From aa864ae5bd3b7a3c389a71aaef88c905f53708b5 Mon Sep 17 00:00:00 2001 From: Sebastian Dröge Date: Fri, 15 May 2015 12:49:19 +0300 Subject: Move all remaining recipes to tarballs --- recipes/tremor/0001-Prevent-symbol-conflicts.patch | 36 + recipes/tremor/0002-Try-fixing-shared-build.patch | 67 ++ recipes/tremor/0003-Map-remaining-symbol-too.patch | 36 + ...04-Fix-build-with-the-Android-NDK-for-x86.patch | 27 + ...05-configure-check-for-machine-endianness.patch | 49 ++ ...r-floor-mapping-residue-function-renaming.patch | 538 ++++++++++++++ .../0007-tremor-more-function-renaming.patch | 797 +++++++++++++++++++++ .../tremor/0008-fix-more-duplicated-symbols.patch | 25 + 8 files changed, 1575 insertions(+) create mode 100644 recipes/tremor/0001-Prevent-symbol-conflicts.patch create mode 100644 recipes/tremor/0002-Try-fixing-shared-build.patch create mode 100644 recipes/tremor/0003-Map-remaining-symbol-too.patch create mode 100644 recipes/tremor/0004-Fix-build-with-the-Android-NDK-for-x86.patch create mode 100644 recipes/tremor/0005-configure-check-for-machine-endianness.patch create mode 100644 recipes/tremor/0006-tremor-floor-mapping-residue-function-renaming.patch create mode 100644 recipes/tremor/0007-tremor-more-function-renaming.patch create mode 100644 recipes/tremor/0008-fix-more-duplicated-symbols.patch (limited to 'recipes/tremor') diff --git a/recipes/tremor/0001-Prevent-symbol-conflicts.patch b/recipes/tremor/0001-Prevent-symbol-conflicts.patch new file mode 100644 index 00000000..e71c173b --- /dev/null +++ b/recipes/tremor/0001-Prevent-symbol-conflicts.patch @@ -0,0 +1,36 @@ +From b879069fd630cf960d87056ce68e16d9ec49b748 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= +Date: Tue, 9 Oct 2012 13:19:58 +0200 +Subject: [PATCH 1/8] Prevent symbol conflicts + +--- + Makefile.am | 2 ++ + vorbisidec.pc.in | 2 +- + 2 files changed, 3 insertions(+), 1 deletion(-) + +diff --git a/Makefile.am b/Makefile.am +index 0a4bb2c..32ca48e 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -7,6 +7,8 @@ pkgconfig_DATA = vorbisidec.pc + + lib_LTLIBRARIES = libvorbisidec.la + ++AM_CFLAGS=-Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward ++ + libvorbisidec_la_SOURCES = mdct.c block.c window.c \ + synthesis.c info.c \ + floor1.c floor0.c vorbisfile.c \ +diff --git a/vorbisidec.pc.in b/vorbisidec.pc.in +index 9c09524..02a134f 100644 +--- a/vorbisidec.pc.in ++++ b/vorbisidec.pc.in +@@ -11,4 +11,4 @@ Version: @VERSION@ + Requires: ogg + Conflicts: + Libs: -L${libdir} -lvorbisidec -lm +-Cflags: -I${includedir} ++Cflags: -I${includedir} -Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward +-- +2.1.4 + diff --git a/recipes/tremor/0002-Try-fixing-shared-build.patch b/recipes/tremor/0002-Try-fixing-shared-build.patch new file mode 100644 index 00000000..039aac64 --- /dev/null +++ b/recipes/tremor/0002-Try-fixing-shared-build.patch @@ -0,0 +1,67 @@ +From c39b87713033ae187f9b87ef51209c38b0e32261 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= +Date: Thu, 11 Oct 2012 14:07:03 +0200 +Subject: [PATCH 2/8] Try fixing shared build + +--- + Version_script.in | 44 ++++++++++++++++++++++---------------------- + 1 file changed, 22 insertions(+), 22 deletions(-) + +diff --git a/Version_script.in b/Version_script.in +index 7f22f2f..2b8d834 100644 +--- a/Version_script.in ++++ b/Version_script.in +@@ -34,28 +34,28 @@ + ov_comment; + ov_read; + +- vorbis_info_init; +- vorbis_info_clear; +- vorbis_info_blocksize; +- vorbis_comment_init; +- vorbis_comment_add; +- vorbis_comment_add_tag; +- vorbis_comment_query; +- vorbis_comment_query_count; +- vorbis_comment_clear; +- vorbis_block_init; +- vorbis_block_clear; +- vorbis_dsp_clear; +- vorbis_synthesis_idheader; +- vorbis_synthesis_headerin; +- vorbis_synthesis_init; +- vorbis_synthesis_restart; +- vorbis_synthesis; +- vorbis_synthesis_trackonly; +- vorbis_synthesis_blockin; +- vorbis_synthesis_pcmout; +- vorbis_synthesis_read; +- vorbis_packet_blocksize; ++ ivorbis_info_init; ++ ivorbis_info_clear; ++ ivorbis_info_blocksize; ++ ivorbis_comment_init; ++ ivorbis_comment_add; ++ ivorbis_comment_add_tag; ++ ivorbis_comment_query; ++ ivorbis_comment_query_count; ++ ivorbis_comment_clear; ++ ivorbis_block_init; ++ ivorbis_block_clear; ++ ivorbis_dsp_clear; ++ ivorbis_synthesis_idheader; ++ ivorbis_synthesis_headerin; ++ ivorbis_synthesis_init; ++ ivorbis_synthesis_restart; ++ ivorbis_synthesis; ++ ivorbis_synthesis_trackonly; ++ ivorbis_synthesis_blockin; ++ ivorbis_synthesis_pcmout; ++ ivorbis_synthesis_read; ++ ivorbis_packet_blocksize; + + local: + *; +-- +2.1.4 + diff --git a/recipes/tremor/0003-Map-remaining-symbol-too.patch b/recipes/tremor/0003-Map-remaining-symbol-too.patch new file mode 100644 index 00000000..eba543f2 --- /dev/null +++ b/recipes/tremor/0003-Map-remaining-symbol-too.patch @@ -0,0 +1,36 @@ +From 280ba02eb19a2067fbc580b9a5b5309f68793321 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= +Date: Thu, 11 Oct 2012 14:09:21 +0200 +Subject: [PATCH 3/8] Map remaining symbol too + +--- + Makefile.am | 2 +- + vorbisidec.pc.in | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/Makefile.am b/Makefile.am +index 32ca48e..5c67508 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -7,7 +7,7 @@ pkgconfig_DATA = vorbisidec.pc + + lib_LTLIBRARIES = libvorbisidec.la + +-AM_CFLAGS=-Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward ++AM_CFLAGS=-Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis=ivorbis_synthesis -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward + + libvorbisidec_la_SOURCES = mdct.c block.c window.c \ + synthesis.c info.c \ +diff --git a/vorbisidec.pc.in b/vorbisidec.pc.in +index 02a134f..a2eb3c9 100644 +--- a/vorbisidec.pc.in ++++ b/vorbisidec.pc.in +@@ -11,4 +11,4 @@ Version: @VERSION@ + Requires: ogg + Conflicts: + Libs: -L${libdir} -lvorbisidec -lm +-Cflags: -I${includedir} -Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward ++Cflags: -I${includedir} -Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis=ivorbis_synthesis -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward +-- +2.1.4 + diff --git a/recipes/tremor/0004-Fix-build-with-the-Android-NDK-for-x86.patch b/recipes/tremor/0004-Fix-build-with-the-Android-NDK-for-x86.patch new file mode 100644 index 00000000..3a659e1d --- /dev/null +++ b/recipes/tremor/0004-Fix-build-with-the-Android-NDK-for-x86.patch @@ -0,0 +1,27 @@ +From e3e85b2c74cd615cf8b1b9a4ed7fe30a6d674515 Mon Sep 17 00:00:00 2001 +From: Andoni Morales Alastruey +Date: Tue, 15 Jan 2013 16:16:53 +0100 +Subject: [PATCH 4/8] Fix build with the Android NDK for x86 + +--- + misc.h | 4 +--- + 1 file changed, 1 insertion(+), 3 deletions(-) + +diff --git a/misc.h b/misc.h +index 1ae4d2e..c855cdd 100644 +--- a/misc.h ++++ b/misc.h +@@ -49,9 +49,7 @@ union magic { + } halves; + ogg_int64_t whole; + }; +-#endif +- +-#if BYTE_ORDER==BIG_ENDIAN ++#else + union magic { + struct { + ogg_int32_t hi; +-- +2.1.4 + diff --git a/recipes/tremor/0005-configure-check-for-machine-endianness.patch b/recipes/tremor/0005-configure-check-for-machine-endianness.patch new file mode 100644 index 00000000..043a7aec --- /dev/null +++ b/recipes/tremor/0005-configure-check-for-machine-endianness.patch @@ -0,0 +1,49 @@ +From b4935b30afbc7a2904f10300a16a9274886b71eb Mon Sep 17 00:00:00 2001 +From: Andoni Morales Alastruey +Date: Fri, 19 Apr 2013 12:33:48 -0300 +Subject: [PATCH 5/8] configure: check for machine endianness + +--- + configure.in | 2 ++ + os.h | 12 ++++++++++++ + 2 files changed, 14 insertions(+) + +diff --git a/configure.in b/configure.in +index e7f5690..684f9c9 100644 +--- a/configure.in ++++ b/configure.in +@@ -99,6 +99,8 @@ dnl -------------------------------------------------- + + AC_CHECK_HEADER(memory.h,CFLAGS="$CFLAGS -DUSE_MEMORY_H",:) + ++AC_CHECK_HEADERS(endian.h machine/endian.h sys/param.h inttypes.h) ++ + dnl -------------------------------------------------- + dnl Check for typedefs, structures, etc + dnl -------------------------------------------------- +diff --git a/os.h b/os.h +index 130d27d..f565b9c 100644 +--- a/os.h ++++ b/os.h +@@ -17,6 +17,18 @@ + + ********************************************************************/ + ++#if HAVE_CONFIG_H ++# include ++#endif ++ ++#if HAVE_ENDIAN_H ++#include ++#elif HAVE_MACHINE_ENDIAN_H ++#include ++#elif HAVE_SYS_PARAM_H ++#include ++#endif ++ + #include + #include + +-- +2.1.4 + diff --git a/recipes/tremor/0006-tremor-floor-mapping-residue-function-renaming.patch b/recipes/tremor/0006-tremor-floor-mapping-residue-function-renaming.patch new file mode 100644 index 00000000..5256ce4a --- /dev/null +++ b/recipes/tremor/0006-tremor-floor-mapping-residue-function-renaming.patch @@ -0,0 +1,538 @@ +From 43c7e123b42bc229e596a0860ed3a4d6ae67c9d2 Mon Sep 17 00:00:00 2001 +From: Thiago Santos +Date: Mon, 22 Apr 2013 08:01:42 -0300 +Subject: [PATCH 6/8] tremor: floor/mapping/residue function renaming + +Prefix _floor_P/_mapping_P/_residue_P and related functions with +ivorbis_ to make sure it doesn't clash with libvorbis' symbols. This +is particularly harmful for iOS applications that link to both libvorbis +and tremor as an iOS app puts all symbols together in the same binary. +--- + block.c | 4 ++-- + floor0.c | 20 ++++++++++---------- + floor1.c | 22 +++++++++++----------- + info.c | 12 ++++++------ + mapping0.c | 28 ++++++++++++++-------------- + registry.c | 32 ++++++++++++++++---------------- + registry.h | 6 +++--- + res012.c | 52 ++++++++++++++++++++++++++-------------------------- + synthesis.c | 2 +- + 9 files changed, 89 insertions(+), 89 deletions(-) + +diff --git a/block.c b/block.c +index 666bc51..098ce23 100644 +--- a/block.c ++++ b/block.c +@@ -190,7 +190,7 @@ static int _vds_init(vorbis_dsp_state *v,vorbis_info *vi){ + for(i=0;imodes;i++){ + int mapnum=ci->mode_param[i]->mapping; + int maptype=ci->map_type[mapnum]; +- b->mode[i]=_mapping_P[maptype]->look(v,ci->mode_param[i], ++ b->mode[i]=_ivorbis_mapping_P[maptype]->look(v,ci->mode_param[i], + ci->map_param[mapnum]); + } + return 0; +@@ -251,7 +251,7 @@ void vorbis_dsp_clear(vorbis_dsp_state *v){ + for(i=0;imodes;i++){ + int mapnum=ci->mode_param[i]->mapping; + int maptype=ci->map_type[mapnum]; +- if(b && b->mode)_mapping_P[maptype]->free_look(b->mode[i]); ++ if(b && b->mode)_ivorbis_mapping_P[maptype]->free_look(b->mode[i]); + } + } + +diff --git a/floor0.c b/floor0.c +index 964383e..2430685 100644 +--- a/floor0.c ++++ b/floor0.c +@@ -288,7 +288,7 @@ void vorbis_lsp_to_curve(ogg_int32_t *curve,int *map,int n,int ln, + + /*************** vorbis decode glue ************/ + +-static void floor0_free_info(vorbis_info_floor *i){ ++static void ivorbis_floor0_free_info(vorbis_info_floor *i){ + vorbis_info_floor0 *info=(vorbis_info_floor0 *)i; + if(info){ + memset(info,0,sizeof(*info)); +@@ -296,7 +296,7 @@ static void floor0_free_info(vorbis_info_floor *i){ + } + } + +-static void floor0_free_look(vorbis_look_floor *i){ ++static void ivorbis_floor0_free_look(vorbis_look_floor *i){ + vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; + if(look){ + +@@ -307,7 +307,7 @@ static void floor0_free_look(vorbis_look_floor *i){ + } + } + +-static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){ ++static vorbis_info_floor *ivorbis_floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int j; + +@@ -333,7 +333,7 @@ static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){ + return(info); + + err_out: +- floor0_free_info(info); ++ ivorbis_floor0_free_info(info); + return(NULL); + } + +@@ -345,7 +345,7 @@ static vorbis_info_floor *floor0_unpack (vorbis_info *vi,oggpack_buffer *opb){ + Note that the scale depends on the sampling rate as well as the + linear block and mapping sizes */ + +-static vorbis_look_floor *floor0_look (vorbis_dsp_state *vd,vorbis_info_mode *mi, ++static vorbis_look_floor *ivorbis_floor0_look (vorbis_dsp_state *vd,vorbis_info_mode *mi, + vorbis_info_floor *i){ + int j; + vorbis_info *vi=vd->vi; +@@ -381,7 +381,7 @@ static vorbis_look_floor *floor0_look (vorbis_dsp_state *vd,vorbis_info_mode *mi + return look; + } + +-static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){ ++static void *ivorbis_floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){ + vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; + vorbis_info_floor0 *info=look->vi; + int j,k; +@@ -412,7 +412,7 @@ static void *floor0_inverse1(vorbis_block *vb,vorbis_look_floor *i){ + return(NULL); + } + +-static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i, ++static int ivorbis_floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i, + void *memo,ogg_int32_t *out){ + vorbis_look_floor0 *look=(vorbis_look_floor0 *)i; + vorbis_info_floor0 *info=look->vi; +@@ -431,9 +431,9 @@ static int floor0_inverse2(vorbis_block *vb,vorbis_look_floor *i, + } + + /* export hooks */ +-vorbis_func_floor floor0_exportbundle={ +- &floor0_unpack,&floor0_look,&floor0_free_info, +- &floor0_free_look,&floor0_inverse1,&floor0_inverse2 ++vorbis_func_floor ivorbis_floor0_exportbundle={ ++ &ivorbis_floor0_unpack,&ivorbis_floor0_look,&ivorbis_floor0_free_info, ++ &ivorbis_floor0_free_look,&ivorbis_floor0_inverse1,&ivorbis_floor0_inverse2 + }; + + +diff --git a/floor1.c b/floor1.c +index e63ae9f..e46fd35 100644 +--- a/floor1.c ++++ b/floor1.c +@@ -26,7 +26,7 @@ + #include "misc.h" + #include "block.h" + +-#define floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */ ++#define ivorbis_floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */ + + typedef struct { + int forward_index[VIF_POSIT+2]; +@@ -43,7 +43,7 @@ typedef struct { + + /***********************************************/ + +-static void floor1_free_info(vorbis_info_floor *i){ ++static void ivorbis_floor1_free_info(vorbis_info_floor *i){ + vorbis_info_floor1 *info=(vorbis_info_floor1 *)i; + if(info){ + memset(info,0,sizeof(*info)); +@@ -51,7 +51,7 @@ static void floor1_free_info(vorbis_info_floor *i){ + } + } + +-static void floor1_free_look(vorbis_look_floor *i){ ++static void ivorbis_floor1_free_look(vorbis_look_floor *i){ + vorbis_look_floor1 *look=(vorbis_look_floor1 *)i; + if(look){ + memset(look,0,sizeof(*look)); +@@ -72,7 +72,7 @@ static int icomp(const void *a,const void *b){ + return(**(int **)a-**(int **)b); + } + +-static vorbis_info_floor *floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){ ++static vorbis_info_floor *ivorbis_floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){ + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; + int j,k,count=0,maxclass=-1,rangebits; + +@@ -132,11 +132,11 @@ static vorbis_info_floor *floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){ + return(info); + + err_out: +- floor1_free_info(info); ++ ivorbis_floor1_free_info(info); + return(NULL); + } + +-static vorbis_look_floor *floor1_look(vorbis_dsp_state *vd,vorbis_info_mode *mi, ++static vorbis_look_floor *ivorbis_floor1_look(vorbis_dsp_state *vd,vorbis_info_mode *mi, + vorbis_info_floor *in){ + + int *sortpointer[VIF_POSIT+2]; +@@ -324,7 +324,7 @@ static void render_line(int n, int x0,int x1,int y0,int y1,ogg_int32_t *d){ + } + } + +-static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){ ++static void *ivorbis_floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){ + vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; + vorbis_info_floor1 *info=look->vi; + codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; +@@ -411,7 +411,7 @@ static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){ + return(NULL); + } + +-static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, ++static int ivorbis_floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, + ogg_int32_t *out){ + vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; + vorbis_info_floor1 *info=look->vi; +@@ -453,8 +453,8 @@ static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, + } + + /* export hooks */ +-vorbis_func_floor floor1_exportbundle={ +- &floor1_unpack,&floor1_look,&floor1_free_info, +- &floor1_free_look,&floor1_inverse1,&floor1_inverse2 ++vorbis_func_floor ivorbis_floor1_exportbundle={ ++ &ivorbis_floor1_unpack,&ivorbis_floor1_look,&ivorbis_floor1_free_info, ++ &ivorbis_floor1_free_look,&ivorbis_floor1_inverse1,&ivorbis_floor1_inverse2 + }; + +diff --git a/info.c b/info.c +index 3f3308e..5c6a8b5 100644 +--- a/info.c ++++ b/info.c +@@ -127,15 +127,15 @@ void vorbis_info_clear(vorbis_info *vi){ + + for(i=0;imaps;i++) /* unpack does the range checking */ + if(ci->map_param[i]) +- _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]); ++ _ivorbis_mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]); + + for(i=0;ifloors;i++) /* unpack does the range checking */ + if(ci->floor_param[i]) +- _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]); ++ _ivorbis_floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]); + + for(i=0;iresidues;i++) /* unpack does the range checking */ + if(ci->residue_param[i]) +- _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]); ++ _ivorbis_residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]); + + for(i=0;ibooks;i++){ + if(ci->book_param[i]){ +@@ -254,7 +254,7 @@ static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ + for(i=0;ifloors;i++){ + ci->floor_type[i]=oggpack_read(opb,16); + if(ci->floor_type[i]<0 || ci->floor_type[i]>=VI_FLOORB)goto err_out; +- ci->floor_param[i]=_floor_P[ci->floor_type[i]]->unpack(vi,opb); ++ ci->floor_param[i]=_ivorbis_floor_P[ci->floor_type[i]]->unpack(vi,opb); + if(!ci->floor_param[i])goto err_out; + } + +@@ -264,7 +264,7 @@ static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ + for(i=0;iresidues;i++){ + ci->residue_type[i]=oggpack_read(opb,16); + if(ci->residue_type[i]<0 || ci->residue_type[i]>=VI_RESB)goto err_out; +- ci->residue_param[i]=_residue_P[ci->residue_type[i]]->unpack(vi,opb); ++ ci->residue_param[i]=_ivorbis_residue_P[ci->residue_type[i]]->unpack(vi,opb); + if(!ci->residue_param[i])goto err_out; + } + +@@ -274,7 +274,7 @@ static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ + for(i=0;imaps;i++){ + ci->map_type[i]=oggpack_read(opb,16); + if(ci->map_type[i]<0 || ci->map_type[i]>=VI_MAPB)goto err_out; +- ci->map_param[i]=_mapping_P[ci->map_type[i]]->unpack(vi,opb); ++ ci->map_param[i]=_ivorbis_mapping_P[ci->map_type[i]]->unpack(vi,opb); + if(!ci->map_param[i])goto err_out; + } + +diff --git a/mapping0.c b/mapping0.c +index aa03e85..56a13a9 100644 +--- a/mapping0.c ++++ b/mapping0.c +@@ -53,7 +53,7 @@ typedef struct { + invalidate decay */ + } vorbis_look_mapping0; + +-static void mapping0_free_info(vorbis_info_mapping *i){ ++static void ivorbis_mapping0_free_info(vorbis_info_mapping *i){ + vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i; + if(info){ + memset(info,0,sizeof(*info)); +@@ -61,7 +61,7 @@ static void mapping0_free_info(vorbis_info_mapping *i){ + } + } + +-static void mapping0_free_look(vorbis_look_mapping *look){ ++static void ivorbis_mapping0_free_look(vorbis_look_mapping *look){ + int i; + vorbis_look_mapping0 *l=(vorbis_look_mapping0 *)look; + if(l){ +@@ -80,7 +80,7 @@ static void mapping0_free_look(vorbis_look_mapping *look){ + } + } + +-static vorbis_look_mapping *mapping0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, ++static vorbis_look_mapping *ivorbis_mapping0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, + vorbis_info_mapping *m){ + int i; + vorbis_info *vi=vd->vi; +@@ -100,10 +100,10 @@ static vorbis_look_mapping *mapping0_look(vorbis_dsp_state *vd,vorbis_info_mode + int floornum=info->floorsubmap[i]; + int resnum=info->residuesubmap[i]; + +- look->floor_func[i]=_floor_P[ci->floor_type[floornum]]; ++ look->floor_func[i]=_ivorbis_floor_P[ci->floor_type[floornum]]; + look->floor_look[i]=look->floor_func[i]-> + look(vd,vm,ci->floor_param[floornum]); +- look->residue_func[i]=_residue_P[ci->residue_type[resnum]]; ++ look->residue_func[i]=_ivorbis_residue_P[ci->residue_type[resnum]]; + look->residue_look[i]=look->residue_func[i]-> + look(vd,vm,ci->residue_param[resnum]); + +@@ -125,7 +125,7 @@ static int ilog(unsigned int v){ + } + + /* also responsible for range checking */ +-static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){ ++static vorbis_info_mapping *ivorbis_mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){ + int i,b; + vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)_ogg_calloc(1,sizeof(*info)); + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; +@@ -178,12 +178,12 @@ static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb) + return info; + + err_out: +- mapping0_free_info(info); ++ ivorbis_mapping0_free_info(info); + return(NULL); + } + + static int seq=0; +-static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){ ++static int ivorbis_mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){ + vorbis_dsp_state *vd=vb->vd; + vorbis_info *vi=vd->vi; + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; +@@ -319,10 +319,10 @@ static int mapping0_inverse(vorbis_block *vb,vorbis_look_mapping *l){ + } + + /* export hooks */ +-vorbis_func_mapping mapping0_exportbundle={ +- &mapping0_unpack, +- &mapping0_look, +- &mapping0_free_info, +- &mapping0_free_look, +- &mapping0_inverse ++vorbis_func_mapping ivorbis_mapping0_exportbundle={ ++ &ivorbis_mapping0_unpack, ++ &ivorbis_mapping0_look, ++ &ivorbis_mapping0_free_info, ++ &ivorbis_mapping0_free_look, ++ &ivorbis_mapping0_inverse + }; +diff --git a/registry.c b/registry.c +index c0b5fec..f02ce0b 100644 +--- a/registry.c ++++ b/registry.c +@@ -24,26 +24,26 @@ + /* seems like major overkill now; the backend numbers will grow into + the infrastructure soon enough */ + +-extern vorbis_func_floor floor0_exportbundle; +-extern vorbis_func_floor floor1_exportbundle; +-extern vorbis_func_residue residue0_exportbundle; +-extern vorbis_func_residue residue1_exportbundle; +-extern vorbis_func_residue residue2_exportbundle; +-extern vorbis_func_mapping mapping0_exportbundle; +- +-vorbis_func_floor *_floor_P[]={ +- &floor0_exportbundle, +- &floor1_exportbundle, ++extern vorbis_func_floor ivorbis_floor0_exportbundle; ++extern vorbis_func_floor ivorbis_floor1_exportbundle; ++extern vorbis_func_residue ivorbis_residue0_exportbundle; ++extern vorbis_func_residue ivorbis_residue1_exportbundle; ++extern vorbis_func_residue ivorbis_residue2_exportbundle; ++extern vorbis_func_mapping ivorbis_mapping0_exportbundle; ++ ++vorbis_func_floor *_ivorbis_floor_P[]={ ++ &ivorbis_floor0_exportbundle, ++ &ivorbis_floor1_exportbundle, + }; + +-vorbis_func_residue *_residue_P[]={ +- &residue0_exportbundle, +- &residue1_exportbundle, +- &residue2_exportbundle, ++vorbis_func_residue *_ivorbis_residue_P[]={ ++ &ivorbis_residue0_exportbundle, ++ &ivorbis_residue1_exportbundle, ++ &ivorbis_residue2_exportbundle, + }; + +-vorbis_func_mapping *_mapping_P[]={ +- &mapping0_exportbundle, ++vorbis_func_mapping *_ivorbis_mapping_P[]={ ++ &ivorbis_mapping0_exportbundle, + }; + + +diff --git a/registry.h b/registry.h +index 2bc8068..0210326 100644 +--- a/registry.h ++++ b/registry.h +@@ -33,8 +33,8 @@ + # define EXTERN extern + #endif + +-EXTERN vorbis_func_floor *_floor_P[]; +-EXTERN vorbis_func_residue *_residue_P[]; +-EXTERN vorbis_func_mapping *_mapping_P[]; ++EXTERN vorbis_func_floor *_ivorbis_floor_P[]; ++EXTERN vorbis_func_residue *_ivorbis_residue_P[]; ++EXTERN vorbis_func_mapping *_ivorbis_mapping_P[]; + + #endif +diff --git a/res012.c b/res012.c +index f036caa..f5ab17f 100644 +--- a/res012.c ++++ b/res012.c +@@ -42,7 +42,7 @@ typedef struct { + + } vorbis_look_residue0; + +-void res0_free_info(vorbis_info_residue *i){ ++void ivorbis_res0_free_info(vorbis_info_residue *i){ + vorbis_info_residue0 *info=(vorbis_info_residue0 *)i; + if(info){ + memset(info,0,sizeof(*info)); +@@ -50,7 +50,7 @@ void res0_free_info(vorbis_info_residue *i){ + } + } + +-void res0_free_look(vorbis_look_residue *i){ ++void ivorbis_res0_free_look(vorbis_look_residue *i){ + int j; + if(i){ + +@@ -87,7 +87,7 @@ static int icount(unsigned int v){ + } + + /* vorbis_info is for range checking */ +-vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){ ++vorbis_info_residue *ivorbis_res0_unpack(vorbis_info *vi,oggpack_buffer *opb){ + int j,acc=0; + vorbis_info_residue0 *info=(vorbis_info_residue0 *)_ogg_calloc(1,sizeof(*info)); + codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; +@@ -147,11 +147,11 @@ vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){ + + return(info); + errout: +- res0_free_info(info); ++ ivorbis_res0_free_info(info); + return(NULL); + } + +-vorbis_look_residue *res0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, ++vorbis_look_residue *ivorbis_res0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, + vorbis_info_residue *vr){ + vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr; + vorbis_look_residue0 *look=(vorbis_look_residue0 *)_ogg_calloc(1,sizeof(*look)); +@@ -266,7 +266,7 @@ static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl, + return(0); + } + +-int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl, ++int ivorbis_res0_inverse(vorbis_block *vb,vorbis_look_residue *vl, + ogg_int32_t **in,int *nonzero,int ch){ + int i,used=0; + for(i=0;imap_type[ci->mode_param[mode]->mapping]; + +- return(_mapping_P[type]->inverse(vb,b->mode[mode])); ++ return(_ivorbis_mapping_P[type]->inverse(vb,b->mode[mode])); + }else{ + /* no pcm */ + vb->pcmend=0; +-- +2.1.4 + diff --git a/recipes/tremor/0007-tremor-more-function-renaming.patch b/recipes/tremor/0007-tremor-more-function-renaming.patch new file mode 100644 index 00000000..925c95c7 --- /dev/null +++ b/recipes/tremor/0007-tremor-more-function-renaming.patch @@ -0,0 +1,797 @@ +From 3c409c5ff76b90e0cef72edf4fc36c02f5c79271 Mon Sep 17 00:00:00 2001 +From: Thiago Santos +Date: Mon, 22 Apr 2013 11:16:30 -0300 +Subject: [PATCH 7/8] tremor: more function renaming + +Add ivorbis prefix to some more functions to avoid clashing with libvorbis +ones' + +As mentioned in the previous commit: +This is particularly harmful for iOS applications that link to both libvorbis +and tremor as an iOS app puts all symbols together in the same binary. +--- + iseeking_example.c | 48 ++++++++--------- + ivorbisfile.h | 58 ++++++++++---------- + ivorbisfile_example.c | 14 ++--- + synthesis.c | 6 +-- + vorbisfile.c | 144 +++++++++++++++++++++++++------------------------- + 5 files changed, 135 insertions(+), 135 deletions(-) + +diff --git a/iseeking_example.c b/iseeking_example.c +index de534eb..c97d252 100644 +--- a/iseeking_example.c ++++ b/iseeking_example.c +@@ -39,27 +39,27 @@ void _verify(OggVorbis_File *ov, + ogg_int64_t pos; + + /* verify the raw position, the pcm position and position decode */ +- if(val!=-1 && ov_raw_tell(ov)pcmval){ ++ if(pcmval!=-1 && ivorbis_ov_pcm_tell(ov)>pcmval){ + fprintf(stderr,"pcm position out of tolerance: requested %ld, got %ld\n", +- (long)pcmval,(long)ov_pcm_tell(ov)); ++ (long)pcmval,(long)ivorbis_ov_pcm_tell(ov)); + exit(1); + } +- if(timeval!=-1 && ov_time_tell(ov)>timeval){ ++ if(timeval!=-1 && ivorbis_ov_time_tell(ov)>timeval){ + fprintf(stderr,"time position out of tolerance: requested %ld, got %ld\n", +- (long)timeval,(long)ov_time_tell(ov)); ++ (long)timeval,(long)ivorbis_ov_time_tell(ov)); + exit(1); + } +- pos=ov_pcm_tell(ov); ++ pos=ivorbis_ov_pcm_tell(ov); + if(pos<0 || pos>pcmlength){ + fprintf(stderr,"pcm position out of bounds: got %ld\n",(long)pos); + exit(1); + } +- bread=ov_read(ov,buffer,4096,&dummy); ++ bread=ivorbis_ov_read(ov,buffer,4096,&dummy); + if(bigassbuffer){ + for(j=0;jchannels!=2){ + fprintf(stderr,"Sorry; right now seeking_test can only use Vorbis files\n" + "that are entirely stereo.\n\n"); +@@ -115,13 +115,13 @@ int main(){ + + /* because we want to do sample-level verification that the seek + does what it claimed, decode the entire file into memory */ +- pcmlength=ov_pcm_total(&ov,-1); +- timelength=ov_time_total(&ov,-1); ++ pcmlength=ivorbis_ov_pcm_total(&ov,-1); ++ timelength=ivorbis_ov_time_total(&ov,-1); + bigassbuffer=malloc(pcmlength*4); /* w00t */ + if(bigassbuffer){ + i=0; + while(ival+1){ ++ if(ivorbis_ov_time_tell(&ov)val+1){ + fprintf(stderr,"Declared position didn't perfectly match request: %ld != %ld\n", +- (long)val,(long)ov_time_tell(&ov)); ++ (long)val,(long)ivorbis_ov_time_tell(&ov)); + exit(1); + } + +@@ -247,7 +247,7 @@ int main(){ + fprintf(stderr,"Standard input was not seekable.\n"); + } + +- ov_clear(&ov); ++ ivorbis_ov_clear(&ov); + return 0; + } + +diff --git a/ivorbisfile.h b/ivorbisfile.h +index fda6205..30f30b8 100644 +--- a/ivorbisfile.h ++++ b/ivorbisfile.h +@@ -42,7 +42,7 @@ typedef struct { + int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); + int (*close_func) (void *datasource); + long (*tell_func) (void *datasource); +-} ov_callbacks; ++} ivorbis_ov_callbacks; + + #define NOTOPEN 0 + #define PARTOPEN 1 +@@ -81,44 +81,44 @@ typedef struct OggVorbis_File { + vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ + vorbis_block vb; /* local working space for packet->PCM decode */ + +- ov_callbacks callbacks; ++ ivorbis_ov_callbacks callbacks; + + } OggVorbis_File; + +-extern int ov_clear(OggVorbis_File *vf); +-extern int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); +-extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf, +- const char *initial, long ibytes, ov_callbacks callbacks); ++extern int ivorbis_ov_clear(OggVorbis_File *vf); ++extern int ivorbis_ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); ++extern int ivorbis_ov_open_callbacks(void *datasource, OggVorbis_File *vf, ++ const char *initial, long ibytes, ivorbis_ov_callbacks callbacks); + +-extern int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); +-extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf, +- const char *initial, long ibytes, ov_callbacks callbacks); +-extern int ov_test_open(OggVorbis_File *vf); ++extern int ivorbis_ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); ++extern int ivorbis_ov_test_callbacks(void *datasource, OggVorbis_File *vf, ++ const char *initial, long ibytes, ivorbis_ov_callbacks callbacks); ++extern int ivorbis_ov_test_open(OggVorbis_File *vf); + +-extern long ov_bitrate(OggVorbis_File *vf,int i); +-extern long ov_bitrate_instant(OggVorbis_File *vf); +-extern long ov_streams(OggVorbis_File *vf); +-extern long ov_seekable(OggVorbis_File *vf); +-extern long ov_serialnumber(OggVorbis_File *vf,int i); ++extern long ivorbis_ov_bitrate(OggVorbis_File *vf,int i); ++extern long ivorbis_ov_bitrate_instant(OggVorbis_File *vf); ++extern long ivorbis_ov_streams(OggVorbis_File *vf); ++extern long ivorbis_ov_seekable(OggVorbis_File *vf); ++extern long ivorbis_ov_serialnumber(OggVorbis_File *vf,int i); + +-extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i); +-extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); +-extern ogg_int64_t ov_time_total(OggVorbis_File *vf,int i); ++extern ogg_int64_t ivorbis_ov_raw_total(OggVorbis_File *vf,int i); ++extern ogg_int64_t ivorbis_ov_pcm_total(OggVorbis_File *vf,int i); ++extern ogg_int64_t ivorbis_ov_time_total(OggVorbis_File *vf,int i); + +-extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); +-extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); +-extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); +-extern int ov_time_seek(OggVorbis_File *vf,ogg_int64_t pos); +-extern int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t pos); ++extern int ivorbis_ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); ++extern int ivorbis_ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); ++extern int ivorbis_ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); ++extern int ivorbis_ov_time_seek(OggVorbis_File *vf,ogg_int64_t pos); ++extern int ivorbis_ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t pos); + +-extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf); +-extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf); +-extern ogg_int64_t ov_time_tell(OggVorbis_File *vf); ++extern ogg_int64_t ivorbis_ov_raw_tell(OggVorbis_File *vf); ++extern ogg_int64_t ivorbis_ov_pcm_tell(OggVorbis_File *vf); ++extern ogg_int64_t ivorbis_ov_time_tell(OggVorbis_File *vf); + +-extern vorbis_info *ov_info(OggVorbis_File *vf,int link); +-extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link); ++extern vorbis_info *ivorbis_ov_info(OggVorbis_File *vf,int link); ++extern vorbis_comment *ivorbis_ov_comment(OggVorbis_File *vf,int link); + +-extern long ov_read(OggVorbis_File *vf,char *buffer,int length, ++extern long ivorbis_ov_read(OggVorbis_File *vf,char *buffer,int length, + int *bitstream); + + #ifdef __cplusplus +diff --git a/ivorbisfile_example.c b/ivorbisfile_example.c +index 7b0cf10..482e33d 100644 +--- a/ivorbisfile_example.c ++++ b/ivorbisfile_example.c +@@ -43,7 +43,7 @@ int main(){ + _setmode( _fileno( stdout ), _O_BINARY ); + #endif + +- if(ov_open(stdin, &vf, NULL, 0) < 0) { ++ if(ivorbis_ov_open(stdin, &vf, NULL, 0) < 0) { + fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n"); + exit(1); + } +@@ -51,20 +51,20 @@ int main(){ + /* Throw the comments plus a few lines about the bitstream we're + decoding */ + { +- char **ptr=ov_comment(&vf,-1)->user_comments; +- vorbis_info *vi=ov_info(&vf,-1); ++ char **ptr=ivorbis_ov_comment(&vf,-1)->user_comments; ++ vorbis_info *vi=ivorbis_ov_info(&vf,-1); + while(*ptr){ + fprintf(stderr,"%s\n",*ptr); + ++ptr; + } + fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate); + fprintf(stderr,"\nDecoded length: %ld samples\n", +- (long)ov_pcm_total(&vf,-1)); +- fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor); ++ (long)ivorbis_ov_pcm_total(&vf,-1)); ++ fprintf(stderr,"Encoded by: %s\n\n",ivorbis_ov_comment(&vf,-1)->vendor); + } + + while(!eof){ +- long ret=ov_read(&vf,pcmout,sizeof(pcmout),¤t_section); ++ long ret=ivorbis_ov_read(&vf,pcmout,sizeof(pcmout),¤t_section); + if (ret == 0) { + /* EOF */ + eof=1; +@@ -84,7 +84,7 @@ int main(){ + } + + /* cleanup */ +- ov_clear(&vf); ++ ivorbis_ov_clear(&vf); + + fprintf(stderr,"Done.\n"); + return(0); +diff --git a/synthesis.c b/synthesis.c +index 1e1d1c7..82148c4 100644 +--- a/synthesis.c ++++ b/synthesis.c +@@ -24,7 +24,7 @@ + #include "misc.h" + #include "block.h" + +-static int _vorbis_synthesis1(vorbis_block *vb,ogg_packet *op,int decodep){ ++static int _ivorbis_synthesis1(vorbis_block *vb,ogg_packet *op,int decodep){ + vorbis_dsp_state *vd= vb ? vb->vd : 0; + private_state *b= vd ? (private_state *)vd->backend_state: 0; + vorbis_info *vi= vd ? vd->vi : 0; +@@ -91,13 +91,13 @@ static int _vorbis_synthesis1(vorbis_block *vb,ogg_packet *op,int decodep){ + } + + int vorbis_synthesis(vorbis_block *vb,ogg_packet *op){ +- return _vorbis_synthesis1(vb,op,1); ++ return _ivorbis_synthesis1(vb,op,1); + } + + /* used to track pcm position without actually performing decode. + Useful for sequential 'fast forward' */ + int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op){ +- return _vorbis_synthesis1(vb,op,0); ++ return _ivorbis_synthesis1(vb,op,0); + } + + long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op){ +diff --git a/vorbisfile.c b/vorbisfile.c +index ac0eb88..5370e7e 100644 +--- a/vorbisfile.c ++++ b/vorbisfile.c +@@ -645,7 +645,7 @@ static int _open_seekable2(OggVorbis_File *vf){ + vf->pcmlengths[0]=pcmoffset; + vf->pcmlengths[1]-=pcmoffset; + +- return(ov_raw_seek(vf,dataoffset)); ++ return(ivorbis_ov_raw_seek(vf,dataoffset)); + } + + /* clear out the current logical bitstream decoder */ +@@ -866,8 +866,8 @@ static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){ + return fseek(f,off,whence); + } + +-static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial, +- long ibytes, ov_callbacks callbacks){ ++static int _ivorbis_ov_open1(void *f,OggVorbis_File *vf,const char *initial, ++ long ibytes, ivorbis_ov_callbacks callbacks){ + int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1); + ogg_uint32_t *serialno_list=NULL; + int serialno_list_size=0; +@@ -904,7 +904,7 @@ static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial, + numbers, load subsequent vorbis setup headers */ + if((ret=_fetch_headers(vf,vf->vi,vf->vc,&serialno_list,&serialno_list_size,NULL))<0){ + vf->datasource=NULL; +- ov_clear(vf); ++ ivorbis_ov_clear(vf); + }else{ + /* serial number list for first link needs to be held somewhere + for second stage of seekable stream open; this saves having to +@@ -925,14 +925,14 @@ static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial, + return(ret); + } + +-static int _ov_open2(OggVorbis_File *vf){ ++static int _ivorbis_ov_open2(OggVorbis_File *vf){ + if(vf->ready_state != PARTOPEN) return OV_EINVAL; + vf->ready_state=OPENED; + if(vf->seekable){ + int ret=_open_seekable2(vf); + if(ret){ + vf->datasource=NULL; +- ov_clear(vf); ++ ivorbis_ov_clear(vf); + } + return(ret); + }else +@@ -943,7 +943,7 @@ static int _ov_open2(OggVorbis_File *vf){ + + + /* clear out the OggVorbis_File struct */ +-int ov_clear(OggVorbis_File *vf){ ++int ivorbis_ov_clear(OggVorbis_File *vf){ + if(vf){ + vorbis_block_clear(&vf->vb); + vorbis_dsp_clear(&vf->vd); +@@ -981,30 +981,30 @@ int ov_clear(OggVorbis_File *vf){ + 0) OK + */ + +-int ov_open_callbacks(void *f,OggVorbis_File *vf, +- const char *initial,long ibytes,ov_callbacks callbacks){ +- int ret=_ov_open1(f,vf,initial,ibytes,callbacks); ++int ivorbis_ov_open_callbacks(void *f,OggVorbis_File *vf, ++ const char *initial,long ibytes,ivorbis_ov_callbacks callbacks){ ++ int ret=_ivorbis_ov_open1(f,vf,initial,ibytes,callbacks); + if(ret)return ret; +- return _ov_open2(vf); ++ return _ivorbis_ov_open2(vf); + } + +-int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){ +- ov_callbacks callbacks = { ++int ivorbis_ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){ ++ ivorbis_ov_callbacks callbacks = { + (size_t (*)(void *, size_t, size_t, void *)) fread, + (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap, + (int (*)(void *)) fclose, + (long (*)(void *)) ftell + }; + +- return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks); ++ return ivorbis_ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks); + } + +-int ov_fopen(const char *path,OggVorbis_File *vf){ ++int ivorbis_ov_fopen(const char *path,OggVorbis_File *vf){ + int ret; + FILE *f = fopen(path,"rb"); + if(!f) return -1; + +- ret = ov_open(f,vf,NULL,0); ++ ret = ivorbis_ov_open(f,vf,NULL,0); + if(ret) fclose(f); + return ret; + } +@@ -1012,38 +1012,38 @@ int ov_fopen(const char *path,OggVorbis_File *vf){ + + /* Only partially open the vorbis file; test for Vorbisness, and load + the headers for the first chain. Do not seek (although test for +- seekability). Use ov_test_open to finish opening the file, else +- ov_clear to close/free it. Same return codes as open. */ ++ seekability). Use ivorbis_ov_test_open to finish opening the file, else ++ ivorbis_ov_clear to close/free it. Same return codes as open. */ + +-int ov_test_callbacks(void *f,OggVorbis_File *vf, +- const char *initial,long ibytes,ov_callbacks callbacks) ++int ivorbis_ov_test_callbacks(void *f,OggVorbis_File *vf, ++ const char *initial,long ibytes,ivorbis_ov_callbacks callbacks) + { +- return _ov_open1(f,vf,initial,ibytes,callbacks); ++ return _ivorbis_ov_open1(f,vf,initial,ibytes,callbacks); + } + +-int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){ +- ov_callbacks callbacks = { ++int ivorbis_ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){ ++ ivorbis_ov_callbacks callbacks = { + (size_t (*)(void *, size_t, size_t, void *)) fread, + (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap, + (int (*)(void *)) fclose, + (long (*)(void *)) ftell + }; + +- return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks); ++ return ivorbis_ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks); + } + +-int ov_test_open(OggVorbis_File *vf){ ++int ivorbis_ov_test_open(OggVorbis_File *vf){ + if(vf->ready_state!=PARTOPEN)return(OV_EINVAL); +- return _ov_open2(vf); ++ return _ivorbis_ov_open2(vf); + } + + /* How many logical bitstreams in this physical bitstream? */ +-long ov_streams(OggVorbis_File *vf){ ++long ivorbis_ov_streams(OggVorbis_File *vf){ + return vf->links; + } + + /* Is the FILE * associated with vf seekable? */ +-long ov_seekable(OggVorbis_File *vf){ ++long ivorbis_ov_seekable(OggVorbis_File *vf){ + return vf->seekable; + } + +@@ -1056,24 +1056,24 @@ long ov_seekable(OggVorbis_File *vf){ + If you want the actual bitrate field settings, get them from the + vorbis_info structs */ + +-long ov_bitrate(OggVorbis_File *vf,int i){ ++long ivorbis_ov_bitrate(OggVorbis_File *vf,int i){ + if(vf->ready_state=vf->links)return(OV_EINVAL); +- if(!vf->seekable && i!=0)return(ov_bitrate(vf,0)); ++ if(!vf->seekable && i!=0)return(ivorbis_ov_bitrate(vf,0)); + if(i<0){ + ogg_int64_t bits=0; + int i; + for(i=0;ilinks;i++) + bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8; +- /* This once read: return(rint(bits/ov_time_total(vf,-1))); ++ /* This once read: return(rint(bits/ivorbis_ov_time_total(vf,-1))); + * gcc 3.x on x86 miscompiled this at optimisation level 2 and above, + * so this is slightly transformed to make it work. + */ +- return(bits*1000/ov_time_total(vf,-1)); ++ return(bits*1000/ivorbis_ov_time_total(vf,-1)); + }else{ + if(vf->seekable){ + /* return the actual bitrate */ +- return((vf->offsets[i+1]-vf->dataoffsets[i])*8000/ov_time_total(vf,i)); ++ return((vf->offsets[i+1]-vf->dataoffsets[i])*8000/ivorbis_ov_time_total(vf,i)); + }else{ + /* return nominal if set */ + if(vf->vi[i].bitrate_nominal>0){ +@@ -1096,7 +1096,7 @@ long ov_bitrate(OggVorbis_File *vf,int i){ + additional data to offer since last call (or at beginning of stream), + EINVAL if stream is only partially open + */ +-long ov_bitrate_instant(OggVorbis_File *vf){ ++long ivorbis_ov_bitrate_instant(OggVorbis_File *vf){ + int link=(vf->seekable?vf->current_link:0); + long ret; + if(vf->ready_state=vf->links)return(ov_serialnumber(vf,vf->links-1)); +- if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1)); ++long ivorbis_ov_serialnumber(OggVorbis_File *vf,int i){ ++ if(i>=vf->links)return(ivorbis_ov_serialnumber(vf,vf->links-1)); ++ if(!vf->seekable && i>=0)return(ivorbis_ov_serialnumber(vf,-1)); + if(i<0){ + return(vf->current_serialno); + }else{ +@@ -1123,14 +1123,14 @@ long ov_serialnumber(OggVorbis_File *vf,int i){ + OV_EINVAL if the stream is not seekable (we can't know the length) + or if stream is only partially open + */ +-ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){ ++ogg_int64_t ivorbis_ov_raw_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return(OV_EINVAL); + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) +- acc+=ov_raw_total(vf,i); ++ acc+=ivorbis_ov_raw_total(vf,i); + return(acc); + }else{ + return(vf->offsets[i+1]-vf->offsets[i]); +@@ -1142,14 +1142,14 @@ ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){ + OV_EINVAL if the stream is not seekable (we can't know the + length) or only partially open + */ +-ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){ ++ogg_int64_t ivorbis_ov_pcm_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return(OV_EINVAL); + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) +- acc+=ov_pcm_total(vf,i); ++ acc+=ivorbis_ov_pcm_total(vf,i); + return(acc); + }else{ + return(vf->pcmlengths[i*2+1]); +@@ -1161,14 +1161,14 @@ ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){ + OV_EINVAL if the stream is not seekable (we can't know the + length) or only partially open + */ +-ogg_int64_t ov_time_total(OggVorbis_File *vf,int i){ ++ogg_int64_t ivorbis_ov_time_total(OggVorbis_File *vf,int i){ + if(vf->ready_stateseekable || i>=vf->links)return(OV_EINVAL); + if(i<0){ + ogg_int64_t acc=0; + int i; + for(i=0;ilinks;i++) +- acc+=ov_time_total(vf,i); ++ acc+=ivorbis_ov_time_total(vf,i); + return(acc); + }else{ + return(((ogg_int64_t)vf->pcmlengths[i*2+1])*1000/vf->vi[i].rate); +@@ -1182,7 +1182,7 @@ ogg_int64_t ov_time_total(OggVorbis_File *vf,int i){ + + returns zero on success, nonzero on failure */ + +-int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){ ++int ivorbis_ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){ + ogg_stream_state work_os; + int ret; + +@@ -1288,7 +1288,7 @@ int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){ + if(!lastblock){ + pagepos=_get_next_page(vf,&og,-1); + if(pagepos<0){ +- vf->pcm_offset=ov_pcm_total(vf,-1); ++ vf->pcm_offset=ivorbis_ov_pcm_total(vf,-1); + break; + } + }else{ +@@ -1387,10 +1387,10 @@ ogg_int64_t rescale64(ogg_int64_t x, ogg_int64_t from, ogg_int64_t to){ + Seek to the last [granule marked] page preceding the specified pos + location, such that decoding past the returned point will quickly + arrive at the requested position. */ +-int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ ++int ivorbis_ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ + int link=-1; + ogg_int64_t result=0; +- ogg_int64_t total=ov_pcm_total(vf,-1); ++ ogg_int64_t total=ivorbis_ov_pcm_total(vf,-1); + + if(vf->ready_stateseekable)return(OV_ENOSEEK); +@@ -1534,7 +1534,7 @@ int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ + if(ogg_page_serialno(&og)==vf->current_serialno && + (ogg_page_granulepos(&og)>-1 || + !ogg_page_continued(&og))){ +- return ov_raw_seek(vf,result); ++ return ivorbis_ov_raw_seek(vf,result); + } + vf->offset=result; + } +@@ -1555,7 +1555,7 @@ int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ + } + + /* verify result */ +- if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){ ++ if(vf->pcm_offset>pos || pos>ivorbis_ov_pcm_total(vf,-1)){ + result=OV_EFAULT; + goto seek_error; + } +@@ -1573,9 +1573,9 @@ int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){ + /* seek to a sample offset relative to the decompressed pcm stream + returns zero on success, nonzero on failure */ + +-int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){ ++int ivorbis_ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){ + int thisblock,lastblock=0; +- int ret=ov_pcm_seek_page(vf,pos); ++ int ret=ivorbis_ov_pcm_seek_page(vf,pos); + if(ret<0)return(ret); + if((ret=_make_decode_ready(vf)))return ret; + +@@ -1661,15 +1661,15 @@ int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){ + + if(samplespcm_offset=ov_pcm_total(vf,-1); /* eof */ ++ vf->pcm_offset=ivorbis_ov_pcm_total(vf,-1); /* eof */ + } + return 0; + } + + /* seek to a playback time relative to the decompressed pcm stream + returns zero on success, nonzero on failure */ +-int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ +- /* translate time to PCM position and call ov_pcm_seek */ ++int ivorbis_ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ ++ /* translate time to PCM position and call ivorbis_ov_pcm_seek */ + + int link=-1; + ogg_int64_t pcm_total=0; +@@ -1681,7 +1681,7 @@ int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ + + /* which bitstream section does this time offset occur in? */ + for(link=0;linklinks;link++){ +- ogg_int64_t addsec = ov_time_total(vf,link); ++ ogg_int64_t addsec = ivorbis_ov_time_total(vf,link); + if(millisecondspcmlengths[link*2+1]; +@@ -1692,14 +1692,14 @@ int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){ + /* enough information to convert time offset to pcm offset */ + { + ogg_int64_t target=pcm_total+(milliseconds-time_total)*vf->vi[link].rate/1000; +- return(ov_pcm_seek(vf,target)); ++ return(ivorbis_ov_pcm_seek(vf,target)); + } + } + +-/* page-granularity version of ov_time_seek ++/* page-granularity version of ivorbis_ov_time_seek + returns zero on success, nonzero on failure */ +-int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t milliseconds){ +- /* translate time to PCM position and call ov_pcm_seek */ ++int ivorbis_ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t milliseconds){ ++ /* translate time to PCM position and call ivorbis_ov_pcm_seek */ + + int link=-1; + ogg_int64_t pcm_total=0; +@@ -1711,7 +1711,7 @@ int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t milliseconds){ + + /* which bitstream section does this time offset occur in? */ + for(link=0;linklinks;link++){ +- ogg_int64_t addsec = ov_time_total(vf,link); ++ ogg_int64_t addsec = ivorbis_ov_time_total(vf,link); + if(millisecondspcmlengths[link*2+1]; +@@ -1722,38 +1722,38 @@ int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t milliseconds){ + /* enough information to convert time offset to pcm offset */ + { + ogg_int64_t target=pcm_total+(milliseconds-time_total)*vf->vi[link].rate/1000; +- return(ov_pcm_seek_page(vf,target)); ++ return(ivorbis_ov_pcm_seek_page(vf,target)); + } + } + + /* tell the current stream offset cursor. Note that seek followed by + tell will likely not give the set offset due to caching */ +-ogg_int64_t ov_raw_tell(OggVorbis_File *vf){ ++ogg_int64_t ivorbis_ov_raw_tell(OggVorbis_File *vf){ + if(vf->ready_stateoffset); + } + + /* return PCM offset (sample) of next PCM sample to be read */ +-ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){ ++ogg_int64_t ivorbis_ov_pcm_tell(OggVorbis_File *vf){ + if(vf->ready_statepcm_offset); + } + + /* return time offset (milliseconds) of next PCM sample to be read */ +-ogg_int64_t ov_time_tell(OggVorbis_File *vf){ ++ogg_int64_t ivorbis_ov_time_tell(OggVorbis_File *vf){ + int link=0; + ogg_int64_t pcm_total=0; + ogg_int64_t time_total=0; + + if(vf->ready_stateseekable){ +- pcm_total=ov_pcm_total(vf,-1); +- time_total=ov_time_total(vf,-1); ++ pcm_total=ivorbis_ov_pcm_total(vf,-1); ++ time_total=ivorbis_ov_time_total(vf,-1); + + /* which bitstream section does this time offset occur in? */ + for(link=vf->links-1;link>=0;link--){ + pcm_total-=vf->pcmlengths[link*2+1]; +- time_total-=ov_time_total(vf,link); ++ time_total-=ivorbis_ov_time_total(vf,link); + if(vf->pcm_offset>=pcm_total)break; + } + } +@@ -1769,7 +1769,7 @@ ogg_int64_t ov_time_tell(OggVorbis_File *vf){ + current bitstream. NULL in the case that the machine is not + initialized */ + +-vorbis_info *ov_info(OggVorbis_File *vf,int link){ ++vorbis_info *ivorbis_ov_info(OggVorbis_File *vf,int link){ + if(vf->seekable){ + if(link<0) + if(vf->ready_state>=STREAMSET) +@@ -1787,7 +1787,7 @@ vorbis_info *ov_info(OggVorbis_File *vf,int link){ + } + + /* grr, strong typing, grr, no templates/inheritence, grr */ +-vorbis_comment *ov_comment(OggVorbis_File *vf,int link){ ++vorbis_comment *ivorbis_ov_comment(OggVorbis_File *vf,int link){ + if(vf->seekable){ + if(link<0) + if(vf->ready_state>=STREAMSET) +@@ -1811,7 +1811,7 @@ vorbis_comment *ov_comment(OggVorbis_File *vf,int link){ + nature must surface: Multiple bitstream sections do not necessarily + have to have the same number of channels or sampling rate. + +- ov_read returns the sequential logical bitstream number currently ++ ivorbis_ov_read returns the sequential logical bitstream number currently + being decoded along with the PCM data in order that the toplevel + application can take action on channel/sample rate changes. This + number will be incremented even for streamed (non-seekable) streams +@@ -1831,7 +1831,7 @@ vorbis_comment *ov_comment(OggVorbis_File *vf,int link){ + + *section) set to the logical bitstream number */ + +-long ov_read(OggVorbis_File *vf,char *buffer,int bytes_req,int *bitstream){ ++long ivorbis_ov_read(OggVorbis_File *vf,char *buffer,int bytes_req,int *bitstream){ + int i,j; + + ogg_int32_t **pcm; +@@ -1860,7 +1860,7 @@ long ov_read(OggVorbis_File *vf,char *buffer,int bytes_req,int *bitstream){ + + /* yay! proceed to pack data into the byte buffer */ + +- long channels=ov_info(vf,-1)->channels; ++ long channels=ivorbis_ov_info(vf,-1)->channels; + + if(samples>(bytes_req/(2*channels))) + samples=bytes_req/(2*channels); +-- +2.1.4 + diff --git a/recipes/tremor/0008-fix-more-duplicated-symbols.patch b/recipes/tremor/0008-fix-more-duplicated-symbols.patch new file mode 100644 index 00000000..ef7055d9 --- /dev/null +++ b/recipes/tremor/0008-fix-more-duplicated-symbols.patch @@ -0,0 +1,25 @@ +From b270cfa95db6da089f8d9f673a8dbcfa51270848 Mon Sep 17 00:00:00 2001 +From: Andoni Morales Alastruey +Date: Wed, 24 Apr 2013 17:44:37 +0200 +Subject: [PATCH 8/8] fix more duplicated symbols + +--- + Makefile.am | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/Makefile.am b/Makefile.am +index 5c67508..6a06a0e 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -7,7 +7,7 @@ pkgconfig_DATA = vorbisidec.pc + + lib_LTLIBRARIES = libvorbisidec.la + +-AM_CFLAGS=-Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis=ivorbis_synthesis -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward ++AM_CFLAGS=-Dvorbis_block_init=ivorbis_block_init -D_vorbis_block_alloc=_ivorbis_block_alloc -D_vorbis_block_ripcord=_ivorbis_block_ripcord -Dvorbis_block_clear=ivorbis_block_clear -Dvorbis_dsp_clear=ivorbis_dsp_clear -Dvorbis_synthesis=ivorbis_synthesis -Dvorbis_synthesis_restart=ivorbis_synthesis_restart -Dvorbis_synthesis_init=ivorbis_synthesis_init -Dvorbis_synthesis_blockin=ivorbis_synthesis_blockin -Dvorbis_synthesis_pcmout=ivorbis_synthesis_pcmout -Dvorbis_synthesis_read=ivorbis_synthesis_read -D_vorbis_apply_window=_ivorbis_apply_window -Dvorbis_comment_init=ivorbis_comment_init -Dvorbis_comment_query=ivorbis_comment_query -Dvorbis_comment_query_count=ivorbis_comment_query_count -Dvorbis_comment_clear=ivorbis_comment_clear -Dvorbis_info_blocksize=ivorbis_info_blocksize -Dvorbis_info_init=ivorbis_info_init -Dvorbis_info_clear=ivorbis_info_clear -Dvorbis_synthesis_idheader=ivorbis_synthesis_idheader -Dvorbis_synthesis_headerin=ivorbis_synthesis_headerin -Dvorbis_staticbook_unpack=ivorbis_staticbook_unpack -Dvorbis_book_decode=ivorbis_book_decode -Dvorbis_book_decodevs_add=ivorbis_book_decodevs_add -Dvorbis_book_decodev_add=ivorbis_book_decodev_add -Dvorbis_book_decodev_set=ivorbis_book_decodev_set -Dvorbis_book_decodevv_add=ivorbis_book_decodevv_add -D_ilog=_iilog -D_make_words=_imake_words -D_book_maptype1_quantvals=_ibook_maptype1_quantvals -D_book_unquantize=_ibook_unquantize -Dvorbis_staticbook_destroy=ivorbis_staticbook_destroy -Dvorbis_book_clear=ivorbis_book_clear -Dvorbis_book_init_decode=ivorbis_book_init_decode -Dmdct_backward=imdct_backward -Dvorbis_packet_blocksize=ivorbis_packet_blocksize -Dvorbis_synthesis_trackonly=ivorbis_synthesis_trackonly -Dvorbis_lsp_to_curve=ivorbis_lsp_to_curve + + libvorbisidec_la_SOURCES = mdct.c block.c window.c \ + synthesis.c info.c \ +-- +2.1.4 + -- cgit v1.2.3