← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/configure

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/configure
1
1
#! /bin/sh
2
2
# From configure.ac Revision.
3
3
# Guess values for system-dependent variables and create Makefiles.
4
 
# Generated by GNU Autoconf 2.68 for sflphone 1.3.0.
 
4
# Generated by GNU Autoconf 2.68 for sflphone 1.4.1.
5
5
#
6
6
# Report bugs to <sflphoneteam@savoirfairelinux.com>.
7
7
#
14
14
# This configure script is free software; the Free Software Foundation
15
15
# gives unlimited permission to copy, distribute and modify it.
16
16
#
17
 
# Copyright (c) Savoir-Faire Linux 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
 
17
# Copyright (c) Savoir-Faire Linux 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
18
18
## -------------------- ##
19
19
## M4sh Initialization. ##
20
20
## -------------------- ##
573
573
# Identity of this package.
574
574
PACKAGE_NAME='sflphone'
575
575
PACKAGE_TARNAME='sflphone'
576
 
PACKAGE_VERSION='1.3.0'
577
 
PACKAGE_STRING='sflphone 1.3.0'
 
576
PACKAGE_VERSION='1.4.1'
 
577
PACKAGE_STRING='sflphone 1.4.1'
578
578
PACKAGE_BUGREPORT='sflphoneteam@savoirfairelinux.com'
579
579
PACKAGE_URL=''
580
580
 
624
624
ENABLE_DOXYGEN_TRUE
625
625
DOT
626
626
DOXYGEN
 
627
BUILD_IPV6_FALSE
 
628
BUILD_IPV6_TRUE
627
629
USE_NETWORKMANAGER_FALSE
628
630
USE_NETWORKMANAGER_TRUE
629
631
USE_IAX_FALSE
648
650
BUILD_TEST_TRUE
649
651
BUILD_SDES_FALSE
650
652
BUILD_SDES_TRUE
 
653
PCRE_LIBS
651
654
PCRE_CFLAGS
652
 
PCRE_LIBS
653
655
PTHREAD_CFLAGS
654
656
PTHREAD_LIBS
655
657
PTHREAD_CC
656
658
ax_pthread_config
657
659
BUILD_INSTANT_MESSAGING_FALSE
658
660
BUILD_INSTANT_MESSAGING_TRUE
659
 
EXPAT_VERSION
660
661
EXPAT_LIBS
661
662
EXPAT_CFLAGS
 
663
USE_DBUS_FALSE
 
664
USE_DBUS_TRUE
 
665
HAVE_DBUSXML2CPP
662
666
DBUSCPP_LIBS
663
667
DBUSCPP_CFLAGS
664
668
BUILD_ZRTP_FALSE
667
671
ZRTPCPP_CFLAGS
668
672
BUILD_TLS_FALSE
669
673
BUILD_TLS_TRUE
670
 
libssl_LIBS
671
 
libssl_CFLAGS
 
674
GNUTLS_LIBS
 
675
GNUTLS_CFLAGS
672
676
SFL_PRESENCE_FALSE
673
677
SFL_PRESENCE_TRUE
674
678
CCRTP_LIBS
675
679
CCRTP_CFLAGS
676
 
CCGNU2_LIBS
677
 
CCGNU2_CFLAGS
678
680
UDEV_LIBS
679
681
UDEV_CFLAGS
680
682
LIBAVUTIL_LIBS
693
695
SNDFILE_CFLAGS
694
696
SAMPLERATE_LIBS
695
697
SAMPLERATE_CFLAGS
 
698
BUILD_JACK_FALSE
 
699
BUILD_JACK_TRUE
 
700
JACK_LIBS
 
701
JACK_CFLAGS
696
702
BUILD_PULSE_FALSE
697
703
BUILD_PULSE_TRUE
698
704
PULSEAUDIO_LIBS
701
707
BUILD_ALSA_TRUE
702
708
ALSA_LIBS
703
709
ALSA_CFLAGS
704
 
LIBCRYPTO_LIBS
705
 
LIBCRYPTO_CFLAGS
 
710
BUILD_OPENSL_FALSE
 
711
BUILD_OPENSL_TRUE
706
712
YAML_LIBS
707
 
UUID_LIBS
708
 
UUID_CFLAGS
 
713
YAML_CFLAGS
 
714
USE_ANDROID_FALSE
 
715
USE_ANDROID_TRUE
709
716
PKG_CONFIG_LIBDIR
710
717
PKG_CONFIG_PATH
711
718
PKG_CONFIG
746
753
ac_ct_CXX
747
754
CXXFLAGS
748
755
CXX
 
756
AM_BACKSLASH
 
757
AM_DEFAULT_VERBOSITY
 
758
AM_DEFAULT_V
 
759
AM_V
749
760
am__fastdepCC_FALSE
750
761
am__fastdepCC_TRUE
751
762
CCDEPMODE
830
841
ac_user_opts='
831
842
enable_option_checking
832
843
enable_dependency_tracking
 
844
enable_silent_rules
833
845
enable_shared
834
846
enable_static
835
847
with_pic
837
849
with_gnu_ld
838
850
with_sysroot
839
851
enable_libtool_lock
 
852
with_opensl
840
853
with_alsa
841
854
with_pulse
 
855
with_jack
842
856
enable_coverage
843
857
enable_video
844
858
enable_presence
846
860
with_zrtp
847
861
with_dbus
848
862
with_instant_messaging
849
 
with_expat
850
 
with_expat_inc
851
 
with_expat_lib
852
863
with_sdes
853
 
with_pcre
854
864
with_gsm
855
865
with_speex
856
866
with_speexdsp
858
868
with_with_opus
859
869
with_iax2
860
870
with_networkmanager
 
871
enable_ipv6
861
872
enable_doxygen
862
873
enable_dot
863
874
enable_debug
878
889
PKG_CONFIG
879
890
PKG_CONFIG_PATH
880
891
PKG_CONFIG_LIBDIR
881
 
UUID_CFLAGS
882
 
UUID_LIBS
883
 
LIBCRYPTO_CFLAGS
884
 
LIBCRYPTO_LIBS
 
892
YAML_CFLAGS
 
893
YAML_LIBS
885
894
ALSA_CFLAGS
886
895
ALSA_LIBS
887
896
PULSEAUDIO_CFLAGS
888
897
PULSEAUDIO_LIBS
 
898
JACK_CFLAGS
 
899
JACK_LIBS
889
900
SAMPLERATE_CFLAGS
890
901
SAMPLERATE_LIBS
891
902
SNDFILE_CFLAGS
902
913
LIBAVUTIL_LIBS
903
914
UDEV_CFLAGS
904
915
UDEV_LIBS
905
 
CCGNU2_CFLAGS
906
 
CCGNU2_LIBS
907
916
CCRTP_CFLAGS
908
917
CCRTP_LIBS
909
 
libssl_CFLAGS
910
 
libssl_LIBS
 
918
GNUTLS_CFLAGS
 
919
GNUTLS_LIBS
911
920
ZRTPCPP_CFLAGS
912
921
ZRTPCPP_LIBS
913
922
DBUSCPP_CFLAGS
914
923
DBUSCPP_LIBS
 
924
EXPAT_CFLAGS
 
925
EXPAT_LIBS
 
926
PCRE_CFLAGS
 
927
PCRE_LIBS
915
928
CPPUNIT_CFLAGS
916
929
CPPUNIT_LIBS
917
930
libilbc_CFLAGS
918
931
libilbc_LIBS
919
932
opus_CFLAGS
920
933
opus_LIBS'
921
 
ac_subdirs_all='libs/pjproject-2.1.0'
 
934
ac_subdirs_all='libs/pjproject-2.2.1'
922
935
 
923
936
# Initialize some variables set by options.
924
937
ac_init_help=
1460
1473
  # Omit some internal or obsolete options to make the list less imposing.
1461
1474
  # This message is too long to be a string in the A/UX 3.1 sh.
1462
1475
  cat <<_ACEOF
1463
 
\`configure' configures sflphone 1.3.0 to adapt to many kinds of systems.
 
1476
\`configure' configures sflphone 1.4.1 to adapt to many kinds of systems.
1464
1477
 
1465
1478
Usage: $0 [OPTION]... [VAR=VALUE]...
1466
1479
 
1530
1543
 
1531
1544
if test -n "$ac_init_help"; then
1532
1545
  case $ac_init_help in
1533
 
     short | recursive ) echo "Configuration of sflphone 1.3.0:";;
 
1546
     short | recursive ) echo "Configuration of sflphone 1.4.1:";;
1534
1547
   esac
1535
1548
  cat <<\_ACEOF
1536
1549
 
1540
1553
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1541
1554
  --disable-dependency-tracking  speeds up one-time build
1542
1555
  --enable-dependency-tracking   do not reject slow dependency extractors
 
1556
  --enable-silent-rules          less verbose build output (undo: `make V=1')
 
1557
  --disable-silent-rules         verbose build output (undo: `make V=0')
1543
1558
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1544
1559
  --enable-static[=PKGS]  build static libraries [default=yes]
1545
1560
  --enable-fast-install[=PKGS]
1546
1561
                          optimize for fast installation [default=yes]
1547
1562
  --disable-libtool-lock  avoid locking (might break parallel builds)
1548
1563
  --enable-coverage       Enable coverage
1549
 
  --enable-video          Enable video
 
1564
  --disable-video         Disable video
1550
1565
  --disable-presence      Disable SIP presence support
 
1566
  --enable-ipv6           Enable IPv6 support
1551
1567
  --enable-doxygen        enable documentation generation with doxygen (disabled by default)
1552
1568
  --enable-dot            use 'dot' to generate graphs in doxygen (auto)
1553
1569
  --enable-debug          Build in debug mode, adds stricter warnings,
1561
1577
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1562
1578
  --with-sysroot=DIR Search for dependent libraries within DIR
1563
1579
                        (or the compiler's sysroot if not specified).
1564
 
   --without-alsa          disable support for alsa
1565
 
   --without-pulse         disable support for pulseaudio
1566
 
   --without-tls           disable support for tls
1567
 
   --without-zrtp          disable support for zrtp
 
1580
  --without-opensl        Ignore presence of opensl and disable it
 
1581
  --without-alsa          disable support for alsa
 
1582
  --without-pulse         disable support for pulseaudio
 
1583
  --without-jack          Ignore presence of jack and disable it
 
1584
  --without-tls           disable support for tls
 
1585
  --without-zrtp          disable support for zrtp
1568
1586
  --without-dbus          disable support for dbus
1569
 
   --without-instant_messaging
 
1587
  --without-instant_messaging
1570
1588
                          disable support for instant-messaging
1571
 
  --with-expat=[ARG]      use Expat XML Parser from given prefix (ARG=path);
1572
 
                          check standard prefixes (ARG=yes); disable (ARG=no)
1573
 
  --with-expat-inc=[DIR]  path to Expat XML Parser headers
1574
 
  --with-expat-lib=[ARG]  link options for Expat XML Parser libraries
1575
 
   --without-sdes          disable support for sdes key exchange
1576
 
  --with-pcre[=prefix]    compile xmlpcre part (via libpcre check)
 
1589
  --without-sdes          disable support for sdes key exchange
1577
1590
  --without-gsm           disable support for gsm codec
1578
1591
  --without-speex         disable support for speex codec
1579
1592
  --without-speexdsp      disable support for speexdp Noise Suppression and
1601
1614
              directories to add to pkg-config's search path
1602
1615
  PKG_CONFIG_LIBDIR
1603
1616
              path overriding pkg-config's built-in search path
1604
 
  UUID_CFLAGS C compiler flags for UUID, overriding pkg-config
1605
 
  UUID_LIBS   linker flags for UUID, overriding pkg-config
1606
 
  LIBCRYPTO_CFLAGS
1607
 
              C compiler flags for LIBCRYPTO, overriding pkg-config
1608
 
  LIBCRYPTO_LIBS
1609
 
              linker flags for LIBCRYPTO, overriding pkg-config
 
1617
  YAML_CFLAGS C compiler flags for YAML, overriding pkg-config
 
1618
  YAML_LIBS   linker flags for YAML, overriding pkg-config
1610
1619
  ALSA_CFLAGS C compiler flags for ALSA, overriding pkg-config
1611
1620
  ALSA_LIBS   linker flags for ALSA, overriding pkg-config
1612
1621
  PULSEAUDIO_CFLAGS
1613
1622
              C compiler flags for PULSEAUDIO, overriding pkg-config
1614
1623
  PULSEAUDIO_LIBS
1615
1624
              linker flags for PULSEAUDIO, overriding pkg-config
 
1625
  JACK_CFLAGS C compiler flags for JACK, overriding pkg-config
 
1626
  JACK_LIBS   linker flags for JACK, overriding pkg-config
1616
1627
  SAMPLERATE_CFLAGS
1617
1628
              C compiler flags for SAMPLERATE, overriding pkg-config
1618
1629
  SAMPLERATE_LIBS
1643
1654
              linker flags for LIBAVUTIL, overriding pkg-config
1644
1655
  UDEV_CFLAGS C compiler flags for UDEV, overriding pkg-config
1645
1656
  UDEV_LIBS   linker flags for UDEV, overriding pkg-config
1646
 
  CCGNU2_CFLAGS
1647
 
              C compiler flags for CCGNU2, overriding pkg-config
1648
 
  CCGNU2_LIBS linker flags for CCGNU2, overriding pkg-config
1649
1657
  CCRTP_CFLAGS
1650
1658
              C compiler flags for CCRTP, overriding pkg-config
1651
1659
  CCRTP_LIBS  linker flags for CCRTP, overriding pkg-config
1652
 
  libssl_CFLAGS
1653
 
              C compiler flags for libssl, overriding pkg-config
1654
 
  libssl_LIBS linker flags for libssl, overriding pkg-config
 
1660
  GNUTLS_CFLAGS
 
1661
              C compiler flags for GNUTLS, overriding pkg-config
 
1662
  GNUTLS_LIBS linker flags for GNUTLS, overriding pkg-config
1655
1663
  ZRTPCPP_CFLAGS
1656
1664
              C compiler flags for ZRTPCPP, overriding pkg-config
1657
1665
  ZRTPCPP_LIBS
1660
1668
              C compiler flags for DBUSCPP, overriding pkg-config
1661
1669
  DBUSCPP_LIBS
1662
1670
              linker flags for DBUSCPP, overriding pkg-config
 
1671
  EXPAT_CFLAGS
 
1672
              C compiler flags for EXPAT, overriding pkg-config
 
1673
  EXPAT_LIBS  linker flags for EXPAT, overriding pkg-config
 
1674
  PCRE_CFLAGS C compiler flags for PCRE, overriding pkg-config
 
1675
  PCRE_LIBS   linker flags for PCRE, overriding pkg-config
1663
1676
  CPPUNIT_CFLAGS
1664
1677
              C compiler flags for CPPUNIT, overriding pkg-config
1665
1678
  CPPUNIT_LIBS
1737
1750
test -n "$ac_init_help" && exit $ac_status
1738
1751
if $ac_init_version; then
1739
1752
  cat <<\_ACEOF
1740
 
sflphone configure 1.3.0
 
1753
sflphone configure 1.4.1
1741
1754
generated by GNU Autoconf 2.68
1742
1755
 
1743
1756
Copyright (C) 2010 Free Software Foundation, Inc.
1744
1757
This configure script is free software; the Free Software Foundation
1745
1758
gives unlimited permission to copy, distribute and modify it.
1746
1759
 
1747
 
Copyright (c) Savoir-Faire Linux 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
 
1760
Copyright (c) Savoir-Faire Linux 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
1748
1761
_ACEOF
1749
1762
  exit
1750
1763
fi
2392
2405
This file contains any messages produced by compilers while
2393
2406
running configure, to aid debugging if configure makes a mistake.
2394
2407
 
2395
 
It was created by sflphone $as_me 1.3.0, which was
 
2408
It was created by sflphone $as_me 1.4.1, which was
2396
2409
generated by GNU Autoconf 2.68.  Invocation command line was
2397
2410
 
2398
2411
  $ $0 $@
2744
2757
 
2745
2758
 
2746
2759
 
2747
 
 
2748
2760
ac_aux_dir=
2749
2761
for ac_dir in build-aux "$srcdir"/build-aux; do
2750
2762
  if test -f "$ac_dir/install-sh"; then
3212
3224
 
3213
3225
# Define the identity of the package.
3214
3226
 PACKAGE='sflphone'
3215
 
 VERSION='1.3.0'
 
3227
 VERSION='1.4.1'
3216
3228
 
3217
3229
 
3218
3230
cat >>confdefs.h <<_ACEOF
4398
4410
 
4399
4411
 
4400
4412
# Silent build by default. Use make V=1 to increase verbosity
4401
 
#m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 
4413
# Check whether --enable-silent-rules was given.
 
4414
if test "${enable_silent_rules+set}" = set; then :
 
4415
  enableval=$enable_silent_rules;
 
4416
fi
 
4417
 
 
4418
case $enable_silent_rules in
 
4419
yes) AM_DEFAULT_VERBOSITY=0;;
 
4420
no)  AM_DEFAULT_VERBOSITY=1;;
 
4421
*)   AM_DEFAULT_VERBOSITY=0;;
 
4422
esac
 
4423
am_make=${MAKE-make}
 
4424
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
 
4425
$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
 
4426
if ${am_cv_make_support_nested_variables+:} false; then :
 
4427
  $as_echo_n "(cached) " >&6
 
4428
else
 
4429
  if $as_echo 'TRUE=$(BAR$(V))
 
4430
BAR0=false
 
4431
BAR1=true
 
4432
V=1
 
4433
am__doit:
 
4434
        @$(TRUE)
 
4435
.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
 
4436
  am_cv_make_support_nested_variables=yes
 
4437
else
 
4438
  am_cv_make_support_nested_variables=no
 
4439
fi
 
4440
fi
 
4441
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
 
4442
$as_echo "$am_cv_make_support_nested_variables" >&6; }
 
4443
if test $am_cv_make_support_nested_variables = yes; then
 
4444
    AM_V='$(V)'
 
4445
  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
 
4446
else
 
4447
  AM_V=$AM_DEFAULT_VERBOSITY
 
4448
  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
 
4449
fi
 
4450
AM_BACKSLASH='\'
 
4451
 
4402
4452
 
4403
4453
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4404
4454
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
16339
16389
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
16340
16390
 
16341
16391
 
16342
 
    ax_cxx_compile_cxx11_required=truednl
 
16392
    ax_cxx_compile_cxx11_required=true
16343
16393
  ac_ext=cpp
16344
16394
ac_cpp='$CXXCPP $CPPFLAGS'
16345
16395
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
16370
16420
    check_type&& cr = static_cast<check_type&&>(c);
16371
16421
 
16372
16422
    auto d = a;
 
16423
    auto l = [](){};
16373
16424
 
16374
16425
_ACEOF
16375
16426
if ac_fn_cxx_try_compile "$LINENO"; then :
16385
16436
    ac_success=yes
16386
16437
  fi
16387
16438
 
16388
 
    if test x$ac_success = xno; then
16389
 
    for switch in -std=gnu++11 -std=gnu++0x; do
16390
 
      cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
16391
 
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
16392
 
$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
16393
 
if eval \${$cachevar+:} false; then :
16394
 
  $as_echo_n "(cached) " >&6
16395
 
else
16396
 
  ac_save_CXXFLAGS="$CXXFLAGS"
16397
 
         CXXFLAGS="$CXXFLAGS $switch"
16398
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
16399
 
/* end confdefs.h.  */
16400
 
 
16401
 
  template <typename T>
16402
 
    struct check
16403
 
    {
16404
 
      static_assert(sizeof(int) <= sizeof(T), "not big enough");
16405
 
    };
16406
 
 
16407
 
    typedef check<check<bool>> right_angle_brackets;
16408
 
 
16409
 
    int a;
16410
 
    decltype(a) b;
16411
 
 
16412
 
    typedef check<int> check_type;
16413
 
    check_type c;
16414
 
    check_type&& cr = static_cast<check_type&&>(c);
16415
 
 
16416
 
    auto d = a;
16417
 
 
16418
 
_ACEOF
16419
 
if ac_fn_cxx_try_compile "$LINENO"; then :
16420
 
  eval $cachevar=yes
16421
 
else
16422
 
  eval $cachevar=no
16423
 
fi
16424
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
16425
 
         CXXFLAGS="$ac_save_CXXFLAGS"
16426
 
fi
16427
 
eval ac_res=\$$cachevar
16428
 
               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
16429
 
$as_echo "$ac_res" >&6; }
16430
 
      if eval test x\$$cachevar = xyes; then
16431
 
        CXXFLAGS="$CXXFLAGS $switch"
16432
 
        ac_success=yes
16433
 
        break
16434
 
      fi
16435
 
    done
16436
 
  fi
 
16439
 
16437
16440
 
16438
16441
    if test x$ac_success = xno; then
16439
16442
    for switch in -std=c++11 -std=c++0x; do
16464
16467
    check_type&& cr = static_cast<check_type&&>(c);
16465
16468
 
16466
16469
    auto d = a;
 
16470
    auto l = [](){};
16467
16471
 
16468
16472
_ACEOF
16469
16473
if ac_fn_cxx_try_compile "$LINENO"; then :
17320
17324
        fi
17321
17325
fi
17322
17326
 
17323
 
 
17324
 
UUID_MIN_VERSION=1.0
17325
 
 
17326
 
pkg_failed=no
17327
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for UUID" >&5
17328
 
$as_echo_n "checking for UUID... " >&6; }
17329
 
 
17330
 
if test -n "$UUID_CFLAGS"; then
17331
 
    pkg_cv_UUID_CFLAGS="$UUID_CFLAGS"
17332
 
 elif test -n "$PKG_CONFIG"; then
17333
 
    if test -n "$PKG_CONFIG" && \
17334
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"uuid >= \${UUID_MIN_VERSION}\""; } >&5
17335
 
  ($PKG_CONFIG --exists --print-errors "uuid >= ${UUID_MIN_VERSION}") 2>&5
17336
 
  ac_status=$?
17337
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
17338
 
  test $ac_status = 0; }; then
17339
 
  pkg_cv_UUID_CFLAGS=`$PKG_CONFIG --cflags "uuid >= ${UUID_MIN_VERSION}" 2>/dev/null`
17340
 
                      test "x$?" != "x0" && pkg_failed=yes
17341
 
else
17342
 
  pkg_failed=yes
17343
 
fi
17344
 
 else
17345
 
    pkg_failed=untried
17346
 
fi
17347
 
if test -n "$UUID_LIBS"; then
17348
 
    pkg_cv_UUID_LIBS="$UUID_LIBS"
17349
 
 elif test -n "$PKG_CONFIG"; then
17350
 
    if test -n "$PKG_CONFIG" && \
17351
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"uuid >= \${UUID_MIN_VERSION}\""; } >&5
17352
 
  ($PKG_CONFIG --exists --print-errors "uuid >= ${UUID_MIN_VERSION}") 2>&5
17353
 
  ac_status=$?
17354
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
17355
 
  test $ac_status = 0; }; then
17356
 
  pkg_cv_UUID_LIBS=`$PKG_CONFIG --libs "uuid >= ${UUID_MIN_VERSION}" 2>/dev/null`
17357
 
                      test "x$?" != "x0" && pkg_failed=yes
17358
 
else
17359
 
  pkg_failed=yes
17360
 
fi
17361
 
 else
17362
 
    pkg_failed=untried
17363
 
fi
17364
 
 
17365
 
 
17366
 
 
17367
 
if test $pkg_failed = yes; then
17368
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17369
 
$as_echo "no" >&6; }
17370
 
 
17371
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
17372
 
        _pkg_short_errors_supported=yes
17373
 
else
17374
 
        _pkg_short_errors_supported=no
17375
 
fi
17376
 
        if test $_pkg_short_errors_supported = yes; then
17377
 
                UUID_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "uuid >= ${UUID_MIN_VERSION}" 2>&1`
17378
 
        else
17379
 
                UUID_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "uuid >= ${UUID_MIN_VERSION}" 2>&1`
17380
 
        fi
17381
 
        # Put the nasty error message in config.log where it belongs
17382
 
        echo "$UUID_PKG_ERRORS" >&5
17383
 
 
17384
 
        HAVE_UUID=false
17385
 
elif test $pkg_failed = untried; then
17386
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17387
 
$as_echo "no" >&6; }
17388
 
        HAVE_UUID=false
17389
 
else
17390
 
        UUID_CFLAGS=$pkg_cv_UUID_CFLAGS
17391
 
        UUID_LIBS=$pkg_cv_UUID_LIBS
17392
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17393
 
$as_echo "yes" >&6; }
17394
 
        HAVE_UUID=true
17395
 
fi;
17396
 
 
17397
 
 
17398
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing yaml_parser_initialize" >&5
17399
 
$as_echo_n "checking for library containing yaml_parser_initialize... " >&6; }
17400
 
if ${ac_cv_search_yaml_parser_initialize+:} false; then :
17401
 
  $as_echo_n "(cached) " >&6
17402
 
else
17403
 
  ac_func_search_save_LIBS=$LIBS
17404
 
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
17405
 
/* end confdefs.h.  */
17406
 
 
17407
 
/* Override any GCC internal prototype to avoid an error.
17408
 
   Use char because int might match the return type of a GCC
17409
 
   builtin and then its argument prototype would still apply.  */
17410
 
#ifdef __cplusplus
17411
 
extern "C"
17412
 
#endif
17413
 
char yaml_parser_initialize ();
17414
 
int
17415
 
main ()
17416
 
{
17417
 
return yaml_parser_initialize ();
17418
 
  ;
17419
 
  return 0;
17420
 
}
17421
 
_ACEOF
17422
 
for ac_lib in '' yaml; do
17423
 
  if test -z "$ac_lib"; then
17424
 
    ac_res="none required"
17425
 
  else
17426
 
    ac_res=-l$ac_lib
17427
 
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
17428
 
  fi
17429
 
  if ac_fn_cxx_try_link "$LINENO"; then :
17430
 
  ac_cv_search_yaml_parser_initialize=$ac_res
17431
 
fi
17432
 
rm -f core conftest.err conftest.$ac_objext \
17433
 
    conftest$ac_exeext
17434
 
  if ${ac_cv_search_yaml_parser_initialize+:} false; then :
17435
 
  break
17436
 
fi
17437
 
done
17438
 
if ${ac_cv_search_yaml_parser_initialize+:} false; then :
17439
 
 
17440
 
else
17441
 
  ac_cv_search_yaml_parser_initialize=no
17442
 
fi
17443
 
rm conftest.$ac_ext
17444
 
LIBS=$ac_func_search_save_LIBS
17445
 
fi
17446
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_yaml_parser_initialize" >&5
17447
 
$as_echo "$ac_cv_search_yaml_parser_initialize" >&6; }
17448
 
ac_res=$ac_cv_search_yaml_parser_initialize
17449
 
if test "$ac_res" != no; then :
17450
 
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
17451
 
  YAML_LIBS=-lyaml
17452
 
 
17453
 
else
17454
 
 
17455
 
       as_fn_error $? "Unable to find yaml development files" "$LINENO" 5
17456
 
fi
17457
 
 
17458
 
 
17459
 
 
17460
 
LIBCRYPTO_MIN_VERSION=1.0
17461
 
 
17462
 
pkg_failed=no
17463
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBCRYPTO" >&5
17464
 
$as_echo_n "checking for LIBCRYPTO... " >&6; }
17465
 
 
17466
 
if test -n "$LIBCRYPTO_CFLAGS"; then
17467
 
    pkg_cv_LIBCRYPTO_CFLAGS="$LIBCRYPTO_CFLAGS"
17468
 
 elif test -n "$PKG_CONFIG"; then
17469
 
    if test -n "$PKG_CONFIG" && \
17470
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libcrypto >= \${LIBCRYPTO_MIN_VERSION}\""; } >&5
17471
 
  ($PKG_CONFIG --exists --print-errors "libcrypto >= ${LIBCRYPTO_MIN_VERSION}") 2>&5
17472
 
  ac_status=$?
17473
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
17474
 
  test $ac_status = 0; }; then
17475
 
  pkg_cv_LIBCRYPTO_CFLAGS=`$PKG_CONFIG --cflags "libcrypto >= ${LIBCRYPTO_MIN_VERSION}" 2>/dev/null`
17476
 
                      test "x$?" != "x0" && pkg_failed=yes
17477
 
else
17478
 
  pkg_failed=yes
17479
 
fi
17480
 
 else
17481
 
    pkg_failed=untried
17482
 
fi
17483
 
if test -n "$LIBCRYPTO_LIBS"; then
17484
 
    pkg_cv_LIBCRYPTO_LIBS="$LIBCRYPTO_LIBS"
17485
 
 elif test -n "$PKG_CONFIG"; then
17486
 
    if test -n "$PKG_CONFIG" && \
17487
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libcrypto >= \${LIBCRYPTO_MIN_VERSION}\""; } >&5
17488
 
  ($PKG_CONFIG --exists --print-errors "libcrypto >= ${LIBCRYPTO_MIN_VERSION}") 2>&5
17489
 
  ac_status=$?
17490
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
17491
 
  test $ac_status = 0; }; then
17492
 
  pkg_cv_LIBCRYPTO_LIBS=`$PKG_CONFIG --libs "libcrypto >= ${LIBCRYPTO_MIN_VERSION}" 2>/dev/null`
17493
 
                      test "x$?" != "x0" && pkg_failed=yes
17494
 
else
17495
 
  pkg_failed=yes
17496
 
fi
17497
 
 else
17498
 
    pkg_failed=untried
17499
 
fi
17500
 
 
17501
 
 
17502
 
 
17503
 
if test $pkg_failed = yes; then
17504
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17505
 
$as_echo "no" >&6; }
17506
 
 
17507
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
17508
 
        _pkg_short_errors_supported=yes
17509
 
else
17510
 
        _pkg_short_errors_supported=no
17511
 
fi
17512
 
        if test $_pkg_short_errors_supported = yes; then
17513
 
                LIBCRYPTO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libcrypto >= ${LIBCRYPTO_MIN_VERSION}" 2>&1`
17514
 
        else
17515
 
                LIBCRYPTO_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libcrypto >= ${LIBCRYPTO_MIN_VERSION}" 2>&1`
17516
 
        fi
17517
 
        # Put the nasty error message in config.log where it belongs
17518
 
        echo "$LIBCRYPTO_PKG_ERRORS" >&5
17519
 
 
17520
 
        HAVE_LIBCRYPTO=false
17521
 
elif test $pkg_failed = untried; then
17522
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
17523
 
$as_echo "no" >&6; }
17524
 
        HAVE_LIBCRYPTO=false
17525
 
else
17526
 
        LIBCRYPTO_CFLAGS=$pkg_cv_LIBCRYPTO_CFLAGS
17527
 
        LIBCRYPTO_LIBS=$pkg_cv_LIBCRYPTO_LIBS
17528
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
17529
 
$as_echo "yes" >&6; }
17530
 
        HAVE_LIBCRYPTO=true
17531
 
fi;
 
17327
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiling with clang" >&5
 
17328
$as_echo_n "checking if compiling with clang... " >&6; }
 
17329
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
17330
/* end confdefs.h.  */
 
17331
 
 
17332
int
 
17333
main ()
 
17334
{
 
17335
 
 
17336
#ifndef __clang__
 
17337
       not clang
 
17338
#endif
 
17339
 
 
17340
  ;
 
17341
  return 0;
 
17342
}
 
17343
_ACEOF
 
17344
if ac_fn_cxx_try_compile "$LINENO"; then :
 
17345
  CLANG=yes
 
17346
else
 
17347
  CLANG=no
 
17348
fi
 
17349
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
17350
 
 
17351
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLANG" >&5
 
17352
$as_echo "$CLANG" >&6; }
 
17353
 
 
17354
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiling for android" >&5
 
17355
$as_echo_n "checking if compiling for android... " >&6; }
 
17356
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
17357
/* end confdefs.h.  */
 
17358
 
 
17359
int
 
17360
main ()
 
17361
{
 
17362
 
 
17363
#ifndef __ANDROID__
 
17364
       not android
 
17365
#endif
 
17366
 
 
17367
  ;
 
17368
  return 0;
 
17369
}
 
17370
_ACEOF
 
17371
if ac_fn_cxx_try_compile "$LINENO"; then :
 
17372
  ANDROID=yes
 
17373
else
 
17374
  ANDROID=no
 
17375
fi
 
17376
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
17377
 
 
17378
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ANDROID" >&5
 
17379
$as_echo "$ANDROID" >&6; }
 
17380
 if test "x$ANDROID" = "xyes"; then
 
17381
  USE_ANDROID_TRUE=
 
17382
  USE_ANDROID_FALSE='#'
 
17383
else
 
17384
  USE_ANDROID_TRUE='#'
 
17385
  USE_ANDROID_FALSE=
 
17386
fi
 
17387
 
 
17388
 
 
17389
 
 
17390
pkg_failed=no
 
17391
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for YAML" >&5
 
17392
$as_echo_n "checking for YAML... " >&6; }
 
17393
 
 
17394
if test -n "$YAML_CFLAGS"; then
 
17395
    pkg_cv_YAML_CFLAGS="$YAML_CFLAGS"
 
17396
 elif test -n "$PKG_CONFIG"; then
 
17397
    if test -n "$PKG_CONFIG" && \
 
17398
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"yaml-0.1\""; } >&5
 
17399
  ($PKG_CONFIG --exists --print-errors "yaml-0.1") 2>&5
 
17400
  ac_status=$?
 
17401
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
17402
  test $ac_status = 0; }; then
 
17403
  pkg_cv_YAML_CFLAGS=`$PKG_CONFIG --cflags "yaml-0.1" 2>/dev/null`
 
17404
                      test "x$?" != "x0" && pkg_failed=yes
 
17405
else
 
17406
  pkg_failed=yes
 
17407
fi
 
17408
 else
 
17409
    pkg_failed=untried
 
17410
fi
 
17411
if test -n "$YAML_LIBS"; then
 
17412
    pkg_cv_YAML_LIBS="$YAML_LIBS"
 
17413
 elif test -n "$PKG_CONFIG"; then
 
17414
    if test -n "$PKG_CONFIG" && \
 
17415
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"yaml-0.1\""; } >&5
 
17416
  ($PKG_CONFIG --exists --print-errors "yaml-0.1") 2>&5
 
17417
  ac_status=$?
 
17418
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
17419
  test $ac_status = 0; }; then
 
17420
  pkg_cv_YAML_LIBS=`$PKG_CONFIG --libs "yaml-0.1" 2>/dev/null`
 
17421
                      test "x$?" != "x0" && pkg_failed=yes
 
17422
else
 
17423
  pkg_failed=yes
 
17424
fi
 
17425
 else
 
17426
    pkg_failed=untried
 
17427
fi
 
17428
 
 
17429
 
 
17430
 
 
17431
if test $pkg_failed = yes; then
 
17432
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
17433
$as_echo "no" >&6; }
 
17434
 
 
17435
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
17436
        _pkg_short_errors_supported=yes
 
17437
else
 
17438
        _pkg_short_errors_supported=no
 
17439
fi
 
17440
        if test $_pkg_short_errors_supported = yes; then
 
17441
                YAML_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "yaml-0.1" 2>&1`
 
17442
        else
 
17443
                YAML_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "yaml-0.1" 2>&1`
 
17444
        fi
 
17445
        # Put the nasty error message in config.log where it belongs
 
17446
        echo "$YAML_PKG_ERRORS" >&5
 
17447
 
 
17448
        as_fn_error $? "Unable to find yaml" "$LINENO" 5
 
17449
elif test $pkg_failed = untried; then
 
17450
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
17451
$as_echo "no" >&6; }
 
17452
        as_fn_error $? "Unable to find yaml" "$LINENO" 5
 
17453
else
 
17454
        YAML_CFLAGS=$pkg_cv_YAML_CFLAGS
 
17455
        YAML_LIBS=$pkg_cv_YAML_LIBS
 
17456
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
17457
$as_echo "yes" >&6; }
 
17458
 
 
17459
fi
 
17460
 
 
17461
if test "x$ANDROID" = "xyes"; then
 
17462
 
 
17463
# Check whether --with-opensl was given.
 
17464
if test "${with_opensl+set}" = set; then :
 
17465
  withval=$with_opensl;
 
17466
fi
 
17467
 
 
17468
 
 
17469
    if test "x$with_opensl" != "xno"; then :
 
17470
  as_ac_Header=`$as_echo "ac_cv_header_"SLES/OpenSLES.h"" | $as_tr_sh`
 
17471
ac_fn_cxx_check_header_mongrel "$LINENO" ""SLES/OpenSLES.h"" "$as_ac_Header" "$ac_includes_default"
 
17472
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
 
17473
  have_opensl=yes
 
17474
else
 
17475
  have_opensl=no
 
17476
fi
 
17477
 
 
17478
 
 
17479
else
 
17480
  have_opensl=no
 
17481
fi
 
17482
 
 
17483
cat >>confdefs.h <<_ACEOF
 
17484
#define HAVE_OPENSL `if test "x$have_opensl" = "xyes"; then echo 1; else echo 0; fi`
 
17485
_ACEOF
 
17486
 
 
17487
fi
 
17488
 if test "x$have_opensl" = "xyes"; then
 
17489
  BUILD_OPENSL_TRUE=
 
17490
  BUILD_OPENSL_FALSE='#'
 
17491
else
 
17492
  BUILD_OPENSL_TRUE='#'
 
17493
  BUILD_OPENSL_FALSE=
 
17494
fi
17532
17495
 
17533
17496
 
17534
17497
ALSA_MIN_VERSION=1.0
17731
17694
fi
17732
17695
 
17733
17696
 
 
17697
 
 
17698
# Check whether --with-jack was given.
 
17699
if test "${with_jack+set}" = set; then :
 
17700
  withval=$with_jack;
 
17701
fi
 
17702
 
 
17703
 
 
17704
if test "x$with_jack" != "xno"; then :
 
17705
 
 
17706
pkg_failed=no
 
17707
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for JACK" >&5
 
17708
$as_echo_n "checking for JACK... " >&6; }
 
17709
 
 
17710
if test -n "$JACK_CFLAGS"; then
 
17711
    pkg_cv_JACK_CFLAGS="$JACK_CFLAGS"
 
17712
 elif test -n "$PKG_CONFIG"; then
 
17713
    if test -n "$PKG_CONFIG" && \
 
17714
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"jack\""; } >&5
 
17715
  ($PKG_CONFIG --exists --print-errors "jack") 2>&5
 
17716
  ac_status=$?
 
17717
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
17718
  test $ac_status = 0; }; then
 
17719
  pkg_cv_JACK_CFLAGS=`$PKG_CONFIG --cflags "jack" 2>/dev/null`
 
17720
                      test "x$?" != "x0" && pkg_failed=yes
 
17721
else
 
17722
  pkg_failed=yes
 
17723
fi
 
17724
 else
 
17725
    pkg_failed=untried
 
17726
fi
 
17727
if test -n "$JACK_LIBS"; then
 
17728
    pkg_cv_JACK_LIBS="$JACK_LIBS"
 
17729
 elif test -n "$PKG_CONFIG"; then
 
17730
    if test -n "$PKG_CONFIG" && \
 
17731
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"jack\""; } >&5
 
17732
  ($PKG_CONFIG --exists --print-errors "jack") 2>&5
 
17733
  ac_status=$?
 
17734
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
17735
  test $ac_status = 0; }; then
 
17736
  pkg_cv_JACK_LIBS=`$PKG_CONFIG --libs "jack" 2>/dev/null`
 
17737
                      test "x$?" != "x0" && pkg_failed=yes
 
17738
else
 
17739
  pkg_failed=yes
 
17740
fi
 
17741
 else
 
17742
    pkg_failed=untried
 
17743
fi
 
17744
 
 
17745
 
 
17746
 
 
17747
if test $pkg_failed = yes; then
 
17748
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
17749
$as_echo "no" >&6; }
 
17750
 
 
17751
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
17752
        _pkg_short_errors_supported=yes
 
17753
else
 
17754
        _pkg_short_errors_supported=no
 
17755
fi
 
17756
        if test $_pkg_short_errors_supported = yes; then
 
17757
                JACK_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "jack" 2>&1`
 
17758
        else
 
17759
                JACK_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "jack" 2>&1`
 
17760
        fi
 
17761
        # Put the nasty error message in config.log where it belongs
 
17762
        echo "$JACK_PKG_ERRORS" >&5
 
17763
 
 
17764
        have_jack=no
 
17765
elif test $pkg_failed = untried; then
 
17766
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
17767
$as_echo "no" >&6; }
 
17768
        have_jack=no
 
17769
else
 
17770
        JACK_CFLAGS=$pkg_cv_JACK_CFLAGS
 
17771
        JACK_LIBS=$pkg_cv_JACK_LIBS
 
17772
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
17773
$as_echo "yes" >&6; }
 
17774
        have_jack=yes
 
17775
fi
 
17776
else
 
17777
  have_jack=no
 
17778
fi
 
17779
 
 
17780
if test "x$have_jack" = "xyes"; then :
 
17781
 
 
17782
else
 
17783
  if test "x$with_jack" = "xyes"; then :
 
17784
  as_fn_error $? "jack requested but not found" "$LINENO" 5
 
17785
 
 
17786
fi
 
17787
 
 
17788
fi
 
17789
 
 
17790
 
 
17791
cat >>confdefs.h <<_ACEOF
 
17792
#define HAVE_JACK `if test "x$have_jack" = "xyes"; then echo 1; else echo 0; fi`
 
17793
_ACEOF
 
17794
 
 
17795
 if test "x$have_jack" = "xyes"; then
 
17796
  BUILD_JACK_TRUE=
 
17797
  BUILD_JACK_FALSE='#'
 
17798
else
 
17799
  BUILD_JACK_TRUE='#'
 
17800
  BUILD_JACK_FALSE=
 
17801
fi
 
17802
 
 
17803
 
17734
17804
LIBSAMPLERATE_MIN_VERSION=0.1.2
17735
17805
 
17736
17806
pkg_failed=no
17894
17964
fi
17895
17965
 
17896
17966
 
17897
 
if test "x$enable_video" = "xyes"; then :
 
17967
if test "x$enable_video" != "xno"; then :
17898
17968
 
17899
17969
 
17900
17970
$as_echo "#define SFL_VIDEO /**/" >>confdefs.h
18206
18276
    pkg_cv_LIBAVUTIL_CFLAGS="$LIBAVUTIL_CFLAGS"
18207
18277
 elif test -n "$PKG_CONFIG"; then
18208
18278
    if test -n "$PKG_CONFIG" && \
18209
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libavutil >= 51.7.0\""; } >&5
18210
 
  ($PKG_CONFIG --exists --print-errors "libavutil >= 51.7.0") 2>&5
 
18279
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libavutil >= 51.0.0\""; } >&5
 
18280
  ($PKG_CONFIG --exists --print-errors "libavutil >= 51.0.0") 2>&5
18211
18281
  ac_status=$?
18212
18282
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18213
18283
  test $ac_status = 0; }; then
18214
 
  pkg_cv_LIBAVUTIL_CFLAGS=`$PKG_CONFIG --cflags "libavutil >= 51.7.0" 2>/dev/null`
 
18284
  pkg_cv_LIBAVUTIL_CFLAGS=`$PKG_CONFIG --cflags "libavutil >= 51.0.0" 2>/dev/null`
18215
18285
                      test "x$?" != "x0" && pkg_failed=yes
18216
18286
else
18217
18287
  pkg_failed=yes
18223
18293
    pkg_cv_LIBAVUTIL_LIBS="$LIBAVUTIL_LIBS"
18224
18294
 elif test -n "$PKG_CONFIG"; then
18225
18295
    if test -n "$PKG_CONFIG" && \
18226
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libavutil >= 51.7.0\""; } >&5
18227
 
  ($PKG_CONFIG --exists --print-errors "libavutil >= 51.7.0") 2>&5
 
18296
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libavutil >= 51.0.0\""; } >&5
 
18297
  ($PKG_CONFIG --exists --print-errors "libavutil >= 51.0.0") 2>&5
18228
18298
  ac_status=$?
18229
18299
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18230
18300
  test $ac_status = 0; }; then
18231
 
  pkg_cv_LIBAVUTIL_LIBS=`$PKG_CONFIG --libs "libavutil >= 51.7.0" 2>/dev/null`
 
18301
  pkg_cv_LIBAVUTIL_LIBS=`$PKG_CONFIG --libs "libavutil >= 51.0.0" 2>/dev/null`
18232
18302
                      test "x$?" != "x0" && pkg_failed=yes
18233
18303
else
18234
18304
  pkg_failed=yes
18249
18319
        _pkg_short_errors_supported=no
18250
18320
fi
18251
18321
        if test $_pkg_short_errors_supported = yes; then
18252
 
                LIBAVUTIL_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libavutil >= 51.7.0" 2>&1`
 
18322
                LIBAVUTIL_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libavutil >= 51.0.0" 2>&1`
18253
18323
        else
18254
 
                LIBAVUTIL_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libavutil >= 51.7.0" 2>&1`
 
18324
                LIBAVUTIL_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libavutil >= 51.0.0" 2>&1`
18255
18325
        fi
18256
18326
        # Put the nasty error message in config.log where it belongs
18257
18327
        echo "$LIBAVUTIL_PKG_ERRORS" >&5
18353
18423
fi;
18354
18424
 
18355
18425
 
18356
 
LIBCCGNU2_MIN_VERSION=1.3.1
18357
 
 
18358
 
pkg_failed=no
18359
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCGNU2" >&5
18360
 
$as_echo_n "checking for CCGNU2... " >&6; }
18361
 
 
18362
 
if test -n "$CCGNU2_CFLAGS"; then
18363
 
    pkg_cv_CCGNU2_CFLAGS="$CCGNU2_CFLAGS"
18364
 
 elif test -n "$PKG_CONFIG"; then
18365
 
    if test -n "$PKG_CONFIG" && \
18366
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"commoncpp >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18367
 
  ($PKG_CONFIG --exists --print-errors "commoncpp >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18368
 
  ac_status=$?
18369
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18370
 
  test $ac_status = 0; }; then
18371
 
  pkg_cv_CCGNU2_CFLAGS=`$PKG_CONFIG --cflags "commoncpp >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18372
 
                      test "x$?" != "x0" && pkg_failed=yes
18373
 
else
18374
 
  pkg_failed=yes
18375
 
fi
18376
 
 else
18377
 
    pkg_failed=untried
18378
 
fi
18379
 
if test -n "$CCGNU2_LIBS"; then
18380
 
    pkg_cv_CCGNU2_LIBS="$CCGNU2_LIBS"
18381
 
 elif test -n "$PKG_CONFIG"; then
18382
 
    if test -n "$PKG_CONFIG" && \
18383
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"commoncpp >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18384
 
  ($PKG_CONFIG --exists --print-errors "commoncpp >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18385
 
  ac_status=$?
18386
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18387
 
  test $ac_status = 0; }; then
18388
 
  pkg_cv_CCGNU2_LIBS=`$PKG_CONFIG --libs "commoncpp >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18389
 
                      test "x$?" != "x0" && pkg_failed=yes
18390
 
else
18391
 
  pkg_failed=yes
18392
 
fi
18393
 
 else
18394
 
    pkg_failed=untried
18395
 
fi
18396
 
 
18397
 
 
18398
 
 
18399
 
if test $pkg_failed = yes; then
18400
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18401
 
$as_echo "no" >&6; }
18402
 
 
18403
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
18404
 
        _pkg_short_errors_supported=yes
18405
 
else
18406
 
        _pkg_short_errors_supported=no
18407
 
fi
18408
 
        if test $_pkg_short_errors_supported = yes; then
18409
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "commoncpp >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18410
 
        else
18411
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "commoncpp >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18412
 
        fi
18413
 
        # Put the nasty error message in config.log where it belongs
18414
 
        echo "$CCGNU2_PKG_ERRORS" >&5
18415
 
 
18416
 
 
18417
 
pkg_failed=no
18418
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCGNU2" >&5
18419
 
$as_echo_n "checking for CCGNU2... " >&6; }
18420
 
 
18421
 
if test -n "$CCGNU2_CFLAGS"; then
18422
 
    pkg_cv_CCGNU2_CFLAGS="$CCGNU2_CFLAGS"
18423
 
 elif test -n "$PKG_CONFIG"; then
18424
 
    if test -n "$PKG_CONFIG" && \
18425
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libccgnu2 >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18426
 
  ($PKG_CONFIG --exists --print-errors "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18427
 
  ac_status=$?
18428
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18429
 
  test $ac_status = 0; }; then
18430
 
  pkg_cv_CCGNU2_CFLAGS=`$PKG_CONFIG --cflags "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18431
 
                      test "x$?" != "x0" && pkg_failed=yes
18432
 
else
18433
 
  pkg_failed=yes
18434
 
fi
18435
 
 else
18436
 
    pkg_failed=untried
18437
 
fi
18438
 
if test -n "$CCGNU2_LIBS"; then
18439
 
    pkg_cv_CCGNU2_LIBS="$CCGNU2_LIBS"
18440
 
 elif test -n "$PKG_CONFIG"; then
18441
 
    if test -n "$PKG_CONFIG" && \
18442
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libccgnu2 >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18443
 
  ($PKG_CONFIG --exists --print-errors "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18444
 
  ac_status=$?
18445
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18446
 
  test $ac_status = 0; }; then
18447
 
  pkg_cv_CCGNU2_LIBS=`$PKG_CONFIG --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18448
 
                      test "x$?" != "x0" && pkg_failed=yes
18449
 
else
18450
 
  pkg_failed=yes
18451
 
fi
18452
 
 else
18453
 
    pkg_failed=untried
18454
 
fi
18455
 
 
18456
 
 
18457
 
 
18458
 
if test $pkg_failed = yes; then
18459
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18460
 
$as_echo "no" >&6; }
18461
 
 
18462
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
18463
 
        _pkg_short_errors_supported=yes
18464
 
else
18465
 
        _pkg_short_errors_supported=no
18466
 
fi
18467
 
        if test $_pkg_short_errors_supported = yes; then
18468
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18469
 
        else
18470
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18471
 
        fi
18472
 
        # Put the nasty error message in config.log where it belongs
18473
 
        echo "$CCGNU2_PKG_ERRORS" >&5
18474
 
 
18475
 
        as_fn_error $? "Missing commoncpp development files" "$LINENO" 5
18476
 
elif test $pkg_failed = untried; then
18477
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18478
 
$as_echo "no" >&6; }
18479
 
        as_fn_error $? "Missing commoncpp development files" "$LINENO" 5
18480
 
else
18481
 
        CCGNU2_CFLAGS=$pkg_cv_CCGNU2_CFLAGS
18482
 
        CCGNU2_LIBS=$pkg_cv_CCGNU2_LIBS
18483
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18484
 
$as_echo "yes" >&6; }
18485
 
 
18486
 
fi
18487
 
elif test $pkg_failed = untried; then
18488
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18489
 
$as_echo "no" >&6; }
18490
 
 
18491
 
pkg_failed=no
18492
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCGNU2" >&5
18493
 
$as_echo_n "checking for CCGNU2... " >&6; }
18494
 
 
18495
 
if test -n "$CCGNU2_CFLAGS"; then
18496
 
    pkg_cv_CCGNU2_CFLAGS="$CCGNU2_CFLAGS"
18497
 
 elif test -n "$PKG_CONFIG"; then
18498
 
    if test -n "$PKG_CONFIG" && \
18499
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libccgnu2 >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18500
 
  ($PKG_CONFIG --exists --print-errors "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18501
 
  ac_status=$?
18502
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18503
 
  test $ac_status = 0; }; then
18504
 
  pkg_cv_CCGNU2_CFLAGS=`$PKG_CONFIG --cflags "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18505
 
                      test "x$?" != "x0" && pkg_failed=yes
18506
 
else
18507
 
  pkg_failed=yes
18508
 
fi
18509
 
 else
18510
 
    pkg_failed=untried
18511
 
fi
18512
 
if test -n "$CCGNU2_LIBS"; then
18513
 
    pkg_cv_CCGNU2_LIBS="$CCGNU2_LIBS"
18514
 
 elif test -n "$PKG_CONFIG"; then
18515
 
    if test -n "$PKG_CONFIG" && \
18516
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libccgnu2 >= \${LIBCCGNU2_MIN_VERSION}\""; } >&5
18517
 
  ($PKG_CONFIG --exists --print-errors "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}") 2>&5
18518
 
  ac_status=$?
18519
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18520
 
  test $ac_status = 0; }; then
18521
 
  pkg_cv_CCGNU2_LIBS=`$PKG_CONFIG --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>/dev/null`
18522
 
                      test "x$?" != "x0" && pkg_failed=yes
18523
 
else
18524
 
  pkg_failed=yes
18525
 
fi
18526
 
 else
18527
 
    pkg_failed=untried
18528
 
fi
18529
 
 
18530
 
 
18531
 
 
18532
 
if test $pkg_failed = yes; then
18533
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18534
 
$as_echo "no" >&6; }
18535
 
 
18536
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
18537
 
        _pkg_short_errors_supported=yes
18538
 
else
18539
 
        _pkg_short_errors_supported=no
18540
 
fi
18541
 
        if test $_pkg_short_errors_supported = yes; then
18542
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18543
 
        else
18544
 
                CCGNU2_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libccgnu2 >= ${LIBCCGNU2_MIN_VERSION}" 2>&1`
18545
 
        fi
18546
 
        # Put the nasty error message in config.log where it belongs
18547
 
        echo "$CCGNU2_PKG_ERRORS" >&5
18548
 
 
18549
 
        as_fn_error $? "Missing commoncpp development files" "$LINENO" 5
18550
 
elif test $pkg_failed = untried; then
18551
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18552
 
$as_echo "no" >&6; }
18553
 
        as_fn_error $? "Missing commoncpp development files" "$LINENO" 5
18554
 
else
18555
 
        CCGNU2_CFLAGS=$pkg_cv_CCGNU2_CFLAGS
18556
 
        CCGNU2_LIBS=$pkg_cv_CCGNU2_LIBS
18557
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18558
 
$as_echo "yes" >&6; }
18559
 
 
18560
 
fi
18561
 
else
18562
 
        CCGNU2_CFLAGS=$pkg_cv_CCGNU2_CFLAGS
18563
 
        CCGNU2_LIBS=$pkg_cv_CCGNU2_LIBS
18564
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18565
 
$as_echo "yes" >&6; }
18566
 
 
18567
 
fi
18568
 
 
18569
18426
LIBCCRTP_MIN_VERSION=1.3.0
18570
18427
 
18571
18428
pkg_failed=no
18814
18671
fi
18815
18672
 
18816
18673
# TLS
18817
 
# required dependency(ies): libssl
 
18674
# required dependency(ies): GnuTLS
18818
18675
 
18819
18676
# Check whether --with-tls was given.
18820
18677
if test "${with_tls+set}" = set; then :
18827
18684
 
18828
18685
 
18829
18686
pkg_failed=no
18830
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libssl" >&5
18831
 
$as_echo_n "checking for libssl... " >&6; }
 
18687
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNUTLS" >&5
 
18688
$as_echo_n "checking for GNUTLS... " >&6; }
18832
18689
 
18833
 
if test -n "$libssl_CFLAGS"; then
18834
 
    pkg_cv_libssl_CFLAGS="$libssl_CFLAGS"
 
18690
if test -n "$GNUTLS_CFLAGS"; then
 
18691
    pkg_cv_GNUTLS_CFLAGS="$GNUTLS_CFLAGS"
18835
18692
 elif test -n "$PKG_CONFIG"; then
18836
18693
    if test -n "$PKG_CONFIG" && \
18837
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libssl\""; } >&5
18838
 
  ($PKG_CONFIG --exists --print-errors "libssl") 2>&5
 
18694
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gnutls\""; } >&5
 
18695
  ($PKG_CONFIG --exists --print-errors "gnutls") 2>&5
18839
18696
  ac_status=$?
18840
18697
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18841
18698
  test $ac_status = 0; }; then
18842
 
  pkg_cv_libssl_CFLAGS=`$PKG_CONFIG --cflags "libssl" 2>/dev/null`
 
18699
  pkg_cv_GNUTLS_CFLAGS=`$PKG_CONFIG --cflags "gnutls" 2>/dev/null`
18843
18700
                      test "x$?" != "x0" && pkg_failed=yes
18844
18701
else
18845
18702
  pkg_failed=yes
18847
18704
 else
18848
18705
    pkg_failed=untried
18849
18706
fi
18850
 
if test -n "$libssl_LIBS"; then
18851
 
    pkg_cv_libssl_LIBS="$libssl_LIBS"
 
18707
if test -n "$GNUTLS_LIBS"; then
 
18708
    pkg_cv_GNUTLS_LIBS="$GNUTLS_LIBS"
18852
18709
 elif test -n "$PKG_CONFIG"; then
18853
18710
    if test -n "$PKG_CONFIG" && \
18854
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libssl\""; } >&5
18855
 
  ($PKG_CONFIG --exists --print-errors "libssl") 2>&5
 
18711
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"gnutls\""; } >&5
 
18712
  ($PKG_CONFIG --exists --print-errors "gnutls") 2>&5
18856
18713
  ac_status=$?
18857
18714
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18858
18715
  test $ac_status = 0; }; then
18859
 
  pkg_cv_libssl_LIBS=`$PKG_CONFIG --libs "libssl" 2>/dev/null`
 
18716
  pkg_cv_GNUTLS_LIBS=`$PKG_CONFIG --libs "gnutls" 2>/dev/null`
18860
18717
                      test "x$?" != "x0" && pkg_failed=yes
18861
18718
else
18862
18719
  pkg_failed=yes
18877
18734
        _pkg_short_errors_supported=no
18878
18735
fi
18879
18736
        if test $_pkg_short_errors_supported = yes; then
18880
 
                libssl_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libssl" 2>&1`
 
18737
                GNUTLS_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "gnutls" 2>&1`
18881
18738
        else
18882
 
                libssl_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libssl" 2>&1`
 
18739
                GNUTLS_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "gnutls" 2>&1`
18883
18740
        fi
18884
18741
        # Put the nasty error message in config.log where it belongs
18885
 
        echo "$libssl_PKG_ERRORS" >&5
 
18742
        echo "$GNUTLS_PKG_ERRORS" >&5
18886
18743
 
18887
 
        as_fn_error $? "Missing ssl development files" "$LINENO" 5
 
18744
        as_fn_error $? "Missing GnuTLS development files" "$LINENO" 5
18888
18745
elif test $pkg_failed = untried; then
18889
18746
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18890
18747
$as_echo "no" >&6; }
18891
 
        as_fn_error $? "Missing ssl development files" "$LINENO" 5
 
18748
        as_fn_error $? "Missing GnuTLS development files" "$LINENO" 5
18892
18749
else
18893
 
        libssl_CFLAGS=$pkg_cv_libssl_CFLAGS
18894
 
        libssl_LIBS=$pkg_cv_libssl_LIBS
 
18750
        GNUTLS_CFLAGS=$pkg_cv_GNUTLS_CFLAGS
 
18751
        GNUTLS_LIBS=$pkg_cv_GNUTLS_LIBS
18895
18752
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18896
18753
$as_echo "yes" >&6; }
18897
18754
 
18916
18773
 
18917
18774
# ZRTP
18918
18775
# required dependency(ies): libzrtp
18919
 
LIBZRTPCPP_MIN_VERSION=1.3.0
18920
18776
 
18921
18777
# Check whether --with-zrtp was given.
18922
18778
if test "${with_zrtp+set}" = set; then :
18936
18792
    pkg_cv_ZRTPCPP_CFLAGS="$ZRTPCPP_CFLAGS"
18937
18793
 elif test -n "$PKG_CONFIG"; then
18938
18794
    if test -n "$PKG_CONFIG" && \
18939
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= \${LIBZRTPCPP_MIN_VERSION}\""; } >&5
18940
 
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}") 2>&5
18941
 
  ac_status=$?
18942
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18943
 
  test $ac_status = 0; }; then
18944
 
  pkg_cv_ZRTPCPP_CFLAGS=`$PKG_CONFIG --cflags "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}" 2>/dev/null`
18945
 
                      test "x$?" != "x0" && pkg_failed=yes
18946
 
else
18947
 
  pkg_failed=yes
18948
 
fi
18949
 
 else
18950
 
    pkg_failed=untried
18951
 
fi
18952
 
if test -n "$ZRTPCPP_LIBS"; then
18953
 
    pkg_cv_ZRTPCPP_LIBS="$ZRTPCPP_LIBS"
18954
 
 elif test -n "$PKG_CONFIG"; then
18955
 
    if test -n "$PKG_CONFIG" && \
18956
 
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= \${LIBZRTPCPP_MIN_VERSION}\""; } >&5
18957
 
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}") 2>&5
18958
 
  ac_status=$?
18959
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
18960
 
  test $ac_status = 0; }; then
18961
 
  pkg_cv_ZRTPCPP_LIBS=`$PKG_CONFIG --libs "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}" 2>/dev/null`
18962
 
                      test "x$?" != "x0" && pkg_failed=yes
18963
 
else
18964
 
  pkg_failed=yes
18965
 
fi
18966
 
 else
18967
 
    pkg_failed=untried
18968
 
fi
18969
 
 
18970
 
 
18971
 
 
18972
 
if test $pkg_failed = yes; then
18973
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18974
 
$as_echo "no" >&6; }
18975
 
 
18976
 
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
18977
 
        _pkg_short_errors_supported=yes
18978
 
else
18979
 
        _pkg_short_errors_supported=no
18980
 
fi
18981
 
        if test $_pkg_short_errors_supported = yes; then
18982
 
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}" 2>&1`
18983
 
        else
18984
 
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libzrtpcpp >= ${LIBZRTPCPP_MIN_VERSION}" 2>&1`
18985
 
        fi
18986
 
        # Put the nasty error message in config.log where it belongs
18987
 
        echo "$ZRTPCPP_PKG_ERRORS" >&5
18988
 
 
18989
 
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
18990
 
elif test $pkg_failed = untried; then
18991
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
18992
 
$as_echo "no" >&6; }
18993
 
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
18994
 
else
18995
 
        ZRTPCPP_CFLAGS=$pkg_cv_ZRTPCPP_CFLAGS
18996
 
        ZRTPCPP_LIBS=$pkg_cv_ZRTPCPP_LIBS
18997
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
18998
 
$as_echo "yes" >&6; }
18999
 
 
 
18795
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 2.3.0\""; } >&5
 
18796
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 2.3.0") 2>&5
 
18797
  ac_status=$?
 
18798
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18799
  test $ac_status = 0; }; then
 
18800
  pkg_cv_ZRTPCPP_CFLAGS=`$PKG_CONFIG --cflags "libzrtpcpp >= 2.3.0" 2>/dev/null`
 
18801
                      test "x$?" != "x0" && pkg_failed=yes
 
18802
else
 
18803
  pkg_failed=yes
 
18804
fi
 
18805
 else
 
18806
    pkg_failed=untried
 
18807
fi
 
18808
if test -n "$ZRTPCPP_LIBS"; then
 
18809
    pkg_cv_ZRTPCPP_LIBS="$ZRTPCPP_LIBS"
 
18810
 elif test -n "$PKG_CONFIG"; then
 
18811
    if test -n "$PKG_CONFIG" && \
 
18812
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 2.3.0\""; } >&5
 
18813
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 2.3.0") 2>&5
 
18814
  ac_status=$?
 
18815
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18816
  test $ac_status = 0; }; then
 
18817
  pkg_cv_ZRTPCPP_LIBS=`$PKG_CONFIG --libs "libzrtpcpp >= 2.3.0" 2>/dev/null`
 
18818
                      test "x$?" != "x0" && pkg_failed=yes
 
18819
else
 
18820
  pkg_failed=yes
 
18821
fi
 
18822
 else
 
18823
    pkg_failed=untried
 
18824
fi
 
18825
 
 
18826
 
 
18827
 
 
18828
if test $pkg_failed = yes; then
 
18829
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18830
$as_echo "no" >&6; }
 
18831
 
 
18832
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
18833
        _pkg_short_errors_supported=yes
 
18834
else
 
18835
        _pkg_short_errors_supported=no
 
18836
fi
 
18837
        if test $_pkg_short_errors_supported = yes; then
 
18838
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libzrtpcpp >= 2.3.0" 2>&1`
 
18839
        else
 
18840
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libzrtpcpp >= 2.3.0" 2>&1`
 
18841
        fi
 
18842
        # Put the nasty error message in config.log where it belongs
 
18843
        echo "$ZRTPCPP_PKG_ERRORS" >&5
 
18844
 
 
18845
 
 
18846
pkg_failed=no
 
18847
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZRTPCPP" >&5
 
18848
$as_echo_n "checking for ZRTPCPP... " >&6; }
 
18849
 
 
18850
if test -n "$ZRTPCPP_CFLAGS"; then
 
18851
    pkg_cv_ZRTPCPP_CFLAGS="$ZRTPCPP_CFLAGS"
 
18852
 elif test -n "$PKG_CONFIG"; then
 
18853
    if test -n "$PKG_CONFIG" && \
 
18854
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 1.3.0\""; } >&5
 
18855
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 1.3.0") 2>&5
 
18856
  ac_status=$?
 
18857
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18858
  test $ac_status = 0; }; then
 
18859
  pkg_cv_ZRTPCPP_CFLAGS=`$PKG_CONFIG --cflags "libzrtpcpp >= 1.3.0" 2>/dev/null`
 
18860
                      test "x$?" != "x0" && pkg_failed=yes
 
18861
else
 
18862
  pkg_failed=yes
 
18863
fi
 
18864
 else
 
18865
    pkg_failed=untried
 
18866
fi
 
18867
if test -n "$ZRTPCPP_LIBS"; then
 
18868
    pkg_cv_ZRTPCPP_LIBS="$ZRTPCPP_LIBS"
 
18869
 elif test -n "$PKG_CONFIG"; then
 
18870
    if test -n "$PKG_CONFIG" && \
 
18871
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 1.3.0\""; } >&5
 
18872
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 1.3.0") 2>&5
 
18873
  ac_status=$?
 
18874
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18875
  test $ac_status = 0; }; then
 
18876
  pkg_cv_ZRTPCPP_LIBS=`$PKG_CONFIG --libs "libzrtpcpp >= 1.3.0" 2>/dev/null`
 
18877
                      test "x$?" != "x0" && pkg_failed=yes
 
18878
else
 
18879
  pkg_failed=yes
 
18880
fi
 
18881
 else
 
18882
    pkg_failed=untried
 
18883
fi
 
18884
 
 
18885
 
 
18886
 
 
18887
if test $pkg_failed = yes; then
 
18888
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18889
$as_echo "no" >&6; }
 
18890
 
 
18891
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
18892
        _pkg_short_errors_supported=yes
 
18893
else
 
18894
        _pkg_short_errors_supported=no
 
18895
fi
 
18896
        if test $_pkg_short_errors_supported = yes; then
 
18897
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libzrtpcpp >= 1.3.0" 2>&1`
 
18898
        else
 
18899
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libzrtpcpp >= 1.3.0" 2>&1`
 
18900
        fi
 
18901
        # Put the nasty error message in config.log where it belongs
 
18902
        echo "$ZRTPCPP_PKG_ERRORS" >&5
 
18903
 
 
18904
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
 
18905
elif test $pkg_failed = untried; then
 
18906
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18907
$as_echo "no" >&6; }
 
18908
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
 
18909
else
 
18910
        ZRTPCPP_CFLAGS=$pkg_cv_ZRTPCPP_CFLAGS
 
18911
        ZRTPCPP_LIBS=$pkg_cv_ZRTPCPP_LIBS
 
18912
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
18913
$as_echo "yes" >&6; }
 
18914
        with_zrtp_configure=no
 
18915
fi
 
18916
elif test $pkg_failed = untried; then
 
18917
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18918
$as_echo "no" >&6; }
 
18919
 
 
18920
pkg_failed=no
 
18921
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZRTPCPP" >&5
 
18922
$as_echo_n "checking for ZRTPCPP... " >&6; }
 
18923
 
 
18924
if test -n "$ZRTPCPP_CFLAGS"; then
 
18925
    pkg_cv_ZRTPCPP_CFLAGS="$ZRTPCPP_CFLAGS"
 
18926
 elif test -n "$PKG_CONFIG"; then
 
18927
    if test -n "$PKG_CONFIG" && \
 
18928
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 1.3.0\""; } >&5
 
18929
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 1.3.0") 2>&5
 
18930
  ac_status=$?
 
18931
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18932
  test $ac_status = 0; }; then
 
18933
  pkg_cv_ZRTPCPP_CFLAGS=`$PKG_CONFIG --cflags "libzrtpcpp >= 1.3.0" 2>/dev/null`
 
18934
                      test "x$?" != "x0" && pkg_failed=yes
 
18935
else
 
18936
  pkg_failed=yes
 
18937
fi
 
18938
 else
 
18939
    pkg_failed=untried
 
18940
fi
 
18941
if test -n "$ZRTPCPP_LIBS"; then
 
18942
    pkg_cv_ZRTPCPP_LIBS="$ZRTPCPP_LIBS"
 
18943
 elif test -n "$PKG_CONFIG"; then
 
18944
    if test -n "$PKG_CONFIG" && \
 
18945
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libzrtpcpp >= 1.3.0\""; } >&5
 
18946
  ($PKG_CONFIG --exists --print-errors "libzrtpcpp >= 1.3.0") 2>&5
 
18947
  ac_status=$?
 
18948
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
18949
  test $ac_status = 0; }; then
 
18950
  pkg_cv_ZRTPCPP_LIBS=`$PKG_CONFIG --libs "libzrtpcpp >= 1.3.0" 2>/dev/null`
 
18951
                      test "x$?" != "x0" && pkg_failed=yes
 
18952
else
 
18953
  pkg_failed=yes
 
18954
fi
 
18955
 else
 
18956
    pkg_failed=untried
 
18957
fi
 
18958
 
 
18959
 
 
18960
 
 
18961
if test $pkg_failed = yes; then
 
18962
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18963
$as_echo "no" >&6; }
 
18964
 
 
18965
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
18966
        _pkg_short_errors_supported=yes
 
18967
else
 
18968
        _pkg_short_errors_supported=no
 
18969
fi
 
18970
        if test $_pkg_short_errors_supported = yes; then
 
18971
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libzrtpcpp >= 1.3.0" 2>&1`
 
18972
        else
 
18973
                ZRTPCPP_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libzrtpcpp >= 1.3.0" 2>&1`
 
18974
        fi
 
18975
        # Put the nasty error message in config.log where it belongs
 
18976
        echo "$ZRTPCPP_PKG_ERRORS" >&5
 
18977
 
 
18978
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
 
18979
elif test $pkg_failed = untried; then
 
18980
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
18981
$as_echo "no" >&6; }
 
18982
        as_fn_error $? "Missing zrtp development files" "$LINENO" 5
 
18983
else
 
18984
        ZRTPCPP_CFLAGS=$pkg_cv_ZRTPCPP_CFLAGS
 
18985
        ZRTPCPP_LIBS=$pkg_cv_ZRTPCPP_LIBS
 
18986
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
18987
$as_echo "yes" >&6; }
 
18988
        with_zrtp_configure=no
 
18989
fi
 
18990
else
 
18991
        ZRTPCPP_CFLAGS=$pkg_cv_ZRTPCPP_CFLAGS
 
18992
        ZRTPCPP_LIBS=$pkg_cv_ZRTPCPP_LIBS
 
18993
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
18994
$as_echo "yes" >&6; }
 
18995
        with_zrtp_configure=yes
19000
18996
fi
19001
18997
 
19002
18998
fi;
19006
19002
#define HAVE_ZRTP `if test "x$with_zrtp" = "xyes"; then echo 1; else echo 0; fi`
19007
19003
_ACEOF
19008
19004
 
 
19005
 
 
19006
cat >>confdefs.h <<_ACEOF
 
19007
#define HAVE_ZRTP_CONFIGURE `if test "x$with_zrtp_configure" = "xyes"; then echo 1; else echo 0; fi`
 
19008
_ACEOF
 
19009
 
19009
19010
 if test "x$with_zrtp" = "xyes" ; then
19010
19011
  BUILD_ZRTP_TRUE=
19011
19012
  BUILD_ZRTP_FALSE='#'
19099
19100
$as_echo "yes" >&6; }
19100
19101
 
19101
19102
fi
 
19103
       ac_config_files="$ac_config_files src/client/dbus/Makefile doc/dbus-api/Makefile"
 
19104
 
 
19105
 
 
19106
       # Extract the first word of "dbusxx-xml2cpp", so it can be a program name with args.
 
19107
set dummy dbusxx-xml2cpp; ac_word=$2
 
19108
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
19109
$as_echo_n "checking for $ac_word... " >&6; }
 
19110
if ${ac_cv_prog_HAVE_DBUSXML2CPP+:} false; then :
 
19111
  $as_echo_n "(cached) " >&6
 
19112
else
 
19113
  if test -n "$HAVE_DBUSXML2CPP"; then
 
19114
  ac_cv_prog_HAVE_DBUSXML2CPP="$HAVE_DBUSXML2CPP" # Let the user override the test.
 
19115
else
 
19116
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
19117
for as_dir in $PATH
 
19118
do
 
19119
  IFS=$as_save_IFS
 
19120
  test -z "$as_dir" && as_dir=.
 
19121
    for ac_exec_ext in '' $ac_executable_extensions; do
 
19122
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
19123
    ac_cv_prog_HAVE_DBUSXML2CPP="true"
 
19124
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
19125
    break 2
 
19126
  fi
 
19127
done
 
19128
  done
 
19129
IFS=$as_save_IFS
 
19130
 
 
19131
  test -z "$ac_cv_prog_HAVE_DBUSXML2CPP" && ac_cv_prog_HAVE_DBUSXML2CPP="false"
 
19132
fi
 
19133
fi
 
19134
HAVE_DBUSXML2CPP=$ac_cv_prog_HAVE_DBUSXML2CPP
 
19135
if test -n "$HAVE_DBUSXML2CPP"; then
 
19136
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAVE_DBUSXML2CPP" >&5
 
19137
$as_echo "$HAVE_DBUSXML2CPP" >&6; }
 
19138
else
 
19139
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
19140
$as_echo "no" >&6; }
 
19141
fi
 
19142
 
 
19143
 
 
19144
       if test "x$HAVE_DBUSXML2CPP" = "xfalse"; then
 
19145
           as_fn_error $? "dbusxx-xml2cpp not found" "$LINENO" 5
 
19146
       fi
 
19147
 
 
19148
       if test "x$CLANG" = "xyes"; then :
 
19149
 
 
19150
             as_fn_error $? "dbus does not compile when clang is used, rerun with --without-dbus" "$LINENO" 5
 
19151
 
 
19152
fi;
19102
19153
 
19103
19154
fi;
19104
19155
 
19107
19158
#define HAVE_DBUS `if test "x$with_dbus" = "xyes"; then echo 1; else echo 0; fi`
19108
19159
_ACEOF
19109
19160
 
 
19161
 if test "x$with_dbus" = "xyes" ; then
 
19162
  USE_DBUS_TRUE=
 
19163
  USE_DBUS_FALSE='#'
 
19164
else
 
19165
  USE_DBUS_TRUE='#'
 
19166
  USE_DBUS_FALSE=
 
19167
fi
 
19168
 
19110
19169
 
19111
19170
# Instant Messaging
19112
19171
# required dependency(ies): libxpat
19118
19177
  with_instant_messaging=yes
19119
19178
fi
19120
19179
 
19121
 
if test "x$with_instant_messaging" = "xyes"; then :
19122
 
 
19123
 
 
19124
 
 
19125
 
# Check whether --with-expat was given.
19126
 
if test "${with_expat+set}" = set; then :
19127
 
  withval=$with_expat;
19128
 
        if test "$withval" = "yes"; then
19129
 
            if test -f /usr/local/include/expat.h ; then
19130
 
                expat_prefix=/usr/local
19131
 
            elif test -f /usr/include/expat.h ; then
19132
 
                expat_prefix=/usr
19133
 
            else
19134
 
                expat_prefix=""
19135
 
            fi
19136
 
            expat_requested="yes"
19137
 
        elif test -d "$withval"; then
19138
 
            expat_prefix="$withval"
19139
 
            expat_requested="yes"
19140
 
        else
19141
 
            expat_prefix=""
19142
 
            expat_requested="no"
19143
 
        fi
19144
 
 
19145
 
else
19146
 
 
19147
 
                if test -f /usr/local/include/expat.h ; then
19148
 
            expat_prefix=/usr/local
19149
 
        elif test -f /usr/include/expat.h ; then
19150
 
            expat_prefix=/usr
19151
 
        else
19152
 
            expat_prefix=""
19153
 
        fi
19154
 
 
19155
 
 
19156
 
fi
19157
 
 
19158
 
 
19159
 
 
19160
 
# Check whether --with-expat-inc was given.
19161
 
if test "${with_expat_inc+set}" = set; then :
19162
 
  withval=$with_expat_inc; expat_include_dir="$withval"
19163
 
else
19164
 
  expat_include_dir=""
19165
 
 
19166
 
fi
19167
 
 
19168
 
 
19169
 
# Check whether --with-expat-lib was given.
19170
 
if test "${with_expat_lib+set}" = set; then :
19171
 
  withval=$with_expat_lib; expat_lib_flags="$withval"
19172
 
else
19173
 
  expat_lib_flags=""
19174
 
 
19175
 
fi
19176
 
 
19177
 
 
19178
 
    EXPAT_CFLAGS=""
19179
 
    EXPAT_LIBS=""
19180
 
    EXPAT_VERSION=""
19181
 
 
19182
 
                run_expat_test="no"
19183
 
 
19184
 
    if test -n "$expat_prefix"; then
19185
 
        expat_include_dir="$expat_prefix/include"
19186
 
        expat_lib_flags="-L$expat_prefix/lib -lexpat"
19187
 
        run_expat_test="yes"
19188
 
    elif test "$expat_requested" = "yes"; then
19189
 
        if test -n "$expat_include_dir" -a -n "$expat_lib_flags"; then
19190
 
            run_expat_test="yes"
19191
 
        fi
19192
 
    else
19193
 
        run_expat_test="no"
19194
 
    fi
19195
 
 
19196
 
                if test "$run_expat_test" = "yes"; then
19197
 
 
19198
 
        saved_CPPFLAGS="$CPPFLAGS"
19199
 
        CPPFLAGS="$CPPFLAGS -I$expat_include_dir"
19200
 
 
19201
 
        saved_LDFLAGS="$LDFLAGS"
19202
 
        LIBS="$LDFLAGS $expat_lib_flags"
19203
 
 
19204
 
                                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Expat XML Parser headers in $expat_include_dir" >&5
19205
 
$as_echo_n "checking for Expat XML Parser headers in $expat_include_dir... " >&6; }
19206
 
 
19207
 
        ac_ext=cpp
19208
 
ac_cpp='$CXXCPP $CPPFLAGS'
19209
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
19210
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
19211
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
19212
 
 
19213
 
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
19214
 
/* end confdefs.h.  */
19215
 
 
19216
 
 
19217
 
#include <expat.h>
19218
 
 
19219
 
int
19220
 
main ()
19221
 
{
19222
 
 
19223
 
 
19224
 
  ;
19225
 
  return 0;
19226
 
}
19227
 
_ACEOF
19228
 
if ac_fn_cxx_try_compile "$LINENO"; then :
19229
 
 
19230
 
            EXPAT_CFLAGS="-I$expat_include_dir"
19231
 
            expat_header_found="yes"
19232
 
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
19233
 
$as_echo "found" >&6; }
19234
 
 
19235
 
else
19236
 
 
19237
 
            expat_header_found="no"
19238
 
            { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19239
 
$as_echo "not found" >&6; }
19240
 
 
19241
 
 
19242
 
fi
19243
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
19244
 
        ac_ext=cpp
19245
 
ac_cpp='$CXXCPP $CPPFLAGS'
19246
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
19247
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
19248
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
19249
 
 
19250
 
 
19251
 
                                if test "$expat_header_found" = "yes"; then
19252
 
 
19253
 
            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Expat XML Parser libraries" >&5
19254
 
$as_echo_n "checking for Expat XML Parser libraries... " >&6; }
19255
 
 
19256
 
            ac_ext=cpp
19257
 
ac_cpp='$CXXCPP $CPPFLAGS'
19258
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
19259
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
19260
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
19261
 
 
19262
 
            cat confdefs.h - <<_ACEOF >conftest.$ac_ext
19263
 
/* end confdefs.h.  */
19264
 
 
19265
 
 
19266
 
#include <expat.h>
19267
 
 
19268
 
int
19269
 
main ()
19270
 
{
19271
 
 
19272
 
XML_Parser p = XML_ParserCreate(NULL);
19273
 
XML_ParserFree(p);
19274
 
p = NULL;
19275
 
 
19276
 
 
19277
 
  ;
19278
 
  return 0;
19279
 
}
19280
 
_ACEOF
19281
 
if ac_fn_cxx_try_link "$LINENO"; then :
19282
 
 
19283
 
                EXPAT_LIBS="$expat_lib_flags"
19284
 
                expat_lib_found="yes"
19285
 
                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
19286
 
$as_echo "found" >&6; }
19287
 
 
19288
 
else
19289
 
 
19290
 
                expat_lib_found="no"
19291
 
                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
19292
 
$as_echo "not found" >&6; }
19293
 
 
19294
 
 
19295
 
fi
19296
 
rm -f core conftest.err conftest.$ac_objext \
19297
 
    conftest$ac_exeext conftest.$ac_ext
19298
 
            ac_ext=cpp
19299
 
ac_cpp='$CXXCPP $CPPFLAGS'
19300
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
19301
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
19302
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
19303
 
 
19304
 
        fi
19305
 
 
19306
 
        CPPFLAGS="$saved_CPPFLAGS"
19307
 
        LDFLAGS="$saved_LDFLAGS"
19308
 
    fi
19309
 
 
19310
 
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Expat XML Parser" >&5
19311
 
$as_echo_n "checking for Expat XML Parser... " >&6; }
19312
 
 
19313
 
    if test "$run_expat_test" = "yes"; then
19314
 
        if test "$expat_header_found" = "yes" -a "$expat_lib_found" = "yes"; then
19315
 
 
19316
 
 
19317
 
 
19318
 
 
19319
 
            HAVE_EXPAT="yes"
19320
 
        else
19321
 
            HAVE_EXPAT="no"
19322
 
        fi
19323
 
 
19324
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAVE_EXPAT" >&5
19325
 
$as_echo "$HAVE_EXPAT" >&6; }
19326
 
 
19327
 
                                if test "$HAVE_EXPAT" = "yes"; then
19328
 
 
19329
 
            expat_version_req=1.95.0
19330
 
 
19331
 
            if test  -n "$expat_version_req"; then
19332
 
 
19333
 
                { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Expat XML Parser version is >= $expat_version_req" >&5
19334
 
$as_echo_n "checking if Expat XML Parser version is >= $expat_version_req... " >&6; }
19335
 
 
19336
 
                if test -f "$expat_include_dir/expat.h"; then
19337
 
 
19338
 
                    expat_major=`cat $expat_include_dir/expat.h | \
19339
 
                                    grep '^#define.*XML_MAJOR_VERSION.*[0-9]$' | \
19340
 
                                    sed -e 's/#define XML_MAJOR_VERSION.//'`
19341
 
 
19342
 
                    expat_minor=`cat $expat_include_dir/expat.h | \
19343
 
                                    grep '^#define.*XML_MINOR_VERSION.*[0-9]$' | \
19344
 
                                    sed -e 's/#define XML_MINOR_VERSION.//'`
19345
 
 
19346
 
                    expat_revision=`cat $expat_include_dir/expat.h | \
19347
 
                                    grep '^#define.*XML_MICRO_VERSION.*[0-9]$' | \
19348
 
                                    sed -e 's/#define XML_MICRO_VERSION.//'`
19349
 
 
19350
 
                    EXPAT_VERSION="$expat_major.$expat_minor.$expat_revision"
19351
 
 
19352
 
 
19353
 
                                        expat_version_req_major=`expr $expat_version_req : '\([0-9]*\)'`
19354
 
                    expat_version_req_minor=`expr $expat_version_req : '[0-9]*\.\([0-9]*\)'`
19355
 
                    expat_version_req_revision=`expr $expat_version_req : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
19356
 
                    if test "x$expat_version_req_revision" = "x"; then
19357
 
                        expat_version_req_revision="0"
19358
 
                    fi
19359
 
 
19360
 
                    expat_version_req_number=`expr $expat_version_req_major \* 10000 \
19361
 
                                               \+ $expat_version_req_minor \* 100 \
19362
 
                                               \+ $expat_version_req_revision`
19363
 
 
19364
 
                                        expat_version_number=`expr $expat_major \* 10000 \
19365
 
                                          \+ $expat_minor \* 100 \
19366
 
                                           \+ $expat_revision`
19367
 
 
19368
 
                    expat_version_check=`expr $expat_version_number \>\= $expat_version_req_number`
19369
 
                    if test "$expat_version_check" = "1"; then
19370
 
                        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
19180
    if test "x$with_instant_messaging" = "xyes"; then :
 
19181
 
 
19182
 
 
19183
pkg_failed=no
 
19184
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPAT" >&5
 
19185
$as_echo_n "checking for EXPAT... " >&6; }
 
19186
 
 
19187
if test -n "$EXPAT_CFLAGS"; then
 
19188
    pkg_cv_EXPAT_CFLAGS="$EXPAT_CFLAGS"
 
19189
 elif test -n "$PKG_CONFIG"; then
 
19190
    if test -n "$PKG_CONFIG" && \
 
19191
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"expat >= 2.0.0\""; } >&5
 
19192
  ($PKG_CONFIG --exists --print-errors "expat >= 2.0.0") 2>&5
 
19193
  ac_status=$?
 
19194
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
19195
  test $ac_status = 0; }; then
 
19196
  pkg_cv_EXPAT_CFLAGS=`$PKG_CONFIG --cflags "expat >= 2.0.0" 2>/dev/null`
 
19197
                      test "x$?" != "x0" && pkg_failed=yes
 
19198
else
 
19199
  pkg_failed=yes
 
19200
fi
 
19201
 else
 
19202
    pkg_failed=untried
 
19203
fi
 
19204
if test -n "$EXPAT_LIBS"; then
 
19205
    pkg_cv_EXPAT_LIBS="$EXPAT_LIBS"
 
19206
 elif test -n "$PKG_CONFIG"; then
 
19207
    if test -n "$PKG_CONFIG" && \
 
19208
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"expat >= 2.0.0\""; } >&5
 
19209
  ($PKG_CONFIG --exists --print-errors "expat >= 2.0.0") 2>&5
 
19210
  ac_status=$?
 
19211
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
19212
  test $ac_status = 0; }; then
 
19213
  pkg_cv_EXPAT_LIBS=`$PKG_CONFIG --libs "expat >= 2.0.0" 2>/dev/null`
 
19214
                      test "x$?" != "x0" && pkg_failed=yes
 
19215
else
 
19216
  pkg_failed=yes
 
19217
fi
 
19218
 else
 
19219
    pkg_failed=untried
 
19220
fi
 
19221
 
 
19222
 
 
19223
 
 
19224
if test $pkg_failed = yes; then
 
19225
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
19226
$as_echo "no" >&6; }
 
19227
 
 
19228
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
19229
        _pkg_short_errors_supported=yes
 
19230
else
 
19231
        _pkg_short_errors_supported=no
 
19232
fi
 
19233
        if test $_pkg_short_errors_supported = yes; then
 
19234
                EXPAT_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "expat >= 2.0.0" 2>&1`
 
19235
        else
 
19236
                EXPAT_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "expat >= 2.0.0" 2>&1`
 
19237
        fi
 
19238
        # Put the nasty error message in config.log where it belongs
 
19239
        echo "$EXPAT_PKG_ERRORS" >&5
 
19240
 
 
19241
                   with_instant_messaging=no
 
19242
elif test $pkg_failed = untried; then
 
19243
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
19244
$as_echo "no" >&6; }
 
19245
                   with_instant_messaging=no
 
19246
else
 
19247
        EXPAT_CFLAGS=$pkg_cv_EXPAT_CFLAGS
 
19248
        EXPAT_LIBS=$pkg_cv_EXPAT_LIBS
 
19249
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
19371
19250
$as_echo "yes" >&6; }
19372
 
                    else
19373
 
                        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19374
 
$as_echo "no" >&6; }
19375
 
                        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Found Expat XML Parser $EXPAT_VERSION, which is older than required. Possible compilation failure." >&5
19376
 
$as_echo "$as_me: WARNING: Found Expat XML Parser $EXPAT_VERSION, which is older than required. Possible compilation failure." >&2;}
19377
 
                    fi
19378
 
                else
19379
 
                    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
19380
 
$as_echo "no" >&6; }
19381
 
                    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Missing expat.h header. Unable to determine Expat version." >&5
19382
 
$as_echo "$as_me: WARNING: Missing expat.h header. Unable to determine Expat version." >&2;}
19383
 
                fi
19384
 
            fi
19385
 
        fi
19386
 
 
19387
 
    else
19388
 
        HAVE_EXPAT="no"
19389
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HAVE_EXPAT" >&5
19390
 
$as_echo "$HAVE_EXPAT" >&6; }
19391
 
 
19392
 
        if test "$expat_requested" = "yes"; then
19393
 
            { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Expat XML Parser support requested but headers or library not found. Specify valid prefix of Expat using --with-expat=[DIR] or provide include directory and linker flags using --with-expat-inc and --with-expat-lib" >&5
19394
 
$as_echo "$as_me: WARNING: Expat XML Parser support requested but headers or library not found. Specify valid prefix of Expat using --with-expat=[DIR] or provide include directory and linker flags using --with-expat-inc and --with-expat-lib" >&2;}
19395
 
        fi
19396
 
    fi
19397
 
 
19398
 
    if test "$HAVE_EXPAT" != "yes"; then :
 
19251
        with_instant_messaging=yes
 
19252
fi
 
19253
 
 
19254
fi;
 
19255
if test "$with_instant_messaging" != "yes"; then :
19399
19256
  as_fn_error $? "Missing libexpat development files" "$LINENO" 5
19400
19257
fi
19401
19258
 
19402
 
fi;
19403
 
 
19404
19259
 
19405
19260
cat >>confdefs.h <<_ACEOF
19406
19261
#define HAVE_INSTANT_MESSAGING `if test "x$with_instant_messaging" = "xyes"; then echo 1; else echo 0; fi`
19828
19683
 
19829
19684
if test "x$with_sdes" = "xyes"; then :
19830
19685
 
19831
 
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking lib pcre" >&5
19832
 
$as_echo_n "checking lib pcre... " >&6; }
19833
 
 
19834
 
# Check whether --with-pcre was given.
19835
 
if test "${with_pcre+set}" = set; then :
19836
 
  withval=$with_pcre;
19837
 
else
19838
 
  with_pcre="yes"
19839
 
fi
19840
 
 
19841
 
if test ".$with_pcre" = ".no" ; then
19842
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
19843
 
$as_echo "disabled" >&6; }
19844
 
 
19845
 
else
19846
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: (testing)" >&5
19847
 
$as_echo "(testing)" >&6; }
19848
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pcre_study in -lpcre" >&5
19849
 
$as_echo_n "checking for pcre_study in -lpcre... " >&6; }
19850
 
if ${ac_cv_lib_pcre_pcre_study+:} false; then :
19851
 
  $as_echo_n "(cached) " >&6
19852
 
else
19853
 
  ac_check_lib_save_LIBS=$LIBS
19854
 
LIBS="-lpcre  $LIBS"
19855
 
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
19856
 
/* end confdefs.h.  */
19857
 
 
19858
 
/* Override any GCC internal prototype to avoid an error.
19859
 
   Use char because int might match the return type of a GCC
19860
 
   builtin and then its argument prototype would still apply.  */
19861
 
#ifdef __cplusplus
19862
 
extern "C"
19863
 
#endif
19864
 
char pcre_study ();
19865
 
int
19866
 
main ()
19867
 
{
19868
 
return pcre_study ();
19869
 
  ;
19870
 
  return 0;
19871
 
}
19872
 
_ACEOF
19873
 
if ac_fn_cxx_try_link "$LINENO"; then :
19874
 
  ac_cv_lib_pcre_pcre_study=yes
19875
 
else
19876
 
  ac_cv_lib_pcre_pcre_study=no
19877
 
fi
19878
 
rm -f core conftest.err conftest.$ac_objext \
19879
 
    conftest$ac_exeext conftest.$ac_ext
19880
 
LIBS=$ac_check_lib_save_LIBS
19881
 
fi
19882
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pcre_pcre_study" >&5
19883
 
$as_echo "$ac_cv_lib_pcre_pcre_study" >&6; }
19884
 
if test "x$ac_cv_lib_pcre_pcre_study" = xyes; then :
19885
 
  cat >>confdefs.h <<_ACEOF
19886
 
#define HAVE_LIBPCRE 1
19887
 
_ACEOF
19888
 
 
19889
 
  LIBS="-lpcre $LIBS"
19890
 
 
19891
 
fi
19892
 
 
19893
 
  if test "$ac_cv_lib_pcre_pcre_study" = "yes" ; then
19894
 
     PCRE_LIBS="-lpcre"
19895
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking lib pcre" >&5
19896
 
$as_echo_n "checking lib pcre... " >&6; }
19897
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PCRE_LIBS" >&5
19898
 
$as_echo "$PCRE_LIBS" >&6; }
19899
 
 
19900
 
  else
19901
 
     OLDLDFLAGS="$LDFLAGS" ; LDFLAGS="$LDFLAGS -L$with_pcre/lib"
19902
 
     OLDCPPFLAGS="$CPPFLAGS" ; CPPFLAGS="$CPPFLAGS -I$with_pcre/include"
19903
 
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pcre_compile in -lpcre" >&5
19904
 
$as_echo_n "checking for pcre_compile in -lpcre... " >&6; }
19905
 
if ${ac_cv_lib_pcre_pcre_compile+:} false; then :
19906
 
  $as_echo_n "(cached) " >&6
19907
 
else
19908
 
  ac_check_lib_save_LIBS=$LIBS
19909
 
LIBS="-lpcre  $LIBS"
19910
 
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
19911
 
/* end confdefs.h.  */
19912
 
 
19913
 
/* Override any GCC internal prototype to avoid an error.
19914
 
   Use char because int might match the return type of a GCC
19915
 
   builtin and then its argument prototype would still apply.  */
19916
 
#ifdef __cplusplus
19917
 
extern "C"
19918
 
#endif
19919
 
char pcre_compile ();
19920
 
int
19921
 
main ()
19922
 
{
19923
 
return pcre_compile ();
19924
 
  ;
19925
 
  return 0;
19926
 
}
19927
 
_ACEOF
19928
 
if ac_fn_cxx_try_link "$LINENO"; then :
19929
 
  ac_cv_lib_pcre_pcre_compile=yes
19930
 
else
19931
 
  ac_cv_lib_pcre_pcre_compile=no
19932
 
fi
19933
 
rm -f core conftest.err conftest.$ac_objext \
19934
 
    conftest$ac_exeext conftest.$ac_ext
19935
 
LIBS=$ac_check_lib_save_LIBS
19936
 
fi
19937
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pcre_pcre_compile" >&5
19938
 
$as_echo "$ac_cv_lib_pcre_pcre_compile" >&6; }
19939
 
if test "x$ac_cv_lib_pcre_pcre_compile" = xyes; then :
19940
 
  cat >>confdefs.h <<_ACEOF
19941
 
#define HAVE_LIBPCRE 1
19942
 
_ACEOF
19943
 
 
19944
 
  LIBS="-lpcre $LIBS"
19945
 
 
19946
 
fi
19947
 
 
19948
 
     CPPFLAGS="$OLDCPPFLAGS"
19949
 
     LDFLAGS="$OLDLDFLAGS"
19950
 
     if test "$ac_cv_lib_pcre_pcre_compile" = "yes" ; then
19951
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: .setting PCRE_LIBS -L$with_pcre/lib -lpcre" >&5
19952
 
$as_echo ".setting PCRE_LIBS -L$with_pcre/lib -lpcre" >&6; }
19953
 
        PCRE_LIBS="-L$with_pcre/lib -lpcre"
19954
 
        test -d "$with_pcre/include" && PCRE_CFLAGS="-I$with_pcre/include"
19955
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking lib pcre" >&5
19956
 
$as_echo_n "checking lib pcre... " >&6; }
19957
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PCRE_LIBS" >&5
19958
 
$as_echo "$PCRE_LIBS" >&6; }
19959
 
 
19960
 
     else
19961
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: checking lib pcre" >&5
19962
 
$as_echo_n "checking lib pcre... " >&6; }
19963
 
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, (WARNING)" >&5
19964
 
$as_echo "no, (WARNING)" >&6; }
19965
 
 
19966
 
     fi
19967
 
  fi
19968
 
fi
19969
 
 
19970
 
 
19971
 
 
19972
 
 
 
19686
 
 
19687
pkg_failed=no
 
19688
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for PCRE" >&5
 
19689
$as_echo_n "checking for PCRE... " >&6; }
 
19690
 
 
19691
if test -n "$PCRE_CFLAGS"; then
 
19692
    pkg_cv_PCRE_CFLAGS="$PCRE_CFLAGS"
 
19693
 elif test -n "$PKG_CONFIG"; then
 
19694
    if test -n "$PKG_CONFIG" && \
 
19695
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpcre\""; } >&5
 
19696
  ($PKG_CONFIG --exists --print-errors "libpcre") 2>&5
 
19697
  ac_status=$?
 
19698
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
19699
  test $ac_status = 0; }; then
 
19700
  pkg_cv_PCRE_CFLAGS=`$PKG_CONFIG --cflags "libpcre" 2>/dev/null`
 
19701
                      test "x$?" != "x0" && pkg_failed=yes
 
19702
else
 
19703
  pkg_failed=yes
 
19704
fi
 
19705
 else
 
19706
    pkg_failed=untried
 
19707
fi
 
19708
if test -n "$PCRE_LIBS"; then
 
19709
    pkg_cv_PCRE_LIBS="$PCRE_LIBS"
 
19710
 elif test -n "$PKG_CONFIG"; then
 
19711
    if test -n "$PKG_CONFIG" && \
 
19712
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libpcre\""; } >&5
 
19713
  ($PKG_CONFIG --exists --print-errors "libpcre") 2>&5
 
19714
  ac_status=$?
 
19715
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
19716
  test $ac_status = 0; }; then
 
19717
  pkg_cv_PCRE_LIBS=`$PKG_CONFIG --libs "libpcre" 2>/dev/null`
 
19718
                      test "x$?" != "x0" && pkg_failed=yes
 
19719
else
 
19720
  pkg_failed=yes
 
19721
fi
 
19722
 else
 
19723
    pkg_failed=untried
 
19724
fi
 
19725
 
 
19726
 
 
19727
 
 
19728
if test $pkg_failed = yes; then
 
19729
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
19730
$as_echo "no" >&6; }
 
19731
 
 
19732
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
 
19733
        _pkg_short_errors_supported=yes
 
19734
else
 
19735
        _pkg_short_errors_supported=no
 
19736
fi
 
19737
        if test $_pkg_short_errors_supported = yes; then
 
19738
                PCRE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libpcre" 2>&1`
 
19739
        else
 
19740
                PCRE_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libpcre" 2>&1`
 
19741
        fi
 
19742
        # Put the nasty error message in config.log where it belongs
 
19743
        echo "$PCRE_PKG_ERRORS" >&5
 
19744
 
 
19745
        as_fn_error $? "libpcre not found" "$LINENO" 5
 
19746
elif test $pkg_failed = untried; then
 
19747
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
19748
$as_echo "no" >&6; }
 
19749
        as_fn_error $? "libpcre not found" "$LINENO" 5
 
19750
else
 
19751
        PCRE_CFLAGS=$pkg_cv_PCRE_CFLAGS
 
19752
        PCRE_LIBS=$pkg_cv_PCRE_LIBS
 
19753
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
19754
$as_echo "yes" >&6; }
 
19755
 
 
19756
fi
19973
19757
fi;
19974
19758
 
19975
19759
 
19976
 
 
19977
19760
cat >>confdefs.h <<_ACEOF
19978
19761
#define HAVE_SDES `if test "x$with_sdes" = "xyes"; then echo 1; else echo 0; fi`
19979
19762
_ACEOF
20783
20566
fi
20784
20567
 
20785
20568
 
 
20569
# Check whether --enable-ipv6 was given.
 
20570
if test "${enable_ipv6+set}" = set; then :
 
20571
  enableval=$enable_ipv6;
 
20572
fi
 
20573
 
 
20574
 
 
20575
 
 
20576
cat >>confdefs.h <<_ACEOF
 
20577
#define HAVE_IPV6 `if test "x$enable_ipv6" = "xyes"; then echo 1; else echo 0; fi`
 
20578
_ACEOF
 
20579
 
 
20580
 if test "x$enable_ipv6" = "xyes" ; then
 
20581
  BUILD_IPV6_TRUE=
 
20582
  BUILD_IPV6_FALSE='#'
 
20583
else
 
20584
  BUILD_IPV6_TRUE='#'
 
20585
  BUILD_IPV6_FALSE=
 
20586
fi
 
20587
 
 
20588
 
20786
20589
 
20787
20590
# DOXYGEN
20788
20591
# required dependency(ies): doxygen
20908
20711
fi
20909
20712
 
20910
20713
 
20911
 
ac_config_files="$ac_config_files Makefile libs/Makefile libs/iax2/Makefile src/Makefile src/sip/Makefile src/im/Makefile src/iax/Makefile src/audio/Makefile src/audio/audiortp/Makefile src/audio/pulseaudio/Makefile src/audio/alsa/Makefile src/audio/sound/Makefile src/audio/codecs/Makefile src/config/Makefile src/client/Makefile src/client/dbus/Makefile src/hooks/Makefile src/history/Makefile src/video/Makefile src/video/test/Makefile test/Makefile ringtones/Makefile man/Makefile doc/Makefile doc/dbus-api/Makefile doc/doxygen/Makefile"
 
20714
ac_config_files="$ac_config_files Makefile libs/Makefile libs/iax2/Makefile src/Makefile src/sip/Makefile src/im/Makefile src/iax/Makefile src/audio/Makefile src/audio/audiortp/Makefile src/audio/pulseaudio/Makefile src/audio/alsa/Makefile src/audio/jack/Makefile src/audio/sound/Makefile src/audio/codecs/Makefile src/config/Makefile src/client/Makefile src/hooks/Makefile src/history/Makefile src/video/Makefile src/video/v4l2/Makefile src/video/test/Makefile test/Makefile ringtones/Makefile man/Makefile doc/Makefile doc/doxygen/Makefile"
20912
20715
 
20913
20716
 
20914
20717
# Go!
21045
20848
  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
21046
20849
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21047
20850
fi
 
20851
if test -z "${USE_ANDROID_TRUE}" && test -z "${USE_ANDROID_FALSE}"; then
 
20852
  as_fn_error $? "conditional \"USE_ANDROID\" was never defined.
 
20853
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
20854
fi
 
20855
if test -z "${BUILD_OPENSL_TRUE}" && test -z "${BUILD_OPENSL_FALSE}"; then
 
20856
  as_fn_error $? "conditional \"BUILD_OPENSL\" was never defined.
 
20857
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
20858
fi
21048
20859
if test -z "${BUILD_ALSA_TRUE}" && test -z "${BUILD_ALSA_FALSE}"; then
21049
20860
  as_fn_error $? "conditional \"BUILD_ALSA\" was never defined.
21050
20861
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21053
20864
  as_fn_error $? "conditional \"BUILD_PULSE\" was never defined.
21054
20865
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21055
20866
fi
 
20867
if test -z "${BUILD_JACK_TRUE}" && test -z "${BUILD_JACK_FALSE}"; then
 
20868
  as_fn_error $? "conditional \"BUILD_JACK\" was never defined.
 
20869
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
20870
fi
21056
20871
if test -z "${SFL_VIDEO_TRUE}" && test -z "${SFL_VIDEO_FALSE}"; then
21057
20872
  as_fn_error $? "conditional \"SFL_VIDEO\" was never defined.
21058
20873
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21077
20892
  as_fn_error $? "conditional \"BUILD_ZRTP\" was never defined.
21078
20893
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21079
20894
fi
 
20895
if test -z "${USE_DBUS_TRUE}" && test -z "${USE_DBUS_FALSE}"; then
 
20896
  as_fn_error $? "conditional \"USE_DBUS\" was never defined.
 
20897
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
20898
fi
21080
20899
if test -z "${BUILD_INSTANT_MESSAGING_TRUE}" && test -z "${BUILD_INSTANT_MESSAGING_FALSE}"; then
21081
20900
  as_fn_error $? "conditional \"BUILD_INSTANT_MESSAGING\" was never defined.
21082
20901
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21121
20940
  as_fn_error $? "conditional \"USE_NETWORKMANAGER\" was never defined.
21122
20941
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21123
20942
fi
 
20943
if test -z "${BUILD_IPV6_TRUE}" && test -z "${BUILD_IPV6_FALSE}"; then
 
20944
  as_fn_error $? "conditional \"BUILD_IPV6\" was never defined.
 
20945
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
20946
fi
21124
20947
if test -z "${ENABLE_DOXYGEN_TRUE}" && test -z "${ENABLE_DOXYGEN_FALSE}"; then
21125
20948
  as_fn_error $? "conditional \"ENABLE_DOXYGEN\" was never defined.
21126
20949
Usually this means the macro was only invoked conditionally." "$LINENO" 5
21534
21357
# report actual input values of CONFIG_FILES etc. instead of their
21535
21358
# values after options handling.
21536
21359
ac_log="
21537
 
This file was extended by sflphone $as_me 1.3.0, which was
 
21360
This file was extended by sflphone $as_me 1.4.1, which was
21538
21361
generated by GNU Autoconf 2.68.  Invocation command line was
21539
21362
 
21540
21363
  CONFIG_FILES    = $CONFIG_FILES
21600
21423
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
21601
21424
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
21602
21425
ac_cs_version="\\
21603
 
sflphone config.status 1.3.0
 
21426
sflphone config.status 1.4.1
21604
21427
configured by $0, generated by GNU Autoconf 2.68,
21605
21428
  with options \\"\$ac_cs_config\\"
21606
21429
 
22107
21930
    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
22108
21931
    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
22109
21932
    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
 
21933
    "src/client/dbus/Makefile") CONFIG_FILES="$CONFIG_FILES src/client/dbus/Makefile" ;;
 
21934
    "doc/dbus-api/Makefile") CONFIG_FILES="$CONFIG_FILES doc/dbus-api/Makefile" ;;
22110
21935
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
22111
21936
    "libs/Makefile") CONFIG_FILES="$CONFIG_FILES libs/Makefile" ;;
22112
21937
    "libs/iax2/Makefile") CONFIG_FILES="$CONFIG_FILES libs/iax2/Makefile" ;;
22118
21943
    "src/audio/audiortp/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/audiortp/Makefile" ;;
22119
21944
    "src/audio/pulseaudio/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/pulseaudio/Makefile" ;;
22120
21945
    "src/audio/alsa/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/alsa/Makefile" ;;
 
21946
    "src/audio/jack/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/jack/Makefile" ;;
22121
21947
    "src/audio/sound/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/sound/Makefile" ;;
22122
21948
    "src/audio/codecs/Makefile") CONFIG_FILES="$CONFIG_FILES src/audio/codecs/Makefile" ;;
22123
21949
    "src/config/Makefile") CONFIG_FILES="$CONFIG_FILES src/config/Makefile" ;;
22124
21950
    "src/client/Makefile") CONFIG_FILES="$CONFIG_FILES src/client/Makefile" ;;
22125
 
    "src/client/dbus/Makefile") CONFIG_FILES="$CONFIG_FILES src/client/dbus/Makefile" ;;
22126
21951
    "src/hooks/Makefile") CONFIG_FILES="$CONFIG_FILES src/hooks/Makefile" ;;
22127
21952
    "src/history/Makefile") CONFIG_FILES="$CONFIG_FILES src/history/Makefile" ;;
22128
21953
    "src/video/Makefile") CONFIG_FILES="$CONFIG_FILES src/video/Makefile" ;;
 
21954
    "src/video/v4l2/Makefile") CONFIG_FILES="$CONFIG_FILES src/video/v4l2/Makefile" ;;
22129
21955
    "src/video/test/Makefile") CONFIG_FILES="$CONFIG_FILES src/video/test/Makefile" ;;
22130
21956
    "test/Makefile") CONFIG_FILES="$CONFIG_FILES test/Makefile" ;;
22131
21957
    "ringtones/Makefile") CONFIG_FILES="$CONFIG_FILES ringtones/Makefile" ;;
22132
21958
    "man/Makefile") CONFIG_FILES="$CONFIG_FILES man/Makefile" ;;
22133
21959
    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
22134
 
    "doc/dbus-api/Makefile") CONFIG_FILES="$CONFIG_FILES doc/dbus-api/Makefile" ;;
22135
21960
    "doc/doxygen/Makefile") CONFIG_FILES="$CONFIG_FILES doc/doxygen/Makefile" ;;
22136
21961
 
22137
21962
  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
23661
23486
 
23662
23487
 
23663
23488
 
23664
 
subdirs="$subdirs libs/pjproject-2.1.0"
 
23489
subdirs="$subdirs libs/pjproject-2.2.1"
23665
23490
 
23666
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuration done! Please make sure that pjsip library (libs/pjproject-2.1.0) has already been compiled. Run \`make' to build the software." >&5
23667
 
$as_echo "$as_me: Configuration done! Please make sure that pjsip library (libs/pjproject-2.1.0) has already been compiled. Run \`make' to build the software." >&6;}
 
23491
{ $as_echo "$as_me:${as_lineno-$LINENO}: Configuration done! Please make sure that pjsip library (libs/pjproject-2.2.1) has already been compiled. Run \`make' to build the software." >&5
 
23492
$as_echo "$as_me: Configuration done! Please make sure that pjsip library (libs/pjproject-2.2.1) has already been compiled. Run \`make' to build the software." >&6;}