diff options
| author | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-11-21 02:23:03 -0600 |
|---|---|---|
| committer | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-11-21 02:23:03 -0600 |
| commit | 9b58d35185905f8334142bf4988cb784e993aea7 (patch) | |
| tree | f83ec30722464f6e4d23d6e7a40201d7ef5b6bf4 /tde-i18n-sv/docs/kdemultimedia/artsbuilder | |
| download | tde-i18n-9b58d35185905f8334142bf4988cb784e993aea7.tar.gz tde-i18n-9b58d35185905f8334142bf4988cb784e993aea7.zip | |
Initial import of extracted KDE i18n tarballs
Diffstat (limited to 'tde-i18n-sv/docs/kdemultimedia/artsbuilder')
39 files changed, 11509 insertions, 0 deletions
diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.am b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.am new file mode 100644 index 00000000000..9e41d9df652 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = sv +SUBDIRS = $(AUTODIRS) +KDE_DOCS = AUTO +KDE_MANS = AUTO diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.in b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.in new file mode 100644 index 00000000000..4219c684938 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/Makefile.in @@ -0,0 +1,635 @@ +# Makefile.in generated by automake 1.10.1 from Makefile.am. +# KDE tags expanded automatically by am_edit - $Revision: 483858 $ +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +subdir = docs/kdemultimedia/artsbuilder +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ + $(top_srcdir)/configure.in +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +SOURCES = +DIST_SOURCES = +#>- RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ +#>- html-recursive info-recursive install-data-recursive \ +#>- install-dvi-recursive install-exec-recursive \ +#>- install-html-recursive install-info-recursive \ +#>- install-pdf-recursive install-ps-recursive install-recursive \ +#>- installcheck-recursive installdirs-recursive pdf-recursive \ +#>- ps-recursive uninstall-recursive +#>+ 7 +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive nmcheck-recursive bcheck-recursive +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +#>- DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +#>+ 1 +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) $(KDE_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +ARTSCCONFIG = @ARTSCCONFIG@ +AUTOCONF = @AUTOCONF@ +AUTODIRS = @AUTODIRS@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CONF_FILES = @CONF_FILES@ +CYGPATH_W = @CYGPATH_W@ +DCOPIDL = @DCOPIDL@ +DCOPIDL2CPP = @DCOPIDL2CPP@ +DCOPIDLNG = @DCOPIDLNG@ +DCOP_DEPENDENCIES = @DCOP_DEPENDENCIES@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +GMSGFMT = @GMSGFMT@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +KCFG_DEPENDENCIES = @KCFG_DEPENDENCIES@ +KCONFIG_COMPILER = @KCONFIG_COMPILER@ +KDECONFIG = @KDECONFIG@ +KDE_EXTRA_RPATH = @KDE_EXTRA_RPATH@ +KDE_RPATH = @KDE_RPATH@ +KDE_XSL_STYLESHEET = @KDE_XSL_STYLESHEET@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MAKEKDEWIDGETS = @MAKEKDEWIDGETS@ +MCOPIDL = @MCOPIDL@ +MEINPROC = @MEINPROC@ +MKDIR_P = @MKDIR_P@ +MSGFMT = @MSGFMT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TOPSUBDIRS = @TOPSUBDIRS@ +VERSION = @VERSION@ +XGETTEXT = @XGETTEXT@ +XMLLINT = @XMLLINT@ +X_RPATH = @X_RPATH@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +#>- bindir = @bindir@ +#>+ 2 +DEPDIR = .deps +bindir = @bindir@ +build_alias = @build_alias@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host_alias = @host_alias@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +kde_appsdir = @kde_appsdir@ +kde_bindir = @kde_bindir@ +kde_confdir = @kde_confdir@ +kde_datadir = @kde_datadir@ +kde_htmldir = @kde_htmldir@ +kde_icondir = @kde_icondir@ +kde_kcfgdir = @kde_kcfgdir@ +kde_libs_htmldir = @kde_libs_htmldir@ +kde_libs_prefix = @kde_libs_prefix@ +kde_locale = @kde_locale@ +kde_mimedir = @kde_mimedir@ +kde_moduledir = @kde_moduledir@ +kde_servicesdir = @kde_servicesdir@ +kde_servicetypesdir = @kde_servicetypesdir@ +kde_sounddir = @kde_sounddir@ +kde_styledir = @kde_styledir@ +kde_templatesdir = @kde_templatesdir@ +kde_wallpaperdir = @kde_wallpaperdir@ +kde_widgetdir = @kde_widgetdir@ +kdeinitdir = @kdeinitdir@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +xdg_appsdir = @xdg_appsdir@ +xdg_directorydir = @xdg_directorydir@ +xdg_menudir = @xdg_menudir@ +KDE_LANG = sv +#>- SUBDIRS = $(AUTODIRS) +#>+ 1 +SUBDIRS =. images +KDE_DOCS = AUTO +KDE_MANS = AUTO +#>- all: all-recursive +#>+ 1 +all: docs-am all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) +#>- @for dep in $?; do \ +#>- case '$(am__configure_deps)' in \ +#>- *$$dep*) \ +#>- cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ +#>- && exit 0; \ +#>- exit 1;; \ +#>- esac; \ +#>- done; \ +#>- echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile'; \ +#>- cd $(top_srcdir) && \ +#>- $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile +#>+ 12 + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/kdemultimedia/artsbuilder/Makefile.in +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +$(RECURSIVE_CLEAN_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +#>- distdir: $(DISTFILES) +#>+ 1 +distdir: distdir-nls $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done + list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + distdir=`$(am__cd) $(distdir) && pwd`; \ + top_distdir=`$(am__cd) $(top_distdir) && pwd`; \ + (cd $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$top_distdir" \ + distdir="$$distdir/$$subdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +#>- uninstall: uninstall-recursive +#>+ 1 +uninstall: uninstall-docs uninstall-nls uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +#>- clean: clean-recursive +#>+ 1 +clean: kde-rpo-clean clean-recursive + +#>- clean-am: clean-generic mostlyclean-am +#>+ 1 +clean-am: clean-docs clean-bcheck clean-generic mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +info: info-recursive + +info-am: + +#>- install-data-am: +#>+ 1 +install-data-am: install-docs install-nls + +install-dvi: install-dvi-recursive + +install-exec-am: + +install-html: install-html-recursive + +install-info: install-info-recursive + +install-man: + +install-pdf: install-pdf-recursive + +install-ps: install-ps-recursive + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) install-am \ + install-strip + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am check check-am clean clean-generic ctags \ + ctags-recursive distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \ + tags-recursive uninstall uninstall-am + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: + +#>+ 2 +KDE_DIST=future.docbook index.docbook arts-structure.png porting.docbook glossary.docbook helping.docbook artsbuilder.docbook detail.docbook midiintro.docbook modules.docbook mcop.docbook gui.docbook faq.docbook index.cache.bz2 midi.docbook tools.docbook Makefile.in digitalaudio.docbook references.docbook apis.docbook Makefile.am + +#>+ 24 +index.cache.bz2: $(srcdir)/index.docbook $(KDE_XSL_STYLESHEET) arts-structure.png glossary.docbook porting.docbook apis.docbook gui.docbook references.docbook mcop.docbook index.docbook detail.docbook future.docbook artsbuilder.docbook digitalaudio.docbook faq.docbook modules.docbook tools.docbook midi.docbook helping.docbook midiintro.docbook + @if test -n "$(MEINPROC)"; then echo $(MEINPROC) --check --cache index.cache.bz2 $(srcdir)/index.docbook; $(MEINPROC) --check --cache index.cache.bz2 $(srcdir)/index.docbook; fi + +docs-am: index.cache.bz2 + +install-docs: docs-am install-nls + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder + @if test -f index.cache.bz2; then \ + echo $(INSTALL_DATA) index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/; \ + $(INSTALL_DATA) index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/; \ + elif test -f $(srcdir)/index.cache.bz2; then \ + echo $(INSTALL_DATA) $(srcdir)/index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/; \ + $(INSTALL_DATA) $(srcdir)/index.cache.bz2 $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/; \ + fi + -rm -f $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/common + $(LN_S) $(kde_libs_htmldir)/$(KDE_LANG)/common $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/common + +uninstall-docs: + -rm -rf $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder + +clean-docs: + -rm -f index.cache.bz2 + + +#>+ 13 +install-nls: + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder + @for base in arts-structure.png glossary.docbook porting.docbook apis.docbook gui.docbook references.docbook mcop.docbook index.docbook detail.docbook future.docbook artsbuilder.docbook digitalaudio.docbook faq.docbook modules.docbook tools.docbook midi.docbook helping.docbook midiintro.docbook ; do \ + echo $(INSTALL_DATA) $$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/$$base ;\ + $(INSTALL_DATA) $(srcdir)/$$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/$$base ;\ + done + +uninstall-nls: + for base in arts-structure.png glossary.docbook porting.docbook apis.docbook gui.docbook references.docbook mcop.docbook index.docbook detail.docbook future.docbook artsbuilder.docbook digitalaudio.docbook faq.docbook modules.docbook tools.docbook midi.docbook helping.docbook midiintro.docbook ; do \ + rm -f $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/$$base ;\ + done + + +#>+ 5 +distdir-nls: + for file in arts-structure.png glossary.docbook porting.docbook apis.docbook gui.docbook references.docbook mcop.docbook index.docbook detail.docbook future.docbook artsbuilder.docbook digitalaudio.docbook faq.docbook modules.docbook tools.docbook midi.docbook helping.docbook midiintro.docbook ; do \ + cp $(srcdir)/$$file $(distdir); \ + done + +#>+ 15 +force-reedit: + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/kdemultimedia/artsbuilder/Makefile.in + + +#>+ 21 +clean-bcheck: + rm -f *.bchecktest.cc *.bchecktest.cc.class a.out + +bcheck: bcheck-recursive + +bcheck-am: + @for i in ; do \ + if test $(srcdir)/$$i -nt $$i.bchecktest.cc; then \ + echo "int main() {return 0;}" > $$i.bchecktest.cc ; \ + echo "#include \"$$i\"" >> $$i.bchecktest.cc ; \ + echo "$$i"; \ + if ! $(CXX) $(DEFS) -I. -I$(srcdir) -I$(top_builddir) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(KDE_CXXFLAGS) --dump-class-hierarchy -c $$i.bchecktest.cc; then \ + rm -f $$i.bchecktest.cc; exit 1; \ + fi ; \ + echo "" >> $$i.bchecktest.cc.class; \ + perl $(top_srcdir)/admin/bcheck.pl $$i.bchecktest.cc.class || { rm -f $$i.bchecktest.cc; exit 1; }; \ + rm -f a.out; \ + fi ; \ + done + + +#>+ 3 +final: + $(MAKE) all-am + +#>+ 3 +final-install: + $(MAKE) install-am + +#>+ 3 +no-final: + $(MAKE) all-am + +#>+ 3 +no-final-install: + $(MAKE) install-am + +#>+ 3 +kde-rpo-clean: + -rm -f *.rpo + +#>+ 3 +nmcheck: +nmcheck-am: nmcheck diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/apis.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/apis.docbook new file mode 100644 index 00000000000..15b76c4003a --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/apis.docbook @@ -0,0 +1,424 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="arts-apis"> +<title +>&arts; programmeringsgränssnitt</title> + +<sect1 id="api-overview"> +<title +>Översikt</title> +<para +>aRts är inte enbart ett program, den tillhandahåller också ett antal olika programmeringsgränssnitt (API) för olika syften. I det här avsnittet, försöker jag beskriva "helhetsbilden", en snabb överblick av vad de här gränssnitten är tänkta att användas till, och hur de hänger samman. </para> + +<para +>Det finns en viktig distinktion som måste göras: De flesta gränssnitten är <emphasis +> språk- och platsoberoende</emphasis +> eftersom de är specificerade som <emphasis +>mcopidl</emphasis +>. Det här betyder att man egentligen kan använda den service som de tillhandahåller från vilket språk som helst, implementera dem i vilket språk som helst, och man behöver inte bry sig om ifall man pratar med lokala eller fjärrobjekt. Här är först en lista på dem: </para> + + +<variablelist> +<varlistentry> +<term +>core.idl</term> + <listitem +><para +>Grundläggande definitioner som bildar grunden i MCOP-funktionen, som själva protokollet, definitioner av objekt, handlaren, flödessystemet och så vidare. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsflow.idl</term> + + <listitem +><para +>De här innehåller flödessystemet som man använder för att ansluta ljudflöden, definitionen av <emphasis +>Arts::SynthModule</emphasis +> som är grunden för alla gränssnitt som har strömmar, och till slut några användbara ljudobjekt </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>kmedia2.idl</term> + + + <listitem +><para +>Här definieras <emphasis +>Arts::PlayObject</emphasis +>, ett objekt som kan spela upp en mediatyp. Mediaspelare som KDE:s mediaspelare noatun kommer att kunna spela upp vilka media som helst som har PlayObject. Därför är det vettigt att implementera PlayObject för olika format (som mp3, mpg video, midi, wav, ...) med det här som grund, och det finns redan många. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>soundserver.idl</term> + + <listitem +><para +>Här definieras ett gränssnitt för systemets ljudserver artsd. Gränssnittet benämns <emphasis +>Arts::SoundServer</emphasis +>, och implementerar funktioner som att ta emot strömmar från nätverket, spela samplingar, skapa andra egna aRts-objekt och så vidare. Nätverkstransparens är underförstådd eftersom MCOP används (som för allt övrigt här). </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsbuilder.idl</term> + <listitem +><para +>Den här modulen definierar grundläggande flödesfunktioner, dvs. kombinera enklare objekt till mer komplexa genom att definiera en graf som binder samman dem. Den definierar det grundläggande gränssnitten <emphasis +>Arts::StructureDesc</emphasis +>, <emphasis +>Arts::ModuleDesc</emphasis +> och <emphasis +>Arts::PortDesc</emphasis +> som innehåller en beskrivning av en struktur, modul och port. Det finns också ett sätt att skapa ett "levande nätverk av objekt" från de här förbindelserna och värdebeskrivningarna med användning av en fabrik. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmidi.idl</term> + + <listitem +><para +>Den här modulen definierar grundläggande midi-funktioner, som objekt som skapar midi-händelser, vad en midi-händelse är, och <emphasis +>Arts::MidiManager</emphasis +> för att förbinda producenter och konsumenter av midi-händelser, och så vidare. Som alltid är nätverkstransparens underförstådd. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmodules.idl</term> + <listitem +><para +>Här finns diverse ytterligare filter, oscillatorer, ljudeffekter, fördröjningar och så vidare, allt som behövs för riktigt användbar signalbehandling, och för att bygga komplexa instrument och effekter från de här grundläggande byggblocken. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsgui.idl</term> + + <listitem +><para +>Det här tar hand om synliga objekt. Det definierar den grundläggande typen <emphasis +> Arts::Widget</emphasis +> som alla moduler med ett grafiskt gränssnitt utgår från. Det här åstadkommer oberoende av verktygslåda, och ... visuell redigering av det grafiska gränssnittet, och möjlighet att serialisera grafiska gränssnitt. Dessutom, eftersom de grafiska komponenterna har normala egenskaper, kan deras värden på ett rättframt sätt anslutas till vissa signalbehandlingsmoduler. (dvs. värdet av ett skjutreglage till klippning för ett filter). Som alltid, nätverkstransparent. </para +></listitem> + +</varlistentry> + +</variablelist> +<para +>Där det är möjligt implementeras aRts själv med IDL. Å andra sidan finns det några <emphasis +>språkspecifika</emphasis +> programmeringsgränssnitt, som antingen använder enkel C++ eller C. Det är ofta förnuftigt att använda IDL-gränssnitt om möjligt, och de övriga gränssnitten när det är nödvändigt. Här är en lista på språkspecifika programmeringsgränssnitt: </para> + +<variablelist> + +<varlistentry> +<term +>KNotify, KAudioPlayer (ingår i libkdecore)</term> + + <listitem +><para +>De här är KDE:s programmeringsgränssnitt för bekvämlighet med de enkla och väldigt vanliga fall, när man bara vill spela upp en sampling. Gränssnitten är enkel C++, Qt/KDE-optimerade, och så enkla som de kan vara. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsc</term> + <listitem +><para +>Enkelt C-gränssnitt för ljudservern. Mycket användbart för att anpassa gamla program. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libmcop</term> + + <listitem +><para +>Här sker all magi som har med MCOP att göra. Biblioteket innehåller de grundläggande saker som behövs för att skriva ett enkelt MCOP-program, avsändaren, tidtagning, I/O-hantering, men också de interna funktioner som behövs för att själva MCOP-protokollet ska fungera. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsflow</term> + <listitem +><para +>Förutom implementeringen av artsflow.idl, några användbara verktyg för konvertering av samplingsfrekvens. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libqiomanager</term> + + <listitem +><para +>Integration av MCOP i Qt:s händelsesnurra, när man skriver Qt-program som använder MCOP. </para +></listitem> + +</varlistentry> + +</variablelist> + + + +</sect1> +<sect1 id="knotify"> +<title +>knotify</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="kaudioplayer"> +<title +>kaudioplayer</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="libkmid"> +<title +>libkmid</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="kmedia2"> +<title +>kmedia2</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="soundserver"> +<title +>ljudserver</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="artsflow"> +<title +>artsflow</title> +<para +>Ännu inte skrivet. </para> +</sect1> + +<sect1 id="capi"> +<title +>C <acronym +>API</acronym +></title> + +<sect2 id="capiintro"> +<title +>Inledning</title> + +<para +>C-gränssnittet för &arts; skapades för att göra det lätt att skriva och anpassa enkla C-program till &arts; ljudserver. Det tillhandahåller flödesfunktioner (att skicka samplingsströmmar till <application +>artsd</application +>), antingen med eller utan blockering. För de flesta program tar man helt enkelt bort de få systemanrop som hanterar ljudenheten och byter ut dem mot lämpliga anrop till &arts;.</para> + +<para +>Jag gjorde två anpassningar för att verifiera idén: <application +>mpg123</application +> och <application +>quake</application +>. Du kan skaffa programfixarna <ulink url="http://space.twc.de/~stefan/kde/download/artsc-patches.tar.gz" +>härifrån</ulink +>. Bidra gärna med dina egna programfixar till underhållaren av &arts; eller till programvarupaket för multimedia så att de kan integrera stöd för &arts; i sin kod.</para> + +</sect2> + +<sect2 id="capiwalkthru"> +<title +>Snabbtur</title> + +<para +>Att skicka ljud till ljudservern med gränssnittet är mycket enkelt:</para> +<procedure> +<step +><para +>infoga deklarationsfilen med <userinput +>#include <artsc.h></userinput +></para +></step> +<step +><para +>initiera gränssnittet med <function +>arts_init()</function +></para +></step> +<step +><para +>skapa en ström med <function +>arts_play_stream()</function +></para +></step> +<step +><para +>anpassa särskilda parametrar med <function +>arts_stream_set()</function +></para +></step> +<step +><para +>skriva samplingsdata till strömmen med <function +>arts_write()</function +></para +></step> +<step +><para +>stänga strömmen med <function +>arts_close_stream()</function +></para +></step> +<step +><para +>frigöra gränssnittet med <function +>arts_free()</function +></para +></step> +</procedure> + +<para +>Här är ett exempel på ett litet program som visar det här:</para> + +<programlisting +>#include <stdio.h> +#include <artsc.h> +int main() +{ + arts_stream_t stream; + char buffer[8192]; + int bytes; + int errorcode; + + errorcode = arts_init(); + if (errorcode < 0) + { + fprintf(stderr, "arts_init fel: %s\n", arts_error_text(errorcode)); + return 1; + } + + stream = arts_play_stream(44100, 16, 2, "artsctest"); + + while((bytes = fread(buffer, 1, 8192, stdin)) > 0) + { + errorcode = arts_write(stream, buffer, bytes); + if(errorcode < 0) + { + fprintf(stderr, "arts_write fel: %s\n", arts_error_text(errorcode)); + return 1; + } + } + + arts_close_stream(stream); + arts_free(); + + return 0; +} +</programlisting> +</sect2> + +<sect2 id="capiartscconfig"> +<title +>Att kompilera och länka: <application +>artsc-config</application +></title> + +<para +>För att lätt kunna kompilera och länka program med &arts; C-gränssnitt, finns verktyget <application +>artsc-config</application +> som känner till vilka bibliotek som man måste länka med och var deklarationsfilerna finns. Det anropas med</para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--libs</option +></userinput +> +</screen> + +<para +>för att ta reda på biblioteken och </para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--cflags</option +></userinput +> +</screen> + +<para +>för att ta reda på ytterligare C-kompilatorväljare. Exemplet ovan skulle ha kunnat kompileras med kommandoraden:</para> + +<screen +><userinput +><command +>cc</command +> <option +>-o artsctest artsctest.c `artsc-config --cflags` `artsc-config --libs`</option +></userinput> + +<userinput +><command +>cc</command +> <option +>-o artsctest</option +> <option +>artsctest.c</option +> <option +>`artsc-config --cflags`</option +> <option +>`artsc-config --libs`</option +></userinput +> +</screen> + +</sect2> + +<sect2 id="c-api-reference"> +<title +>Biblioteksreferens</title> + +<para +>[ATT GÖRA: skapa dokumentation för artsc.h med kdoc] </para> + +</sect2> + +</sect1> +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/arts-structure.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/arts-structure.png Binary files differnew file mode 100644 index 00000000000..1869b5598ff --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/arts-structure.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/artsbuilder.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/artsbuilder.docbook new file mode 100644 index 00000000000..dc286a81aeb --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/artsbuilder.docbook @@ -0,0 +1,917 @@ +<chapter id="artsbuilder"> +<title +>aRts-byggare</title> + +<sect1 id="overview"> +<title +>Översikt</title> + +<para +>Först av allt, när du försöker köra aRts-byggaren, ska du också köra ljudservern (&artsd;). Oftast, om du använder &kde; 2.1, ska detta redan vara fallet. Om inte, så kan du ställa in automatisk start av ljudservern i inställningscentralen, med <menuchoice +><guilabel +>Ljud</guilabel +><guilabel +>Ljudserver</guilabel +></menuchoice +>. </para> + +<para +>När du kör &arts;, körs alltid små moduler. aRts-byggaren är ett verktyg för att skapa nya strukturer av små ihopkopplade moduler. Du klickar helt enkelt i rutnätet för att lägga till en modul. För att göra detta, välj dem från menyn <guimenu +>Moduler</guimenu +>, och klicka någonstans på den gröngrå ytan. </para> + +<para +>Moduler har ofta portar (där ljudsignaler vanligtvis leds in eller ut). För att koppla ihop två portar, klicka på den första, som gör att den blir orange, och klicka sedan på den andra. Du kan bara förbinda en inport (på översidan av en modul) med en utport (på undersidan av en modul). Om du vill ange ett konstant värde för en port (eller koppla ifrån den), gör det genom att dubbelklicka på porten. </para> + +</sect1> + +<sect1 id="artsbuilder-tutorial"> +<title +>Handledning</title> + +<sect2 id="step-1"> +<title +>Steg 1</title> + +<para +>Starta aRts-byggaren. </para> + +<para +>Du behöver en Synth_AMAN_PLAY-modul för att höra utdata som du skapar. Så skapa en Synth_AMAN_PLAY-modul genom att välja <menuchoice +><guimenu +>Moduler</guimenu +> <guisubmenu +>Syntes</guisubmenu +> <guisubmenu +>Ljud-IO</guisubmenu +> <guisubmenu +>Synth_AMAN_PLAY</guisubmenu +></menuchoice +> och klicka på den tomma modulytan. Placera den nedanför den femte raden ungefär, eftersom vi kommer att lägga till en del grejor ovanför. </para> + +<para +>Modulen kommer att ha en parameter <parameter +>title</parameter +> (porten längst till vänster), och <parameter +>autoRestoreID</parameter +> (intill porten längst till vänster) för att den ska kunna hittas. För att fylla i de här, dubbelklicka på portarna, välj konstant värde och skriv <userinput +>handledning</userinput +> i textrutan. Klicka <guibutton +>OK</guibutton +> för att verkställa. </para> + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +>. Du hör absolut ingenting. Uppspelningsmodulen behöver också någon indata... ;) Om du har lyssnat på tystnaden ett tag, klicka <guibutton +>Avsluta</guibutton +> och gå till steg 2. </para> +</sect2> + +<sect2 id="step-2"> +<title +>Steg 2</title> + +<para +>Skapa en Synth_WAVE_SIN-modul (från <menuchoice +> <guimenu +>Moduler</guimenu +> <guimenuitem +>Syntes</guimenuitem +> <guimenuitem +>Vågformer</guimenuitem +></menuchoice +>) och placera den ovanför Synth_AMAN_PLAY-modulen (lämna en rads mellanrum mellan dem). </para> + +<para +>Som du ser, så producerar den någon utdata, men kräver <guilabel +>pos</guilabel +> som indata. Låt oss först ansluta utporten till högtalarna. Klicka på porten <guilabel +>out</guilabel +> på Synth_WAVE_SIN och sedan på porten <guilabel +>left</guilabel +> på Synth_AMAN_PLAY. Voila, du har kopplat ihop två moduler. </para> + +<para +>Oscillatorer i &arts; kräver inte en frekvens som indata, utan istället en position i vågformen. Positionen ska vara mellan 0 och 1, som i ett standardobjekt Synth_WAVE_SIN översätts till området 0 .. 2*Pi. För att skapa oscillerande värden från en frekvens, används en Synth_FREQUENCY modul. </para> + +<para +>Skapa en Synth_FREQUENCY-modul (från <menuchoice +> <guimenu +>Moduler</guimenu +> <guimenuitem +>Syntes</guimenuitem +> <guimenuitem +>Oscillation & modulation</guimenuitem +></menuchoice +>) och anslut dess <quote +>pos</quote +> utgång till <quote +>pos</quote +> ingången på Synth_WAVE_SIN. Sätt frekvensporten för frekvensgeneratorn till det konstanta värdet 440. </para> + + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +>. Du kommer att höra en sinusvåg på 440 Hz i en av dina högtalare. Om du har lyssnat på den ett tag, klicka <guibutton +>Avsluta</guibutton +> och gå till steg 3. </para> + +</sect2> + +<sect2 id="step-3"> +<title +>Steg 3</title> + +<para +>OK, det vore trevligare om du kunde höra sinusvågen i båda högtalarna. Anslut den högra porten på Synth_PLAY till utgången från Synth_WAVE_SIN också. </para> + +<para +>Skapa ett Synth_SEQUENCE-objekt (från <menuchoice +><guimenu +>Moduler</guimenu +> <guisubmenu +>Syntes</guisubmenu +><guisubmenu +>Midi & sekvensiering</guisubmenu +></menuchoice +>). Det ska placeras överst på skärmen. Om du behöver mer utrymme kan du flytta de andra modulerna genom att markera dem (för att markera flera moduler håll nere skifttangenten), och dra omkring dem. </para> + +<para +>Anslut nu frekvensutgången på Synth_SEQUENCE till frekvensingången på Synth_FREQUENCY-modulen. Ange sedan sekvensens hastighet som konstant värde 0.13 (hastigheten är porten längs till vänster). </para> + +<para +>Gå nu till porten längs till höger (seq) på Synth_SEQUENCE och skriv in <userinput +>A-3;C-4;E-4;C-4;</userinput +> som konstant värde. Det här anger en sekvens. Mer om detta i modulreferensen. </para> + +<note> +<para +>Synth_SEQUENCE <emphasis +>behöver</emphasis +> verkligen en sekvens och hastigheten. Utan dessa kanske du får minnesdumpar. </para> +</note> + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +>. Du kommer att höra en trevlig sekvens spelas upp. Om du har njutit av känslan, klicka <guibutton +>Avsluta</guibutton +> och gå till steg 4. </para> +</sect2> + +<sect2 id="step-4"> +<title +>Steg 4</title> + +<para +>Skapa en Synth_PSCALE-modul (från <menuchoice +><guimenu +>Moduler</guimenu +> <guisubmenu +>Syntes</guisubmenu +> <guisubmenu +>Envelopper</guisubmenu +> </menuchoice +>). Koppla bort utgången från sinusvågen genom att dubbelklicka på den och välja <guilabel +>inte ansluten</guilabel +>. Anslut </para> + +<orderedlist +><listitem> +<para +>Utgången SIN till ingången på PSCALE</para> +</listitem> +<listitem> +<para +>PSCALE utgången till AMAN_PLAY på vänster sida</para> +</listitem> +<listitem> +<para +>PSCALE utgången till AMAN_PLAY på höger sida</para> +</listitem> +<listitem> +<para +>SEQUENCE pos till PSCALE pos</para> +</listitem> +</orderedlist> + +<para +>Till slut, sätt PSCALE top till något värde, till exempel 0.1. </para> + +<para +>Hur fungerar detta nu: Synth_SEQUENCE ger ytterligare information om positionen för tonen den spelar just nu, där 0 betyder precis påbörjad och 1 betyder avslutad. Modulen Synth_PSCALE skalar ljudflödet som skickas genom den från volymen 0 (tyst) till 1 (ursprunglig ljudstyrka) tillbaka till 0 (tyst) enligt positionen. Positionen där toppen ska ske kan anges som top. 0.1 betyder att efter 10 % av tonen har spelats har volymen nått sitt maximala värde, och börjar sedan avta. </para> + + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +>. Du kommer att höra en trevlig sekvens spelas upp. Om du har njutit av känslan, klicka <guibutton +>Avsluta</guibutton +> och gå till steg 5. </para> + +</sect2> + +<sect2 id="step-5-starting-to-beam-data-around"> +<title +>Steg 5: Börja skicka omkring data ;)</title> + +<para +>Starta en aRts-byggare till.</para> + +<para +>Placera en Synth_AMAN_PLAY i den, och ställ in den till ett vettigt namn. Placera en Synth_BUS_DOWNLINK i den och:</para> + +<orderedlist> +<listitem> +<para +>Sätt Synth_BUS_DOWNLINK bus till ljud (det är bara ett namn, kalla den Fred om du vill) </para> +</listitem> +<listitem> +<para +>Anslut Synth_BUS_DOWNLINK left (vänster) till Synth_AMAN_PLAY left. </para> +</listitem> +<listitem> +<para +>Anslut Synth_BUS_DOWNLINK right (höger) till Synth_AMAN_PLAY right. </para> +</listitem> +</orderedlist> + +<para +>Börja köra strukturen. Som väntat hör du ingenting, ... inte än. </para> + +<para +>Gå tillbaka till strukturen med Synth_WAVE_SIN grejorna och byt ut Synth_AMAN_PLAY-modulen mot en Synth_BUS_UPLINK, och ställ in namnet till ljud (eller Fred om du vill). Att ta bort moduler görs genom att markera dem och välja <menuchoice +><guimenu +>Redigera</guimenu +> <guimenuitem +>Ta bort</guimenuitem +></menuchoice +> från menyn (eller trycka på tangenten <keycap +>Del</keycap +>). </para> + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +>. Du kommer att höra sekvensen med skalade toner, transporterad över bussen. </para> + +<para +>Om du vill ta reda på varför något sådant här kan vara användbart, klicka <guibutton +>Avsluta</guibutton +> (i aRts-byggaren som kör Synth_SEQUENCE grejorna, du kan låta den andra fortsätta köra) och gå till steg 6. </para> +</sect2> + +<sect2 id="step-6-beaming-for-advanced-users"> +<title +>Steg 6: Skicka data för avancerade användare</title> + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Byt namn på struktur</guimenuitem +></menuchoice +> från menyn i den aRts-byggare som innehåller Synth_SEQUENCE grejorna, och kalla den handledning. Tryck <guibutton +>OK</guibutton +>. </para> + +<para +>Välj <menuchoice +><guimenu +>Arkiv</guimenu +> <guimenuitem +>Spara som</guimenuitem +> </menuchoice +>. </para> + +<para +>Starta ytterligare en aRts-byggare och välj <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Öppna</guimenuitem +> </menuchoice +>, och ladda handledningen igen. </para> + +<para +>Nu kan du välja <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Kör struktur</guimenuitem +> </menuchoice +> i båda aRts-byggarna som har strukturen. Nu hör du samma sak två gånger. Beroende på när du startar dem kommer det att låta mer eller mindre bra. </para> + +<para +>En annan sak som kan vara bra att göra vid det här tillfället är att starta &noatun;, och spela en <literal role="extension" +>mp3</literal +>-fil. Starta sedan &artscontrol;. Gå till <menuchoice +><guimenu +>Visa</guimenu +><guimenuitem +>Visa ljudhanterare</guimenuitem +></menuchoice +>. Vad du ser är &noatun; och din struktur <quote +>handledning</quote +> spela upp någonting. Det trevliga som du kan göra är: dubbelklicka på &noatun;. Du får nu en lista på tillgängliga bussar. Och ser du? Du kan låta &noatun; skicka sin utmatning via ljudbussen till uppspelningsstrukturen som din handledning tillhandahåller. </para> +</sect2> + +<sect2 id="step-7-midi-synthesis"> +<title +>Steg 7: Midisyntes</title> + +<para +>Till slut, nu ska du kunna göra om din sinusvåg till ett riktigt instrument. Det här är bara meningsfullt om du har något lämpligt som kan skicka &MIDI;-händelser till &arts;. Här beskriver jag hur du kan använda ett externt keyboard, men en sequencer, som &brahms;, som känner till midibussen fungerar också. </para> + +<para +>Först av allt, rensa på ditt skrivbord till du bara har en aRts-byggare med sinusvågstrukturen igång (men låt den inte köra). Gå därefter tre gånger till <menuchoice +><guimenu +>Portar</guimenu +> <guisubmenu +>Skapa IN-ljudsignal</guisubmenu +></menuchoice +>, och tre gånger till <menuchoice +><guimenu +>Portar</guimenu +> <guisubmenu +>Skapa UT-ljudsignal</guisubmenu +></menuchoice +>. Placera portarna någonstans. </para> + +<para +>Gå till <menuchoice +><guimenu +>Portar</guimenu +> <guilabel +>Ändra positioner/namn</guilabel +></menuchoice +> och döp portarna till frequency, velocity, pressed, left, right, done. </para> + +<para +>Till sist kan du ta bort modulen Synth_SEQUENCE, och istället ansluta inporten frequency för strukturen till frekvensporten på Synth_FREQUENCY. Hmm. Men vad ska man göra med pos?</para +> <para +>Den här är inte tillgänglig, eftersom det inte finns någon algoritm i värden som kan förutse när användaren ska släppa tangenten han just tryckte ner på sitt midi-keyboard. Vi har istället parametern pressed, som bara anger om användaren fortfarande håller nere tangenten. (pressed = 1: tangenten fortfarande nertryckt, pressed = 0: tangenten släppt) </para> + +<para +>Det här betyder också att Synth_PSCALE-objektet måste bytas ut nu. Koppla in en Synth_ENVELOPE_ADSR istället (från <menuchoice +><guimenu +>Moduler</guimenu +> <guisubmenu +>Syntes</guisubmenu +> <guisubmenu +>Envelopper</guisubmenu +> </menuchoice +>). Anslut: </para> + +<orderedlist> +<listitem> +<para +>Strukturens pressed ingång till ADSR active</para> +</listitem> +<listitem> +<para +>SIN utgången till ADSR ingången</para> +</listitem> +<listitem> +<para +>ADSR utgången till den vänstra strukturutgången</para> +</listitem +><listitem> +<para +>ADSR utgången till den högra strukturutgången</para> +</listitem> +</orderedlist> + +<para +>Ställ in parametrarna attack till 0.1, decay till 0.2, sustain till 0.7, release till 0.1. </para> + +<para +>En sak till som vi måste tänka på är att instrumentstrukturen måste på något sätt veta när den har spelat färdigt och då kunna rensas bort, eftersom den annars aldrig skulle stanna även om tangenten har släppts. Som tur är, vet ADSR enveloppen när det inte finns mer att höra, eftersom den ändå skalar ner signalen till noll vid någon tidpunkt efter tangenten har släppts. </para> + +<para +>Det här anges genom att sätta utgången done till 1. Så anslut den här till strukturens utgång. Strukturen tas bort så fort done blir 1. </para> + +<para +>Döp om din struktur till instrument_handledning (från <menuchoice +><guimenu +> Arkiv</guimenu +> <guimenuitem +>Byt namn på struktur</guimenuitem +></menuchoice +>. Spara den sedan med Spara som (det förvalda namnet som nu anges ska vara instrument_handledning).</para +><para +>Starta aRts control, och gå till <menuchoice +><guimenu +>Visa</guimenu +><guimenuitem +>Visa midihanterare</guimenuitem +></menuchoice +>, och välj <menuchoice +><guimenu +>Lägg till</guimenu +><guimenuitem +>aRts synthes midi utmatning</guimenuitem +></menuchoice +>. Till sist ska du kunna välja ditt instrument (handledning) här. </para> + +<para +>Öppna en terminal och skriv <userinput +><command +>midisend</command +></userinput +>. Du kommer att se att <command +>midisend</command +> och instrumentet nu listas i &arts; &MIDI;hanterare. Efter att ha valt båda två och tryckt på <guibutton +>Anslut</guibutton +>, är vi till sist klara. Ta ditt keyboard och börja spela (det måste förstås vara anslutet till din dator). </para> +</sect2> + +<sect2 id="suggestions"> +<title +>Förslag</title> + +<para +>Du bör nu kunna arbeta med &arts;. Här är några tips om vad du nu skulle kunna göra för att förbättra dina strukturer: </para> + +<itemizedlist> +<listitem> +<para +>Försök att använda något annat än en sinusvåg. Om du kopplar in en triangelvåg, TRI, tycker du troligen inte att ljudet är särskilt trevligt, Men försök att lägga till ett SHELVE_CUTOFF-filter direkt efter triangelvågen för att klippa frekvenserna ovanför en viss frekvens (försök med något i stil med 1000 Hz, eller ännu bättre två gånger indatafrekvensen eller indatafrekvensen + 2000 Hz eller något sådant). </para> +</listitem> +<listitem> +<para +>Försök använda mer än en oscillator. Synth_XFADE kan användas för att övertona (blanda) två signaler, Synth_ADD för att addera dem. </para> +</listitem> +<listitem> +<para +>Försök att sätta frekvenserna för oscillatorerna till något olika värden, det ger trevliga oscillationer. </para> +</listitem> +<listitem> +<para +>Experimentera med mer än ett envelopp. </para> +</listitem> +<listitem> +<para +>Försök syntetisera instrument med olika ljud till vänster och höger. </para> +</listitem> +<listitem> +<para +>Försök efterbehandla signalen när den kommer ut från bussens nerlänk. Du skulle till exempel kunna blanda en fördröjd version av signalen med originalet för att få en ekoeffekt. </para> +</listitem> +<listitem> +<para +>Försök att använda anslagsstyrkan, velocity (det här är styrkan som tangenten har tryckts ner med, man kan också kalla det volymen). Specialeffekter uppstår alltid om det här inte bara ändrar volymen på signalen som skapas, utan också instrumentets ljud (till exempel klippningsfrekvensen). </para> +</listitem> +<listitem> +<para +>...</para> +</listitem> +</itemizedlist> + +<para +>Om du har skapat något storartat, fundera gärna på att tillhandahålla det till &arts; webbsida, eller för att ingå i nästa utgåva. </para> +</sect2> + +</sect1> + +<sect1 id="artsbuilder-examples"> +<title +>Exempel</title> + +<para +>aRts-byggaren levereras med flera exempel, som kan öppnas med <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Öppna exempel...</guimenuitem +> </menuchoice +>. Några av dem är i katalogen, medan några (som av någon anledning inte fungerar med den nuvarande utgåvan) har lämnats i todo-katalogen. </para> +<para +>Exemplen kan delas in i flera kategorier: </para> + +<itemizedlist> +<listitem> +<para +>Självständiga exempel som illustrerar hur var och en av de inbyggda aRts-modulerna används (som heter <filename +>example_*.arts</filename +>). De här skickar typiskt någon utmatning till ett ljudkort. </para> +</listitem> + +<listitem> +<para +>Instrument som byggs från aRts-moduler på lägre nivå (som heter <filename +>instrument_*.arts</filename +>). De här följer en standardkonvention för in- och utportar så att de kan användas av &MIDI;-hanteraren i &artscontrol;. </para> +</listitem> + +<listitem> +<para +>Mallar för att skapa nya moduler (som heter <filename +>template_*.arts</filename +>). </para> +</listitem> + +<listitem> +<para +>Effekter som kan användas som återanvändbara byggblock (som heter <filename +>effect_*.arts</filename +>) [ alla att göra ] </para> +</listitem> + +<listitem> +<para +>Mixerelement som används för att skapa mixrar, inklusive grafiska styrmoduler (som heter <filename +>mixer_element_*.arts</filename +>). [ alla att göra ] </para> +</listitem> + +<listitem> +<para +>Diverse moduler som inte passar in i någon av de ovanstående kategorierna. </para> +</listitem> +</itemizedlist> + +<variablelist> +<title +>Detaljerad beskrivning av varje modul:</title> +<varlistentry> +<term +><filename +>example_stereo_beep.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz sinusvåg i vänster kanal och en 880 Hz sinusvåg i höger kanal, och skickar dem till ljudkortet. Den här hänvisas till i &arts; dokumentation. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sine.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz sinusvåg. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pulse.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz pulsvåg med 20% aktivitet. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_softsaw.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz sågtandsvåg. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_square.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz fyrkantvåg. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tri.arts</filename +></term> +<listitem> +<para +>Skapar en 440 Hz triangelvåg. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_noise.arts</filename +></term> +<listitem> +<para +>Skapar vitt brus. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_dtmf1.arts</filename +></term> +<listitem> +<para +>Skapar en dubbelton genom att producera sinusvågor med 697 och 1209 Hz, skala dem till 0,5 och addera dem. Det här är DTMF-tonen för siffran "1" på en knapptelefon. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_atan_saturate.arts</filename +></term> +<listitem> +<para +>Kör en triangelvåg genom ett atan-mättningsfilter. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_autopanner.arts</filename +></term> +<listitem> +<para +>Använder autopanorering för att panorera en 400 Hz sinusvåg mellan vänster och höger högtalare med en hastighet av 2 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_brickwall.arts</filename +></term> +<listitem> +<para +>Skalar en sinusvåg med en faktor 5 och kör den sedan genom en tegelväggsbegränsare. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_bus.arts</filename +></term> +<listitem> +<para +>Länkar ner från en buss som heter <quote +>Bus</quote +> och länkar upp till bussen <quote +>out_soundcard</quote +> med vänster och höger kanal utbytta. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_cdelay.arts</filename +></term> +<listitem> +<para +>Länkar ner från en buss som heter <quote +>Delay</quote +> och länkar upp höger kanal genom en 0,5 sekunders fördröjning, och vänster kanal oförändrad. Du kan använda &artscontrol; för att ansluta effekten till ljuduppspelning och observera resultatet. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_delay.arts</filename +></term> +<listitem> +<para +>Det här är samma sak som <filename +>example_cdelay.arts</filename +> men använder fördröjningseffekten. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_capture_wav.arts</filename +></term> +<listitem> +<para +>Det här använder Synth_CAPTURE_WAV för att spara en 400 Hz sinusvåg som en wav-fil. Kör modulen i några sekunder, och titta sedan på filen som skapats i <filename class="directory" +>/tmp</filename +>. Du kan spela upp filen med en mediaspelare som <application +>kaiman</application +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_data.arts</filename +></term> +<listitem> +<para +>Det här använder Data-modulen för att skapa en konstant ström av värdet <quote +>3</quote +> och skickar det till en Debug-modul för att visa det periodiskt. Det innehåller också en Nil-modul, och visar hur den kan användas för att göra ingenting alls. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_adsr.arts</filename +></term> +<listitem> +<para +>Visar hur ett enkelt instrumentljud kan skapas med envelopp ADSR-modulen, som triggas repetitivt av en fyrkantvåg. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_fm.arts</filename +></term> +<listitem> +<para +>Det här använder FM Source-modulen för att skapa en 440 Hz sinusvåg som frekvensmoduleras med en 5 Hz hastighet. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_freeverb.arts</filename +></term> +<listitem> +<para +>Det här förbinder Freeverb-effekten från en bussnerlänk till en bussupplänk. Du kan använda artscontrol för att ansluta effekten till ljuduppspelning och observera resultatet. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_flanger.arts</filename +></term> +<listitem> +<para +>Det här implementerar en enkel flänseffekt (det verkar dock inte fungera än). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_moog.arts</filename +></term> +<listitem> +<para +>Den här strukturen kombinerar de två kanalerna från en buss till en, skickar den genom ett Moog VCF filer, och skickar det sedan till bussen out_soundcard. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pitch_shift.arts</filename +></term> +<listitem> +<para +>Den här strukturen skickar vänsterkanalens ljuddata genom en tonhöjdsändringseffekt. Justera hastighetsparametern för att variera effekten. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_rc.arts</filename +></term> +<listitem> +<para +>Den här strukturen skickar vitt brus genom ett RC-filer och ut till ljudkortet. Genom att titta på FFT mätaren i artscontrol kan du se hur det här skiljer sig från en ofiltrerad brusvågform. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sequence.arts</filename +></term> +<listitem> +<para +>Det här demonstrerar Sequence-modulen genom att spela en sekvens av toner. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_shelve_cutoff.arts</filename +></term> +<listitem> +<para +>Den här strukturen skickar vitt brus genom ett hyllklippningsfilter och ut till ljudkortet. Genom att titta på FFT mätaren i artscontrol kan du se hur det här skiljer sig från en ofiltrerad brusvågform. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_equalizer.arts</filename +></term> +<listitem> +<para +>Det här demonstrerar modulen Std_Equalizer. Det höjer de låga och höga frekvenserna med 6 dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tremolo.arts</filename +></term> +<listitem> +<para +>Det här demonstrerar tremoloeffekten. Det modulerar vänster och höger kanal med ett 10 Hz tremolo. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_xfade.arts</filename +></term> +<listitem> +<para +>Det här exemplet blandar 440 och 880 Hz sinusvågor med en övertoning. Justera värdet på övertoningens procentingång från -1 till 1 för att kontrollera blandningen av de två signalerna. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pscale.arts</filename +></term> +<listitem> +<para +>Det här illustrerar Pscale-modulen (jag är inte säker på att det är ett meningsfullt exempel). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_play_wav.arts</filename +></term> +<listitem> +<para +>Det här illustrerar modulen Play Wave. Du måste ange hela sökvägen till en <literal role="extension" +>.wav</literal +>-fil som filnamnsparameter. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>example_multi_add.arts</term> +<listitem> +<para +>Det här visar modulen Multi Add, som accepterar vilket antal ingångar som helst. Det summerar tre Data-moduler som producerar indata 1, 2 och 3, och visar resultatet 6. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/detail.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/detail.docbook new file mode 100644 index 00000000000..24e4cf4d186 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/detail.docbook @@ -0,0 +1,1383 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="arts-in-detail"> +<title +>&arts; i detalj</title> + +<sect1 id="architecture"> +<title +>Arkitektur</title> + +<mediaobject> +<imageobject> +<imagedata fileref="arts-structure.png" format="PNG"/> +</imageobject> +<textobject +><phrase +>&arts; strukturer.</phrase +></textobject> +</mediaobject> +</sect1> + +<sect1 id="modules-ports"> +<title +>Moduler & portar</title> + +<para +>Idén med &arts; är att syntes kan göras med små moduler, som bara gör en enda sak, och sedan kombinera dem i komplexa strukturer. De små modulerna har normalt ingångar, där de kan ta emot några signaler eller parametrar, och utgångar där de producerar några signaler. </para> + +<para +>En modul (Synth_ADD) tar till exempel bara de två signalerna på sina ingångar och adderar dem. Resultatet är tillgängligt som en utsignal. De ställen där moduler tillhandahåller sina in- eller utsignaler kallas portar. </para> + +</sect1> + +<sect1 id="structures"> +<title +>Strukturer</title> + +<para +>En struktur är en kombination av ihopkopplade moduler, där några kan ha parametrar som är direktkodade på deras inportar, andra kan vara ihopkopplade, och en del kan vara helt oanslutna. </para> + +<para +>Vad du kan göra med aRts-byggaren är att beskriva strukturer. Du beskriver vilka moduler du vill ska kopplas ihop med vilka andra moduler. När du är klar, kan du spara strukturbeskrivningen i en fil, eller be &arts; att skapa (köra) den strukturen som du beskrivit. </para> + +<para +>Därefter hör du förmodligen något ljud, om du har gjort allt på rätt sätt. </para> +</sect1> + +<!-- TODO + +<sect1 id="streams"> +<title +>Streams</title> + +</sect1> + +--> + +<sect1 id="latency"> +<title +>Latenstid</title> + +<sect2 id="what-islatency"> +<title +>Vad är latenstid?</title> + +<para +>Anta att du har ett program som heter <quote +>muspling</quote +> (som ska avge ett <quote +>pling</quote +> ljud om du klickar på en musknapp). Latenstiden är tiden mellan ditt finger trycker på musknappen och du hör plinget. Latenstiden för det här scenariot består av flera olika latenstider, som har olika orsaker. </para> + +</sect2> + +<sect2 id="latenbcy-simple"> +<title +>Latenstid i enkla program</title> + +<para +>För det här enkla programmet uppstår latenstiden på följande ställen: </para> + +<itemizedlist> + +<listitem> +<para +>Tiden till kärnan har meddelat X11-servern att musknappen har tryckts ner. </para> +</listitem> + +<listitem> +<para +>Tiden till X11-servern har meddelat ditt program att musknappen har tryckts ner. </para> +</listitem> + +<listitem> +<para +>Tiden till muspling-programmet har bestämt att den här knappen var värd att få ett pling spelat. </para> +</listitem> + +<listitem> +<para +>Tiden det tar för muspling-programmet att tala om för ljudservern att den ska spela ett pling. </para> +</listitem> + +<listitem> +<para +>Tiden det tar för plinget (som ljudservern börjar mixa med övrig utmatning omedelbart) att ta sig igenom buffrad data, till det verkligen når stället där ljudkortet spelar. </para> +</listitem> + +<listitem> +<para +>Tiden det tar för pling-ljudet att gå från högtalarna till dina öron. </para> +</listitem> +</itemizedlist> + +<para +>De första tre punkterna är latenstid utanför &arts;. De är intressanta, men utanför det här dokumentets omfattning. Hur som helst, var medveten om att de finns, så att även om du har optimerat allting annat till verkligt små värden, så kanske du inte nödvändigtvis får exakt det resultat du förväntar dig. </para> + +<para +>Att be servern att spela någonting innebär oftast bara ett enda &MCOP;-anrop. Det finns mätningar som bekräftar att det går att be servern att spela någonting 9000 gånger per sekund med den nuvarande implementeringen, på samma värddator med Unix domänuttag. Jag antar att det mesta av det här är kärnans omkostnad, för att byta från en process till en annan. Naturligtvis ändras det här värdet med de exakta typerna på parametrarna. Om man överför en hel bild med ett anrop, blir det långsammare än om man bara överför ett "long" värde. Detsamma är sant för returvärdet. För vanliga strängar (som filnamnet på <literal role="extension" +>wav</literal +>-filen som ska spelas) ska inte det här vara ett problem. </para> + +<para +>Det här betyder att vi kan approximera den här tiden med 1/9000 sekund, det vill säga under 0,15 ms. Vi kommer att se att detta inte är relevant. </para> + +<para +>Därefter kommer tiden efter servern börjar spela och ljudkortet tar emot någonting. Servern måste buffra data, så att inga pauser hörs när andra program, som din X11-server eller <quote +>muspling</quote +>-programmet, kör. Det sätt som detta hanteras på &Linux; är att det finns ett antal fragment av en viss storlek. Servern fyller på fragment, och ljudkortet spelar fragment. </para> + +<para +>Så antag att det finns tre fragment. Servern fyller det första och ljudkortet börjar spela det. Servern fyller det andra. Servern fyller det tredje. Servern är klar och andra program kan nu göra någonting. </para> + +<para +>När ljudkortet har spelat det första fragmentet, börjar det spela det andra och servern börjar fylla det första igen, och så vidare. </para> + +<para +>Den maximala latenstiden du får med allt detta är (antal fragment) * (storlek på varje fragment) / (samplingsfrekvens * (storlek på varje sampling)). Om vi antar 44 kHz stereo, och sju fragment på 1024 byte (de nuvarande förvalda inställningarna i aRts), så får vi 40 ms. </para> + +<para +>De här värdena kan anpassas enligt dina behov. <acronym +>CPU</acronym +>-användningen ökar dock med mindre latenstider, eftersom ljudservern måste fylla på buffrarna oftare, och med mindre delar. Det är också oftast omöjligt att nå bättre värden utan att ge ljudservern realtidsprioritet, eftersom man annars ofta får pauser. </para> + +<para +>Det är i alla fall realistiskt att göra någonting i stil med 3 fragment med 256 byte vardera, som skulle ändra det här värdet till 4,4 ms. Med 4,4 ms fördröjning skulle &arts; <acronym +>CPU</acronym +>-användning vara ungefär 7,5 %. Med en 40 ms fördröjning, skulle den vara ungefär 3 % (för en PII-350, och värdet kan bero på ditt ljudkort, version av kärnan och annat). </para> + +<para +>Så är det tiden som det tar för pling-ljudet att gå från högtalarna till dina öron. Antag att ditt avstånd från högtalarna är 2 meter. Ljud rör sig med hastigheten 330 meter per sekund. Så vi kan uppskatta den här tiden till 6 ms. </para> + +</sect2> + +<sect2 id="latency-streaming"> +<title +>Latenstid i program med ljudflöden</title> + +<para +>Program med ljudflöden är de som skapar sitt ljud själva. Tänk dig ett spel som skickar ett konstant flöde med samplingar, och nu ska anpassas att spela upp ljud via &arts;. Som ett exempel: när jag trycker på en tangent så hoppar figuren som jag använder, och ett bång-ljud spelas upp. </para> + +<para +>Först så måste du veta hur &arts; hanterar strömmar. Det är mycket likt I/O med ljudkortet. Spelet skickar några paket med samplingar till ljudservern, låt oss anta tre stycken. Så fort som ljudservern är klar med det första paketet, skickar det en bekräftelse tillbaka till spelet att det paketet är klart. </para> + +<para +>Spelet skapar ytterligare ett ljudpaket och skickar det till servern. Under tiden börjar servern konsumera det andra ljudpaketet, och så vidare. Latenstiden här liknar den i det enklare fallet: </para> + +<itemizedlist> +<listitem> +<para +>Tiden till kärnan har meddelat X11-servern att en knapp har tryckts ner. </para> +</listitem> + +<listitem> +<para +>Tiden till X11-servern har meddelat spelet att en knapp har tryckts ner. </para> +</listitem> + +<listitem> +<para +>Tiden till spelet har bestämt att den här knappen var värd att få ett bång spelat. </para> +</listitem> + +<listitem> +<para +>Tiden till ljudpaketet som spelet har börjat stoppa in bång-ljudet i når ljudservern. </para> +</listitem> + +<listitem> +<para +>Tiden det tar för bånget (som ljudservern börjar mixa med övrig utmatning omedelbart) att ta sig igenom buffrad data, till det verkligen når stället där ljudkortet spelar. </para> +</listitem> + +<listitem> +<para +>Tiden det tar för bång-ljudet från högtalarna att nå dina öron. </para> +</listitem> + +</itemizedlist> + +<para +>De externa latenstiderna, som ovan, är utanför det här dokumentets omfattning. </para> + +<para +>Det är uppenbart att latenstiden för strömmar beror på tiden det tar för alla paket som används att spelas en gång. Så den är (antal paket) * (storlek på varje paket) / (samplingsfrekvensen * (storlek på varje sampling)). </para> + +<para +>Som du ser är detta samma formel som gäller för fragmenten. För spel finns det dock ingen anledning att ha så korta fördröjningar som ovan. Jag skulle vilja säga att ett realistiskt exempel för ett spel skulle vara 2048 byte per paket, använd 3 paket. Latenstidsresultatet skulle då vara 35 ms. </para> + +<para +>Det här är baserat på följande: antag att ett spel renderar 25 bilder per sekund (för skärmen). Det är antagligen helt säkert att anta att en skillnad på en bild för ljudutmatningen inte skulle märkas. Därför är 1/25 sekunds fördröjning för ljudflöden acceptabelt, vilket i sin tur betyder att 40 ms skulle vara ok. </para> + +<para +>De flesta personer kör inte heller sina spel med realtidsprioritet, och faran med pauser i ljudet kan inte bortses ifrån. Strömmar med 3 paket på 256 byte är möjliga (jag provade det) - men orsakar mycket <acronym +>CPU</acronym +>-användning för strömhantering. </para> + +<para +>Latenstider på serversidan kan du beräkna precis som ovan. </para> + +</sect2> + +<sect2 id="cpu-usage"> +<title +>Några <acronym +>CPU</acronym +>-användningshänsyn</title> + +<para +>Det finns många faktorer som påverkar <acronym +>CPU</acronym +>-användning i ett komplext scenario, med några program med ljudflöden och några andra program, några insticksprogram i servern, etc. För att ange några få: </para> + +<itemizedlist> +<listitem> +<para +>Rå <acronym +>CPU</acronym +>-användning för de nödvändiga beräkningarna. </para> +</listitem> + +<listitem> +<para +>&arts; interna schemaläggningsomkostnad - hur &arts; bestämmer när vilken modul ska beräkna vad. </para> +</listitem> + +<listitem> +<para +>Omkostnad för konvertering av heltal till flyttal. </para> +</listitem> + +<listitem> +<para +>&MCOP; protokollomkostnad. </para> +</listitem> + +<listitem> +<para +>Kärnans process/sammanhangsbyte. </para> +</listitem> + +<listitem> +<para +>Kärnans kommunikationsomkostnad. </para> +</listitem> +</itemizedlist> + +<para +>För beräkning av rå <acronym +>CPU</acronym +>-användning, om du spelar upp två strömmar samtidigt måste du göra additioner. Om du applicerar ett filter, är vissa beräkningar inblandade. För att ta ett förenklat exempel, att addera två strömmar kräver kanske fyra <acronym +>CPU</acronym +>-cykler per addition, på en 350 MHz processor är detta 44100 * 2 * 4 / 350000000 = 0,1 % <acronym +>CPU</acronym +>-användning. </para> + +<para +>&arts; interna schemaläggning: &arts; behöver bestämma vilken insticksmodul som ska beräkna vad när. Detta tar tid. Använd ett profileringsverktyg om du är intresserad av det. Vad som kan sägas i allmänhet är att ju mindre realtid som används (dvs. ju större block som kan beräknas åt gången) desto mindre schemaläggningsomkostnad fås. Över beräkning av block med 128 samplingar åt gången (alltså med användning av fragmentstorlekar på 512 byte) är schemaläggningsomkostnad förmodligen inte värt att bry sig om. </para> + +<para +>Konvertering från heltal till flyttal: &arts; använder flyttal som internt dataformat. De är enkla att hantera, och på moderna processorer inte mycket långsammare än heltalsoperationer. Om det i alla fall finns klienter som spelar data som inte är flyttal (som ett spel som ska göra sin ljudutmatning via &arts;), behövs konvertering. Detsamma gäller om du vill spela upp ljud på ditt ljudkort. Ljudkortet behöver heltal, så du måste konvertera. </para> + +<para +>Här är värden för en Celeron, ungefärliga klockcykler per sampling, med -O2 och egcs 2.91.66 (mätta av Eugene Smith <email +>hamster@null.ru</email +>). Det här är förstås ytterst processorberoende: </para> + +<programlisting +>convert_mono_8_float: 14 +convert_stereo_i8_2float: 28 +convert_mono_16le_float: 40 +interpolate_mono_16le_float: 200 +convert_stereo_i16le_2float: 80 +convert_mono_float_16le: 80 +</programlisting> + +<para +>Så detta betyder 1 % <acronym +>CPU</acronym +>-användning för konvertering och 5 % för interpolation på den här 350 MHz processorn. </para> + +<para +>&MCOP; protokollomkostnad: &MCOP; klarar, som en tumregel, 9000 anrop per sekund. En stor del av detta är inte &MCOP;:s fel, utan hör ihop med de två orsakerna för kärnan som nämns nedan. Det här ger i alla fall en bas för att göra beräkningar av vad kostaden för strömhantering är. </para> + +<para +>Varje datapaket som skickas med en ström kan anses vara ett &MCOP;-anrop. Stora paket är förstås långsammare än 9000 paket/s, men det ger en god idé. </para> + +<para +>Antag att du använder paketstorlekar på 1024 byte. På så sätt, för att överföra en ström med 44 kHz stereo, behöver du överföra 44100 * 4 / 1024 = 172 paket per sekund. Antag att du kunde överföra 9000 paket med 100 % CPU-användning, då får du (172 *100) / 9000 = 2 % <acronym +>CPU</acronym +>-användning på grund av strömmen med 1024 byte paket. </para> + +<para +>Detta är en approximation. Det visar i alla fall att du skulle klara dig mycket bättre (om du har råd med latenstiden), med att till exempel använda paket på 4096 byte. Här kan vi skapa en kompakt formel, genom att beräkna paketstorleken som orsakar 100 % <acronym +>CPU</acronym +>-användning som 44100 * 4 / 9000 = 19,6 samplingar, och på så sätt få snabbformeln: </para> + +<para +><acronym +>CPU</acronym +>-användning för en ström i procent = 1960 / (din paketstorlek) </para> + +<para +>som ger oss 0,5 % <acronym +>CPU</acronym +>-användning med en ström av 4096 byte paket. </para> + +<para +>Kärnans process/sammanhangsbyte: Det här är en del av &MCOP;-protokollets omkostnad. Att byta mellan två processer tar tid. Det blir en ny minnesmappning, cachar blir ogiltiga, och en del annat (om en expert på kärnan läser det här - tala om de exakta orsakerna för mig). Det här betyder: det tar tid. </para> + +<para +>Jag är inte säker på hur många processbyten &Linux; kan göra per sekund, men värdet är inte oändligt. Så av &MCOP;-protokollets omkostnad, antar jag att en hel del beror på processbyten. När &MCOP; först påbörjades provade jag samma kommunikation inne i en process, och det var mycket snabbare (ungefär fyra gånger snabbare). </para> + +<para +>Kärnans kommunikationsomkostnad: Det här är en del av &MCOP;-protokollets omkostnad. Att överföra data mellan processer görs för närvarande via ett uttag (socket). Det här är bekvämt, eftersom den vanliga select() metoden kan användas för att avgöra när ett meddelande har anlänt. Det kan också kombineras med andra I/O-källor som ljud-I/O, X11-server eller vad som helst annat. </para> + +<para +>De här läs- och skrivanropen kostar definitivt processorcykler. För små anrop (som att överföra en midi-händelse) är det förmodligen inte så farligt, men för stora anrop (som att överföra en videobild med flera Mibyte) är det helt klart ett problem. </para> + +<para +>Att lägga till användning av delat minne till &MCOP; där det är lämpligt är förmodligen den bästa lösningen. Det måste dock göras transparent för tillämpningsprogrammeraren. </para> + +<para +>Ta ett profileringsverktyg och gör andra prov för att exakt ta reda på hur nuvarande ljudströmmar påverkas av att inte använda delat minne. Det är dock inte så dåligt, eftersom ljudströmmar (spela upp mp3) kan göras med totalt 6 % <acronym +>CPU</acronym +>-användning för &artsd; och <application +>artscat</application +> (och 5 % för mp3-avkodaren). Det här innefattar dock allting från nödvändiga beräkningar till omkostnad för uttaget, så jag skulle uppskatta att man skulle vinna ungefär 1 % på att använda delat minne. </para> + +</sect2> + +<sect2 id="hard-numbers"> +<title +>Några riktiga värden</title> + +<para +>De här är gjorda med den nuvarande utvecklingsversionen. Jag ville också försöka med riktigt svåra fall, så det här är inte vad program för daglig användning skulle göra. </para> + +<para +>Jag skrev ett program som heter streamsound som skickar dataflöden till &arts;. Här körs det med realtidsprioritet (utan problem), och en liten insticksmodul på serversidan (volymskalning och klippning): </para> + +<programlisting +>4974 stefan 20 0 2360 2360 1784 S 0 17.7 1.8 0:21 artsd + 5016 stefan 20 0 2208 2208 1684 S 0 7.2 1.7 0:02 streamsound + 5002 stefan 20 0 2208 2208 1684 S 0 6.8 1.7 0:07 streamsound + 4997 stefan 20 0 2208 2208 1684 S 0 6.6 1.7 0:07 streamsound +</programlisting> + +<para +>Var och en av programmen skickar en ström med 3 fragment på 1024 byte (18 ms). Det finns tre sådana klienter som kör samtidigt. Jag vet att det verkar vara lite väl mycket, men som jag sa: ta ett profileringsverktyg och ta reda på vad som kostar tid, och om du vill, förbättra det. </para> + +<para +>Jag tror i alla fall inte att använda strömmar så här är realistiskt eller vettigt. För att göra det hela ännu mer extremt, försökte jag med den minsta möjliga latenstiden. Resultat: man kan använda strömmar utan avbrott med ett klientprogram, om man tar 2 fragment med 128 byte mellan aRts och ljudkortet, och mellan klientprogrammet och aRts. Det här betyder att man har en total maximal latenstid på 128 * 4 / 44100 * 4 = 3 ms, där 1,5 ms skapas på grund av I/O till ljudkortet och 1,5 ms skapas av kommunikation med &arts;. Båda programmen måste köra med realtidsprioritet. </para> + +<para +>Men det här kostar en enorm mängd <acronym +>CPU</acronym +>. Det här exemplet kostar ungefär 45 % på min P-II/350. Det börjar också gå fel om man startar top, flyttar fönster på X11-skärmen eller gör disk-I/O. Allt det här har med kärnan att göra. Problemet är att schemalägga två eller flera processer med realtidsprioritet också kostar en enorm ansträngning, ännu mer än kommunikation och meddelande till varandra, etc. </para> + +<para +>Till sist, ett mer vardagligt exempel: Det här är &arts; med artsd och en artscat (en klient med dataflöde) som kör 16 fragment på 4096 byte: </para> + +<programlisting +>5548 stefan 12 0 2364 2364 1752 R 0 4.9 1.8 0:03 artsd + 5554 stefan 3 0 752 752 572 R 0 0.7 0.5 0:00 top + 5550 stefan 2 0 2280 2280 1696 S 0 0.5 1.7 0:00 artscat +</programlisting> + +</sect2> +</sect1> + +<!-- TODO + +<sect1 id="dynamic-instantiation"> +<title +>Dynamic Instantiation</title> + +</sect1> + +--> + +<sect1 id="busses"> +<title +>Bussar</title> + +<para +>Bussar är förbindelser som byggs dynamiskt för att överföra ljud. Det finns ett antal upplänkar och nerlänkar. Alla signaler från upplänkarna adderas och skickas till nerlänkarna. </para> + +<para +>Bussar är för närvarande implementerade för att fungera med stereo, så du kan bara överföra stereodata via bussar. Om du vill ha monodata, nå, överför det bara på en kanal och sätt den andra till noll eller något godtyckligt. Vad du måste göra är att skapa en eller flera Synth_BUS_UPLINK-objekt och ge dem ett bussnamn, som de ska prata med (t.ex. <quote +>ljud</quote +> eller <quote +>trummor</quote +>). Skicka sedan helt enkelt in data dit. </para> + +<para +>Därefter måste du skapa en eller flera Synth_BUS_DOWNLINK-objekt, och tala om bussnamnet för dem (<quote +>ljud</quote +> eller <quote +>trummor</quote +>... om det passar ihop, kommer data igenom), och det blandade ljudet kommer ut igen. </para> + +<para +>Upplänkarna och nerlänkarna kan finnas i olika strukturer, du kan till och med ha olika aRts-byggare som kör och starta en upplänk i en och ta emot data i den andra med en nerlänk. </para> + +<para +>Vad som är trevligt med bussar är att de är fullständigt dynamiska. Klienter kan kopplas in eller ur i farten. Det ska inte höras några klick eller brus när detta sker. </para> + +<para +>Du ska förstås inte koppla in eller ur en klient medan den spelar en signal, eftersom den förmodligen inte är noll när den kopplas ur, och då uppstår ett klick. </para> +</sect1> + +<!-- TODO +<sect1 id="network-ransparency"> +<title +>Network Transparency</title> + +</sect1> + +<sect1 id="security"> +<title +>Security</title> + +</sect1> + + +<sect1 id="effects"> +<title +>Effects and Effect Stacks</title> + +</sect1> + +--> +<sect1 id="trader"> +<title +>Handlaren</title> + +<para +>&arts;/&MCOP; förlitar sig helt på att dela upp objekt i små komponenter. Det här gör allt mycket flexibelt, eftersom man lätt kan utöka systemet genom att lägga till nya komponenter, som implementerar nya effekter, filformat, oscillatorer, grafiska element, ... Eftersom nästan allt är komponenter, kan nästan allt lätt utökas utan att ändra befintlig källkod. Nya komponenter kan enkelt laddas dynamiskt för att förbättra program som redan finns. </para> + +<para +>För att detta ska fungera, behövs dock två saker: </para> + +<itemizedlist> + +<listitem> +<para +>Komponenter måste tala om att de finns - de måste beskriva vilka storartade saker de erbjuder, så att program kan använda dem. </para> +</listitem> + +<listitem> +<para +>Program måste aktivt leta efter komponenter som de skulle kunna använda, istället för att alltid använda samma komponent för en viss uppgift. </para> +</listitem> + +</itemizedlist> + +<para +>Kombinationen av det här: komponenter som säger <quote +>här är jag, jag är tuff, använd mig</quote +>, och program (eller om man vill, andra komponenter) som går ut och letar efter vilken komponent som de kan använda för att få någonting gjort, kallas att handla. </para> + +<para +>I &arts; beskriver komponenter sig genom att ange värden som de <quote +>stöder</quote +> som egenskaper. En typisk egenskap för en filladdningskomponent kan vara filändelsen för filerna som den kan behandla. Typiska värden kan vara <literal role="extension" +>wav</literal +>, <literal role="extension" +>aiff</literal +> eller <literal role="extension" +>mp3</literal +>. </para> + +<para +>I själva verket kan varje komponent välja att erbjuda många olika värden för en egenskap. Så en enda komponent skulle kunna erbjuda att läsa både <literal role="extension" +>wav</literal +> och <literal role="extension" +>aiff</literal +> filer, genom att ange att den stöder de här värdena för egenskapen <quote +>Extension</quote +>. </para> + +<para +>För att göra det här, måste en komponent lägga en <literal role="extension" +>.mcopclass</literal +>-fil som innehåller egenskaperna den stöder på ett lämpligt ställe. För vårt exempel, kan den se ut så här (och skulle installeras i <filename +><replaceable +>komponentkatalog</replaceable +>/Arts/WavPlayObject.mcopclass</filename +>): </para> + +<programlisting +>Interface=Arts::WavPlayObject,Arts::PlayObject,Arts::SynthModule,Arts::Object +Author="Stefan Westerfeld <stefan@space.twc.de>" +URL="http://www.arts-project.org" +Extension=wav,aiff +MimeType=audio/x-wav,audio/x-aiff +</programlisting> + +<para +>Det är viktigt att filnamnet på <literal role="extension" +>.mcopclass</literal +>-filen också anger vad komponentens gränssnitt heter. Handlaren tittar inte på innehållet alls, om filen (som här) heter <filename +>Arts/WavPlayObject.mcopclass</filename +>, och komponentgränssnittet heter <interfacename +>Arts::WavPlayObject</interfacename +> (moduler hör ihop med kataloger). </para> + +<para +>För att leta efter komponenter finns det två gränssnitt (som är definierade i <filename +>core.idl</filename +>, så de är tillgängliga i varje program), som heter <interfacename +>Arts::TraderQuery</interfacename +> och <interfacename +>Arts::TraderOffer</interfacename +>. Du går på en <quote +>shoppingrunda</quote +> efter komponenter så här: </para> + +<orderedlist> +<listitem> +<para +>Skapa ett frågeobjekt: </para> +<programlisting +>Arts::TraderQuery query; +</programlisting> +</listitem> + +<listitem> +<para +>Ange vad du vill ha. Som du såg ovan, beskriver komponenter sig själva med egenskaper, som de sätter till vissa värden. Så att specificera vad du vill ha görs genom att välja komponenter som stöder ett visst värde för en egenskap. Det här sker med metoden supports i TraderQuery: </para> + +<programlisting +>query.supports("Interface","Arts::PlayObject"); + query.supports("Extension","wav"); +</programlisting> +</listitem> + +<listitem> +<para +>Till sist utförs förfrågan med metoden query. Sedan får du (förhoppningsvis) några erbjudanden: </para> + +<programlisting +>vector<Arts::TraderOffer> *offers = query.query(); +</programlisting> +</listitem> + +<listitem> +<para +>Nu kan du undersöka vad du hittade. Det viktiga är metoden interfaceName i TraderOffer, som ger dig namnen på komponenterna som svarade på frågan. Du kan också ta reda på ytterligare egenskaper med getProperty. Följande kod löper helt enkelt igenom alla komponenterna, skriver ut deras gränssnittsnamn (som skulle kunna användas för att skapa dem), och tar bort resultatet av frågan: </para> +<programlisting +>vector<Arts::TraderOffer>::iterator i; + for(i = offers->begin(); i != offers->end(); i++) + cout << i->interfaceName() << endl; + delete offers; +</programlisting> +</listitem> +</orderedlist> + +<para +>För att den här sortens handelsservice ska vara användbar, är det viktigt att på något sätt komma överens om vilka egenskaper som komponenter normalt ska definiera. Det är väsentligt att mer eller mindre alla komponenter inom ett visst område använder samma uppsättning egenskaper för att beskriva sig själva (och samma uppsättning värden när det behövs), så att program (eller andra komponenter) kan hitta dem. </para> + +<para +>Author (typ stäng, valfri): Upphovsman. Det här kan användas för att till sist låta världen få reda på att du skrivit någonting. Du kan skriva vad du vill här, en e-postadress är förstås en bra hjälp. </para> + +<para +>Buildable (typ boolean, rekommenderas): Byggbar. Det här anger om komponenten är användbar med <acronym +>RAD</acronym +>-verktyg (som aRts-byggaren) som använder komponenter genom att tilldela egenskaper och ansluta portar. Det rekommenderas att det här värdet sätts till true för nästan alla signalbehandlingskomponenter (som filer, ljudeffekter, oscillatorer, ...), och för alla andra objekt som kan användas på ett <acronym +>RAD</acronym +>-liknande sätt, men inte för interna objekt som till exempel <interfacename +>Arts::InterfaceRepo</interfacename +>. </para> + +<para +>Extension (typ sträng, använd där det passar): Filändelse. Alla moduler som hanterar filer bör fundera på att använda det här. Du anger filändelsen med små bokstäver utan <quote +>.</quote +> här, så något som <userinput +>wav</userinput +> ska fungera utmärkt. </para> + +<para +>Interface (typ sträng, krävs): Gränssnitt. Det här ska omfatta hela listan på (användbara) gränssnitt som din komponent stöder, troligen inklusive <interfacename +>Arts::Object</interfacename +> och om tillämpligt <interfacename +>Arts::SynthModule</interfacename +>. </para> + +<para +>Language (typ sträng, rekommenderas): Språk. Om du vill att din komponent ska laddas dynamiskt, måste du ange språket här. För närvarande är det enda tillåtna värdet <userinput +>C++</userinput +>, som betyder att komponenten är skriven med det normala C++ programmeringsgränssnittet. Om du anger detta, måste du också ange egenskapen <quote +>Library</quote +> nedan. </para> + +<para +>Library (typ sträng, använd där det passar): Bibliotek. Komponenter som är skrivna i C++ kan laddas dynamiskt. För att göra det måste du kompilera dem i en dynamiskt laddningsbar libtool (<literal role="extension" +>.la</literal +>) modul. Här kan du ange namnet på <literal role="extension" +>.la</literal +>-filen som innehåller din komponent. Kom ihåg att använda REGISTER_IMPLEMENTATION (som alltid). </para> + +<para +>MimeType (typ sträng, använd där det passar): Mimetyp. Alla som hanterar filer bör tänka sig att använda det här. Du ska ange standard-mimetypen med små bokstäver här, till exempel <userinput +>audio/x-wav</userinput +>. </para> + +<para +>&URL; (typ sträng, valfri): Om du vill tala om var man kan hitta en ny version av komponenten (eller en hemsida eller något annat), kan du göra det här. Det här ska vara en standard &HTTP;- eller &FTP;-webbadress. </para> + +</sect1> + +<!-- TODO +<sect1 id="midi-synthesis"> +<title +><acronym +>MIDI</acronym +> Synthesis</title> + +</sect1> + +<sect1 id="instruments"> +<title +>Instruments</title> + +</sect1> + +<sect1 id="session-management"> +<title +>Session Management</title> + +</sect1> + +<sect1 id="full-duplex"> +<title +>Full duplex Audio</title> + +</sect1> +--> + +<sect1 id="namespaces"> +<title +>Namnrymder i &arts;</title> + +<sect2 id="namespaces-intro"> +<title +>Inledning</title> + +<para +>Varje namnrymdsdeklaration hör ihop med en deklaration av en <quote +>modul</quote +> i &MCOP; &IDL;. </para> + +<programlisting +>// mcop idl + +module M { + interface A + { + } +}; + +interface B; +</programlisting> + +<para +>I det här fallet skulle den genererade C++ koden för &IDL;-fragmentet se ut så här: </para> + +<programlisting +>// C++ deklaration + +namespace M { + /* deklaration av A_base/A_skel/A_stub och liknande */ + class A { // Smartwrap referensklass + /* [...] */ + }; +} + +/* deklaration av B_base/B_skel/B_stub och liknande */ +class B { + /* [...] */ +}; +</programlisting> + +<para +>Så när du hänvisar till klasserna från exemplet ovan i din C++ kod, måste du skriva <classname +>M::A</classname +>, men bara B. Du kan förstås använda <quote +>using M</quote +> någonstans, som med alla namnrymnder i C++. </para> + +</sect2> + +<sect2 id="namespaces-how"> +<title +>Hur &arts; använder namnrymder</title> + +<para +>Det finns en global namnrymd som kallas <quote +>Arts</quote +>, som alla program och bibliotek som hör till &arts; själv använder för att lägga sina deklarationer i. Det här betyder att när du skriver C++ kod som beror på &arts;, måste du normalt använda prefixet <classname +>Arts::</classname +> för varje klass som du använder, så här: </para> + +<programlisting +>int main(int argc, char **argv) +{ + Arts::Dispatcher dispatcher; + Arts::SimpleSoundServer server(Arts::Reference("global:Arts_SimpleSoundServer")); + + server.play("/var/foo/någon_fil.wav"); +</programlisting> + +<para +>Det andra alternativet är att skriva "using" en gång, så här: </para> + +<programlisting +>using namespace Arts; + +int main(int argc, char **argv) +{ + Dispatcher dispatcher; + SimpleSoundServer server(Reference("global:Arts_SimpleSoundServer")); + + server.play("/var/foo/någon_fil.wav"); + [...] +</programlisting> + +<para +>I &IDL;-filer, har du egentligen inget val. Om du skriver kod som tillhör &arts; själv, måste du lägga den i modulen &arts;. </para> + +<programlisting +>// IDL-fil för aRts-kod: +#include <artsflow.idl> +module Arts { // lägg den i Arts-namnrymd + interface Synth_TWEAK : SynthModule + { + in audio stream invalue; + out audio stream outvalue; + attribute float tweakFactor; + }; +}; +</programlisting> + +<para +>Om du skriver kod som inte hör till &arts; själv, ska du inte lägga den i namnrymden <quote +>Arts</quote +>. Du kan dock skapa en egen namnrymd om du vill. Hur som helst, måste du använda prefix för klasser från &arts; som du använder. </para> + +<programlisting +>// IDL-fil för kod som inte hör till aRts: +#include <artsflow.idl> + +// skriv antingen med eller utan moduldeklaration, och de genererade klasserna +// kommer inte att använda en namnrymd: +interface Synth_TWEAK2 : Arts::SynthModule +{ + in audio stream invalue; + out audio stream outvalue; + attribute float tweakFactor; +}; + +// du kan dock välja en egen namnrymd om du vill, så om du +// skriver programmet "PowerRadio", skulle du kunna göra så här: +module PowerRadio { + struct Station { + string name; + float frequency; + }; + + interface Tuner : Arts::SynthModule { + attribute Station station; // inget prefix för Station, samma modul + out audio stream left, right; + }; +}; +</programlisting> + +</sect2> + +<sect2 id="namespaces-implementation"> +<title +>Interna funktioner: hur implementeringen fungerar</title> + +<para +>&MCOP; behöver ofta hänvisa till namn på typer och gränssnitt för typkonverteringar, gränssnitt och metodsignaturer. Dessa representeras av strängar i de vanliga &MCOP;-datastrukturerna, medan namnrymden alltid är fullständigt representerad i C++ stilen. Det här betyder att strängarna skulle innehålla <quote +>M::A</quote +> och <quote +>B</quote +>, enligt exemplen ovan. </para> + +<para +>Observera att detta gäller till och med om namnrymdskvalificeringen inte angavs inne i &IDL;-texten, eftersom sammanhanget klargör vilken namnrymd gränssnittet <interfacename +>A</interfacename +> var tänkt att användas. </para> + +</sect2> +</sect1> + +<sect1 id="threads"> +<title +>Trådar i &arts;</title> + +<sect2 id="threads-basics"> +<title +>Grundläggande information</title> + +<para +>Att använda trådar är inte möjligt på alla plattformar. Det här är orsaken att &arts; ursprungligen skrevs utan att använda trådar alls. För nästan alla problem, finns det en lösning utan trådar som gör samma sak som varje lösning med trådar. </para> + +<para +>Till exempel, istället för att placera ljudutmatning i en separat tråd, och göra den blockerande, använder &arts; ljudutmatning som inte blockerar, och räknar ut när nästa del av utdata ska skrivas med <function +>select()</function +>. </para> + +<para +>&arts; stöder åtminstone (i de senaste versionerna) de som vill implementera sina objekt med trådar. Till exempel om du redan har kod för en <literal role="extension" +>mp3</literal +>-spelare, och koden förväntar sig att <literal role="extension" +>mp3</literal +>-avkodaren ska köras i en separat tråd, är det oftast lättast att behålla den konstruktionen. </para> + +<para +>Implementeringen av &arts;/&MCOP; är uppbyggd genom att dela tillståndet mellan olika objekt på tydliga och mindre tydliga sätt. En kort lista på delade tillstånd innefattar: </para> + +<itemizedlist> +<listitem +><para +>Avsändarobjektet som gör &MCOP;-kommunikation </para> +</listitem> + +<listitem> +<para +>Referensräkningen (Smartwrappers). </para> +</listitem> + +<listitem> +<para +>I/O-hanteraren som hanterar tidsgränser och fd-tidmätning. </para> +</listitem> + +<listitem> +<para +>Objekthanteraren som skapar objekt och laddar insticksmoduler dynamiskt. </para> +</listitem> + +<listitem> +<para +>Flödessystemet som anropar calculateBlock vid lämpliga tillfällen. </para> +</listitem> +</itemizedlist> + +<para +>Inget av de ovanstående objekten förväntar sig att användas med samtidighet (dvs. anropas från olika trådar samtidigt). I allmänhet finns det två sätt att lösa detta: </para> + +<itemizedlist> +<listitem> +<para +>Kräva att den som anropar vilken funktion som helst i objektet skaffar ett lås innan den används. </para> +</listitem> + +<listitem> +<para +>Göra objekten verkligt trådsäkra och/eller skapa instanser av dem för varje tråd. </para> +</listitem> +</itemizedlist> + +<para +>&arts; använder det första sättet. Du behöver ett lås varje gång du ska komma åt några av de här objekten. Det andra sättet är svårare att göra. En snabbfix som försöker åstadkomma detta finns på <ulink url="http://space.twc.de/~stefan/kde/download/arts-mt.tar.gz" +> http://space.twc.de/~stefan/kde/download/arts-mt.tar.gz</ulink +>, men för närvarande fungerar förmodligen ett minimalt sätt bättre, och orsakar mindre problem med befintliga program. </para> + +</sect2> +<sect2 id="threads-locking"> +<title +>När/hur ska låsning ske?</title> + +<para +>Du kan skaffa/släppa låset med de två funktionerna: </para> + +<itemizedlist> +<listitem> +<para> +<ulink +url="http://space.twc.de/~stefan/kde/arts-mcop-doc/arts-reference/headers/Arts__Dispatcher.html#lock" +><function +>Arts::Dispatcher::lock()</function +></ulink> +</para> +</listitem> +<listitem> +<para> +<ulink +url="http://space.twc.de/~stefan/kde/arts-mcop-doc/arts-reference/headers/Arts__Dispatcher.html#unlock" +><function +>Arts::Dispatcher::unlock()</function +></ulink> +</para> +</listitem> +</itemizedlist> + +<para +>I allmänhet behöver du inte skaffa ett lås (och du ska inte försöka att göra det), om det redan hålls. En lista på villkor när detta är fallet är: </para> + +<itemizedlist> +<listitem> +<para +>Du tar emot ett återanrop från I/O-hanteraren (tidsgräns eller fd). </para> +</listitem> + +<listitem> +<para +>Du anropas på grund av någon &MCOP;-begäran. </para> +</listitem> + +<listitem> +<para +>Du anropas från NotificationManager. </para> +</listitem> + +<listitem> +<para +>Du anropas från flödessystemet (calculateBlock) </para> +</listitem> +</itemizedlist> + +<para +>Det finns också några undantag för funktioner som du bara kan anropa i huvudtråden, och av den anledningen aldrig behöver ett lås för att anropa dem: </para> + +<itemizedlist> +<listitem> +<para +>Skapa och ta bort avsändaren eller I/O-hanteraren. </para> +</listitem> + +<listitem> +<para +><methodname +>Dispatcher::run()</methodname +> / <methodname +>IOManager::run()</methodname +> </para> +</listitem> + +<listitem> +<para +><methodname +>IOManager::processOneEvent()</methodname +></para> +</listitem> +</itemizedlist> + +<para +>Men det är allt. För allt annat som på något sätt hör ihop med &arts;, måste du skaffa låset, och släppa det igen när du är klar. Här är ett enkelt exempel: </para> + +<programlisting +>class SuspendTimeThread : Arts::Thread { +public: + void run() { + /* + * du behöver det här låset därför att: + * - skapa en referens behöver ett lås (eftersom global: går till + * objekthanteraren, som i sin tur kan behöva GlobalComm + * objektet för att slå upp vart anslutningen ska göras) + * - tilldela en smartwrapper behöver ett lås + * - skapa ett objekt från en referens behöver ett lås (eftersom + * det kan behöva ansluta till en server) + */ + Arts::Dispatcher::lock(); + Arts::SoundServer server = Arts::Reference("global:Arts_SoundServer"); + Arts::Dispatcher::unlock(); + + for(;;) { /* + * du behöver ett lås här, eftersom + * - följa en referens för en smartwrapper behöver ett lås + * (eftersom det kan skapa objektet när det används) + * - att göra ett MCOP-anrop behöver ett lås + */ + Arts::Dispatcher::lock(); + long seconds = server.secondsUntilSuspend(); + Arts::Dispatcher::unlock(); + + printf("sekunder till vänteläge = %d",seconds); + sleep(1); + } + } +} +</programlisting> + + +</sect2> + +<sect2 id="threads-classes"> +<title +>Trådrelaterade klasser</title> + +<para +>Följande trådrelaterade klasser finns tillgängliga för närvarande: </para> + +<itemizedlist> +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Thread.html" +><classname +> Arts::Thread</classname +></ulink +> - som kapslar in en tråd. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Mutex.html" +> <classname +>Arts::Mutex</classname +></ulink +> - som kapslar in en mutex. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__ThreadCondition.html" +> <classname +>Arts::ThreadCondition</classname +></ulink +> - som ger stöd för att väcka upp trådar som väntar på att ett visst villkor ska bli sant. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__SystemThreads.html" +><classname +>Arts::SystemThreads</classname +></ulink +> - som kapslar in operativsystemets trådningslager (och ger några hjälpfunktioner för tillämpningsprogrammerare). </para> +</listitem> +</itemizedlist> + +<para +>Se länkarna för dokumentation. </para> + +</sect2> +</sect1> + +<sect1 id="references-errors"> +<title +>Referenser och felhantering</title> + +<para +>&MCOP;-referenser är ett av de mest centrala koncepten i &MCOP; programmering. Det här avsnittet försöker beskriva exakt hur referenser används, och behandlar särskilt felfall (serverkrascher). </para> + +<sect2 id="references-properties"> +<title +>Grundläggande egenskaper för referenser</title> + +<itemizedlist> +<listitem> +<para +>En &MCOP; referens är inte ett objekt, utan en referens till ett objekt: Även om följande deklaration <programlisting> + Arts::Synth_PLAY p; +</programlisting +> ser ut som en definition av ett objekt, så deklarerar det bara en referens till ett objekt. Som C++ programmerare, kan du också se den som Synth_PLAY *, en sorts pekare till ett Synth_PLAY-objekt. Det betyder i synnerhet att p kan vara samma sak som en NULL-pekare. </para> +</listitem> + +<listitem> +<para +>Du kan skapa en NULL-referens genom att explicit tilldela den. </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); +</programlisting> +</listitem> + +<listitem> +<para +>Att anropa objekt med en NULL-referens orsakar en minnesdump </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); + string s = p.toString(); +</programlisting> +<para +>orsakar en minnesdump. Om man jämför detta med en pekare, är det i stor sett samma som <programlisting> + QWindow* w = 0; + w->show(); +</programlisting +> vilket varje C++ programmerare vet att man ska undvika. </para> +</listitem> + +<listitem> +<para +>Oinitierade objekt försöker att skapa sig själva när de först används </para> + +<programlisting +>Arts::Synth_PLAY p; + string s = p.toString(); +</programlisting> +<para +>är något annorlunda än att följa en NULL-pekare. Du talade inte alls om för objektet vad det är, och nu försöker du använda det. Gissningen här är att du vill ha en ny lokal instans av ett Arts::Synth_PLAY-objekt. Du kan förstås ha velat göra något annat (som att skapa objektet någon annanstans, eller använda ett befintligt fjärrobjekt). Det är i alla fall en bekväm genväg för att skapa objekt. Att skapa ett objekt när det först används fungerar inte när du väl har tilldelat det något annat (som en null-referens). </para> + +<para +>Den motsvarande C++ terminologin skulle vara <programlisting> + QWidget* w; + w->show(); +</programlisting +> som naturligtvis helt enkelt ger ett segmenteringsfel i C++. Så detta är annorlunda här. Det här sättet att skapa objekt är knepigt, eftersom det inte är nödvändigt att det finns en implementering för ditt gränssnitt. </para> + +<para +>Betrakta till exempel ett abstrakt objekt som ett Arts::PlayObject. Det finns naturligtvis konkreta PlayObjects, som de för att spela mp3-filer eller wav-filer, men <programlisting> + Arts::PlayObject po; + po.play(); +</programlisting +> misslyckas helt säkert. Problemet är att fastän ett PlayObject försöker skapas, så misslyckas det eftersom det bara finns objekt som Arts::WavPlayObject och liknande. Använd därför bara det här sättet att skapa objekt om du är säker på att det finns en implementering. </para> +</listitem> + +<listitem> +<para +>Referenser kan peka på samma objekt </para> + +<programlisting +>Arts::SimpleSoundServer s = Arts::Reference("global:Arts_SimpleSoundServer"); + Arts::SimpleSoundServer s2 = s; +</programlisting> + +<para +>skapar två referenser som anger samma objekt. Det kopierar inte något värde, och skapar inte två objekt. </para> +</listitem> + +<listitem> +<para +>Alla objekt referensräknas. Så fort ett objekt inte har några referenser längre, tas det bort. Det finns inget sätt att uttryckligen ta bort ett objekt, men du kan dock använda något sådant här <programlisting> + Arts::Synth_PLAY p; + p.start(); + [...] + p = Arts::Synth_PLAY::null(); +</programlisting +> för att få Synth_PLAY-objektet att försvinna till slut. I synnerhet ska det aldrig vara nödvändigt att använda new och delete i samband med referenser. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="references-failure"> +<title +>Fallet med misslyckanden</title> + +<para +>Eftersom referenser kan peka på fjärrobjekt, kan servrarna som innehåller de här objekten krascha. Vad händer då? </para> + +<itemizedlist> + +<listitem> +<para +>En krasch ändrar inte om en referens är en null-referens. Det här betyder att om <function +>foo.isNull()</function +> var <returnvalue +>true</returnvalue +> innan en serverkrasch är den också <returnvalue +>true</returnvalue +> efter en serverkrasch (vilket är självklart). Det betyder också att om <function +>foo.isNull()</function +> var <returnvalue +>false</returnvalue +> innan en serverkrasch (foo angav ett objekt) är den också <returnvalue +>false</returnvalue +> efter serverkraschen. </para> +</listitem> + +<listitem> +<para +>Att anropa metoder med en giltig referens förblir säkert. Antag att servern som innehåller objektet calc kraschade. Fortfarande är anrop till objekt som <programlisting> + int k = calc.subtract(i,j) +</programlisting +> säkra. Det är uppenbart att subtract måste returnera något här, vilket den inte kan eftersom fjärrobjektet inte längre finns. I det här fallet skulle (k == 0) vara sant. I allmänhet försöker operationer returnera något <quote +>neutralt</quote +> som resultat, som 0.0, en null-referens för objekt eller tomma strängar, när objektet inte längre finns. </para> +</listitem> + +<listitem> +<para +>Att kontrollera med <function +>error()</function +> avslöjar om något fungerade. </para> + +<para +>För ovanstående fall, skulle <programlisting> + int k = calc.subtract(i,j) + if(k.error()) { + printf("k är inte i-j!\n"); + } +</programlisting +> skriva ut <computeroutput +>k är inte i-j</computeroutput +> när fjärranropet inte fungerade. Annars är <varname +>k</varname +> verkligen resultatet av subtraktionsoperationen som utförs av fjärrobjektet (ingen serverkrasch). För metoder som gör saker som att ta bort en fil, kan du inte veta säkert om det verkligen skett. Naturligtvis skedde det om <function +>.error()</function +> är <returnvalue +>false</returnvalue +>. Men om <function +>.error()</function +> är <returnvalue +>true</returnvalue +>, finns det två möjligheter: </para> + +<itemizedlist> +<listitem> +<para +>Filen togs bort, och servern kraschade precis efter den togs bort, men innan resultatet överfördes. </para> +</listitem> + +<listitem> +<para +>Servern kraschade innan den kunde ta bort filen. </para> +</listitem> +</itemizedlist> +</listitem> + +<listitem> +<para +>Att använda nästlade anrop är farligt i ett program som ska vara kraschsäkert. </para> + +<para +>Att använda något som liknar <programlisting> + window.titlebar().setTitle("foo"); +</programlisting +> är ingen bra Idé. Antag att du vet att fönstret innehåller en giltig fönsterreferens. Antag att du vet att <function +>window.titlebar()</function +> returnerar en referens till namnlisten eftersom fönsterobjektet är riktigt implementerat. Men satsen ovan är ändå inte säker. </para> + +<para +>Vad kan hända om servern som innehåller fönsterobjektet har kraschat. Då, oberoende av hur bra implementeringen av Window är, så kommer du att få en null-referens som resultat av operationen window.titlebar(). Och sedan kommer förstås anropet till setTitle med den här null-referensen också leda till en krasch. </para> + +<para +>Så en säker variant av detta skulle vara <programlisting> + Titlebar titlebar = window.titlebar(); + if(!window.error()) + titlebar.setTitle("foo"); +</programlisting +> och lägg till den riktiga felhanteringen om du vill. Om du inte litar på implementeringen av Window, kan du lika väl använda <programlisting> + Titlebar titlebar = window.titlebar(); + if(!titlebar.isNull()) + titlebar.setTitle("foo"); +</programlisting +> som båda är säkra. </para> +</listitem> +</itemizedlist> + +<para +>Det finns andra felorsaker, som nerkoppling av nätverket (antag att du tar bort kabeln mellan din server och klient medan ditt program kör). Deras effekt är ändå likadan som en serverkrasch. </para> + +<para +>Totalt sett är det förstås en policyfråga hur strikt du försöker hantera kommunikationsfel i hela ditt program. Du kan följa metoden <quote +>om servern kraschar, måste vi avlusa den till den aldrig kraschar igen</quote +>, som skulle betyda att du inte behöver bry dig om alla de här problemen. </para> + +</sect2> + +<sect2 id="references-internals"> +<title +>Interna funktioner: distribuerad referensräkning</title> + +<para +>Ett objekt måste ägas av någon för att finnas till. Om det inte gör det, kommer det upphöra att finnas till (mer eller mindre) omedelbart. Internt anges en ägare genom att anropa <function +>_copy()</function +>, som räknar upp en referensräknare, och en ägare tas bort genom att anropa <function +>_release()</function +>. Så fort referensräknaren når noll, så tas objektet bort. </para> + +<para +>Som en variation på temat, anges fjärranvändning med <function +>_useRemote()</function +>, och löses upp med <function +>_releaseRemote()</function +>. Dessa funktioner har en lista över vilken server som har anropat dem (och därför äger objektet). Det här används om servern kopplar ner (dvs. krasch, nätverksfel), för att ta bort referenser som fortfarande finns till objektet. Det här görs i <function +>_disconnectRemote()</function +>. </para> + +<para +>Nu finns det ett problem. Betrakta ett returvärde. I vanliga fall ägs inte returvärdesobjektet av funktionen som anropas längre. Det ägs inte heller av den som anropar, förrän meddelandet som innehåller objektet har tagits emot. Så det finns en tid med objekt som <quote +>saknar ägare</quote +>. </para> + +<para +>Nu när vi skickar ett objekt kan man vara rimligt säker på att så fort det tas emot, ägs det av någon igen, om inte, återigen, mottagaren kraschar. Det här betyder i alla fall att speciell hänsyn måste tas för objekt åtminstone vid sändning, och troligen också vid mottagning, så att de inte tas bort meddetsamma. </para> + +<para +>Sättet som &MCOP; gör det här är genom att <quote +>tagga</quote +> objekt som håller på att kopieras över nätverket. Innan en sådan kopiering börjar, anropas <function +>_copyRemote</function +>. Det här förhindrar att objektet tas bort på ett tag (5 sekunder). Så fort mottagaren anropar <function +>_useRemote()</function +>, tas taggen bort igen. Så alla objekt som skickas över nätverket, taggas innan överföringen. </para> + +<para +>Om mottagaren tar emot ett objekt som finns på samma server, så används förstås inte <function +>_useRemote()</function +>. I det här specialfallet, finns funktionen <function +>_cancelCopyRemote()</function +> för att ta bort taggen manuellt. Förutom detta, finns det också en tidsbaserad borttagning av taggen, om taggning gjordes, men mottagaren verkligen inte fick objektet (på grund av krasch, nätverksfel). Det här görs med klassen <classname +>ReferenceClean</classname +>. </para> + +</sect2> + +</sect1> + +<sect1 id="detail-gui-elements"> +<title +>Grafiska gränssnittselement</title> + +<para +>Grafiska gränssnittselement är för närvarande på det experimentella stadiet. Det här avsnittet beskriver vad som är meningen ska hända med dem, så om du är en utvecklare, kan du förstå hur &arts; kommer att hantera grafiska gränssnitt i framtiden. Det finns också redan en del kod på plats. </para> + +<para +>Grafiska gränssnittselement ska användas för att låta syntesstrukturer växelverka med användaren. I det enklaste fallet ska användaren kunna ändra några parametrar för en struktur direkt (som en förstärkningsfaktor som används innan den slutliga uppspelningsmodulen). </para> + +<para +>För mer komplexa fall, kan man tänka sig att användaren ändrar parametrar för grupper av strukturer och/eller strukturer som inte kör än, som att ändra <acronym +>ADSR</acronym +> enveloppen för det aktiva &MIDI;-instrumentet. Något annat skulle kunna vara att ange filnamnet för ett samplingsbaserat instrument. </para +> + +<para +>Å andra sidan, skulle användaren kunna vilja övervaka vad synthezisern gör. Det skulle kunna finnas oscilloskop, spektrumanalysatorer volymmätare och <quote +>experiment</quote +> som till exempel räknar ut frekvensöverföringskurvan för en given filtermodul. </para> + +<para +>Till sist, ska grafiska gränssnittselement kunna kontrollera hela strukturen av allt som kör inne i &arts;, och på vilket sätt. Användaren ska kunna tilldela instrument till midi-kanaler, starta nya effektbehandlingssteg, anpassa sin huvudmixerpanel (som själv är byggd av &arts;-strukturer) för att få ytterligare en kanal eller använda en annan strategi för tonkontroll. </para> + +<para +>Som du ser, ska grafiska gränssnittselement ge alla möjligheterna i en virtuell studio som &arts; simulerar åt användaren. Naturligtvis ska de också växelverka med midi-ingångar (som skjutreglage som också flyttas om de får &MIDI;-indata som ändrar motsvarande parameter), och troligen till och med skapa händelser själva, för att växelverkan med användaren ska kunna spelas in via en sequencer. </para> + +<para +>Tekniskt sett är Idén att ha en &IDL;-basklass för alla grafiska komponenter (<classname +>Arts::Widget</classname +>), och härleda ett antal vanliga komponenter från den (som <classname +>Arts::Poti</classname +>, <classname +>Arts::Panel</classname +>, <classname +>Arts::Window</classname +>, ...). </para> + +<para +>Därefter kan man implementera de här grafiska komponenterna med en verktygslåda, till exempel &Qt; eller Gtk. Till slut, bör effekter bygga sina grafiska gränssnitt från existerande komponenter. En efterklangseffekt skulle till exempel kunna bygga sitt grafiska gränssnitt från fem <classname +>Arts::Poti</classname +>-mojänger och ett <classname +>Arts::Window</classname +>. Så OM det finns en &Qt; implementering för de här grundkomponenterna, kan effekten visas med &Qt;. Om det finns en Gtk implementering, fungerar det också med Gtk (och ser mer eller mindre likadant ut). </para> + +<para +>Till sist, eftersom vi använder &IDL; här, kan aRts-byggaren (eller andra verktyg) sätta ihop grafiska gränssnitt visuellt, eller automatgenerera grafiska gränssnitt, med tips för parametervärden, enbart baserat på gränssnitten. Det borde vara ganska rättframt att skriva en klass för att <quote +>skapa grafiskt gränssnitt från en beskrivning</quote +>, som tar en beskrivning av ett grafiskt gränssnitt (som innehåller de olika parametrarna och grafiska komponenterna), och skapar ett levande objekt för ett grafiskt gränssnitt från den. </para> + +<para +>Baserat på &IDL; och &arts;/&MCOP;-komponentmodellen, bör det vara lätt att utöka de möjliga objekten som kan användas för det grafiska gränssnittet precis lika lätt som det är att lägga till en insticksmodul till &arts; som till exempel implementerar ett nytt filter. </para> + +</sect1> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/digitalaudio.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/digitalaudio.docbook new file mode 100644 index 00000000000..982a9f2a766 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/digitalaudio.docbook @@ -0,0 +1,16 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE appendix PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<appendix id="intro-digital-audio"> +<title +>Introduktion till digitalljud</title> + +<para +>Digital sampling, filter, ljudeffekter, etc.</para> + +</appendix> + + + diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/faq.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/faq.docbook new file mode 100644 index 00000000000..e9130d27924 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/faq.docbook @@ -0,0 +1,1307 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> +<chapter id="faq"> +<title +>Vanliga frågor</title> + +<para +>Det här avsnittet besvarar några frågor som ofta ställs om &arts;. </para> + +<qandaset id="faq-general"> +<title +>Allmänna frågor</title> + +<qandaentry> +<question> +<para +>Stöder &kde; mitt ljudkort för ljuduppspelning? </para> +</question> + +<answer> +<para +>&kde; använder &arts; för att spela upp ljud, och &arts; använder ljuddrivrutinerna i &Linux; kärna, antingen <acronym +>OSS</acronym +> eller <acronym +>ALSA</acronym +> (med emulering av <acronym +>OSS</acronym +>). Om ditt ljudkort antingen stöds av <acronym +>ALSA</acronym +> eller <acronym +>OSS</acronym +> och är riktigt inställt (dvs. alla andra &Linux;-program kan spela upp ljud), kommer det att fungera. Det finns dock några problem med specifik hårdvara, läs <link linkend="faq-hardware-specific" +>avsnittet om hårdvaruspecifika problem</link +> om du får problem med artsd på din dator. </para> +<para +>Under tiden har också stöd för diverse andra plattformar lagts till. Här är en fullständig lista över hur den senaste versionen av &arts; kan spela ljud. Om du har en plattform som inte stöds, fundera gärna på att anpassa &arts; till din plattform. </para> + +<informaltable> +<tgroup cols="2"> +<thead> +<row> +<entry +>&arts; metod för ljud-I/O</entry> +<entry +>Kommentar</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>paud</entry> +<entry +>Stöd för AIX personliga ljudenhet (Personal Audio Device)</entry> +</row> + +<row> +<entry +>alsa</entry> +<entry +>Linux ALSA-0.5 och ALSA-0.9 drivrutiner</entry> +</row> + +<row> +<entry +>libaudioio</entry> +<entry +>Stöd för det generella LibAudioIO-biblioteket som fungerar på Solaris</entry> +</row> + +<row> +<entry +>nas</entry> +<entry +>NAS ljudserver, användbar för X-terminaler med NAS-stöd</entry> +</row> + +<row> +<entry +>null</entry> +<entry +>Ljudenheten null, kastar bort ljudet utan att något hörs</entry> +</row> + +<row> +<entry +>oss</entry> +<entry +>OSS (Open Sound System) stöd (fungerar på Linux, olika BSD-versioner och andra plattformar med OSS-drivrutiner installerade)</entry> +</row> + +<row> +<entry +>toss</entry> +<entry +>Trådat OSS-stöd, som fungerar bättre i vissa fall då det vanliga OSS-stödet inte fungerar bra</entry> +</row> + +<row> +<entry +>sgi</entry> +<entry +>Stöd för SGI Direct Media för IRIX</entry> +</row> + +<row> +<entry +>sun</entry> +<entry +>Solaris-stöd</entry> +</row> + +</tbody> +</tgroup> +</informaltable> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Jag kan inte spela <literal role="extension" +>wav</literal +>-filer med &artsd;! </para> +</question> + +<answer> +<para +>Kontrollera att &artsd; är länkad till <filename +>libaudiofile</filename +> (<userinput +><command +>ldd</command +> <parameter +>artsd</parameter +></userinput +>). Om den inte är det, ladda ner kdesupport, kompilera om allt, och det kommer att fungera. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Jag hör ljud när jag är inloggad som <systemitem class="username" +>root</systemitem +>, men andra användare saknar ljud! </para> +</question> + +<answer> +<para +>Rättigheterna för filen <filename class="devicefile" +>/dev/dsp</filename +> påverkar vilka användare som har ljud. För att låta alla använda den, gör så här: </para> + +<procedure> +<step> +<para +>Logga in som <systemitem class="username" +>root</systemitem +>. </para> +</step> + +<step> +<para +>Öppna ett &konqueror;-fönster. </para> +</step> + +<step> +<para +>Gå till katalogen <filename class="directory" +>/dev</filename +>. </para> +</step> + +<step> +<para +>Klicka på filen <filename +>dsp</filename +> med <mousebutton +>höger</mousebutton +> musknapp, och välj egenskaper. </para> +</step> + +<step> +<para +>Klicka på fliken <guilabel +>Skydd</guilabel +>. </para> +</step> + +<step> +<para +>Markera rutorna <guilabel +>Visa poster</guilabel +> och <guilabel +>Skriv poster</guilabel +> i alla avdelningar. </para> +</step> + +<step> +<para +>Klicka på <guibutton +>Ok</guibutton +>. </para> +</step> +</procedure> + +<para +>Du kan uppnå samma effekt i ett terminalfönster med kommandot <userinput +><command +>chmod</command +> <option +>666</option +> <parameter +>/dev/dsp</parameter +></userinput +>. </para> + +<para +>För att begränsa tillgången av ljud till särskilda användare kan du använda gruppskydd. För vissa &Linux;-distributioner, till exempel Debian/Potato, ägs <filename class="devicefile" +>/dev/dsp</filename +> redan av en grupp som heter <systemitem class="groupname" +>audio</systemitem +>, så allt du behöver göra är att lägga till användarna till den här gruppen. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Det här hjälper för &artsd;, men vad gäller för &kmix;, &kmid;, &kscd; etc.? </para> +</question> +<answer> + +<para +>Det finns diverse andra enheter som tillhandahåller funktioner som ska kommas åt av multimediaprogram. Du kan behandla dem på samma sätt, antingen genom att göra dem tillgängliga för alla, eller använda grupper för att kontrollera åtkomsten. Här är en lista, som fortfarande kan vara ofullständig (dessutom om det finns flera enheter på formen <filename class="devicefile" +>midi0</filename +>, <filename class="devicefile" +>midi1</filename +>..., så finns bara 0-versionen med): </para> + +<itemizedlist> +<listitem> +<para> +<filename class="devicefile" +>/dev/admmidi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/adsp0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/amidi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/amixer0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/audio</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/audio0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/cdrom</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/dmfm0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/dmmidi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/dsp</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/dsp0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/midi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/midi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/midi00</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/midi00</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/mixer</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/mixer0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/mpu401data</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/mpu401stat</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/music</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/rmidi0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/rtc</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/sequencer</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/smpte0</filename> +</para> +</listitem> +<listitem> +<para> +<filename class="devicefile" +>/dev/sndstat</filename> +</para> +</listitem> +</itemizedlist> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad kan jag göra om artsd inte startar eller kraschar när den kör?</para> +</question> + +<answer> +<para +>Försök först att använda de förvalda inställningarna i inställningscentralen (eller om du startar manuellt, ange inga extra väljare utom eventuellt <userinput +><option +>-F</option +><parameter +>10</parameter +> <option +>-S</option +><parameter +>4096</parameter +></userinput +> för latenstid). Särskilt <emphasis +>full duplex fungerar troligen inte</emphasis +> med diverse drivrutiner, så försök stänga av det. </para> + +<para +>Ett bra sätt att räkna ut varför &artsd; inte startar (eller kraschar när den kör) är att starta den manuellt. Öppna ett &konsole;-fönster och skriv: </para> + +<screen width="40" +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-F</option +><parameter +>10</parameter +> <option +>-S</option +><parameter +>4096</parameter +> +></userinput +></screen> + +<para +>Du kan också lägga till väljaren <option +>-l0</option +>, som skriver ut mer information om vad som händer, så här: </para> +<screen width="40" +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-l0</option +> <option +>-F</option +><parameter +>10</parameter +> <option +>-S</option +><parameter +>4096</parameter +></userinput +></screen> + +<para +>Genom att göra detta får du förmodligen någon användbar information om varför den inte startade. Eller om den kraschar medan något särskilt pågår, kan du göra det och se <quote +>hur</quote +> den kraschar. Om du vill rapportera ett fel, kan en bakåtspårning skapad med <command +>gdb</command +> och/eller en <command +>strace</command +> hjälpa till att hitta problemet. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Kan jag flytta på &artsd; (flytta kompilerade filer till en annan katalog)?</para> +</question> + +<answer> +<para +>Du kan inte flytta &arts; helt perfekt. Problemet är att &artswrapper; har platsen för &artsd; inkompilerad av säkerhetsskäl. Du kan i alla fall använda <filename +>.mcoprc</filename +>-filen (TraderPath/ExtensionPath posterna) för att åtminstone få en flyttad &artsd; att hitta sina komponenter. Se <link linkend="the-mcoprc-file" +>kapitlet om <filename +>.mcoprc</filename +>-filen</link +> för detaljer om hur man gör detta. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Kan jag kompilera &arts; med gcc-3.0?</para> +</question> + +<answer> +<para +>Ett kort svar: nej, &arts; fungerar inte om du kompilerar det med gcc-3.0. </para> + +<para +>Långt svar: i den officiella utgåvan av gcc-3.0, finns det två fel som påverkar &arts;. Det första problemet med gcc-3.0, c++/2733, är ganska ofarligt (och har att göra med problem med asm-satsen). Det gör att convert.cc inte kan kompileras. Det har rättats i gcc-3.0 CVS, och kommer inte att vara ett problem med gcc-3.0.1 och senare. Ett sätt att gå förbi problemet har också lagts till i CVS-versionen av KDE/aRts. </para> +<para +>Det andra problemet med gcc-3.0, c++/3145 (som orsakar felaktig kodgenerering för vissa fall av multipla virtuellt arv) är kritisk. Program som &artsd; kraschar helt enkelt när de startas om de har kompilerats med gcc-3.0. Även om vissa framsteg har gjorts i gcc-3.0 grenen när det här skrivs, kraschar fortfarande &artsd; väldigt ofta, oförutsägbart. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>Vilka program kör med &arts;?</para> +</question> +<answer> + +<para +>Självklart så fungerar alla program som ingår i &kde; med &arts;. Detta innefattar: </para> + +<itemizedlist> +<listitem +><para +>&noatun;</para +></listitem> +<listitem +><para +>aRts-byggare</para +></listitem> +<listitem +><para +>&aktion;</para +></listitem> +<listitem +><para +>&kmid;</para +></listitem> +<listitem +><para +>&kmidi;</para +></listitem> +<listitem +><para +>&kmix;</para +></listitem> +<listitem +><para +>&kscd;</para +></listitem> +<listitem +><para +>&kde;-spel som &kpoker; och &ktuberling;</para +></listitem> +</itemizedlist> + +<para +>Vissa &kde;-program som ännu inte ingår i &kde;-utgåvor (t.ex. i kdenonbeta) stöder också &arts;, inklusive: </para> + +<itemizedlist> +<listitem +><para +>&brahms;</para +></listitem> +<listitem +><para +><application +>Kaboodle</application +></para +></listitem> +<listitem +><para +><application +>Kdao</application +></para +></listitem> +</itemizedlist> + +<para +>Följande program som inte hör till -&kde; är kända för att fungera med &arts;: </para> + +<itemizedlist> +<listitem +><para +><application +>xmms</application +> (med &arts;-insticksprogram)</para +></listitem> +<listitem +><para +>Real Networks <application +>RealPlayer</application +> 8.0 (fungerar med &artsdsp;; inbyggt &arts;-stöd undersöks)</para +></listitem> +</itemizedlist> + +<para +>Följande program är kända för att <emphasis +>inte</emphasis +> fungera med &arts;: </para> + +<itemizedlist> +<listitem +><para +>inga</para +></listitem> +</itemizedlist> + +<para +>Se också svaren till frågorna i avsnittet om <link linkend="faq-non-arts" +>program som inte stöder &arts;</link +>. </para> + +<para +>Det här avsnittet är ofullständigt. Om du har mer information om program som stöds eller inte, var vänlig skicka dem till upphovsmannen så att de kan läggas till här. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-non-arts"> +<title +>Program som inte stöder &arts;</title> + +<qandaentry> +<question> +<para +>Så fort &kde; kör, så kan inga andra program komma åt mitt ljudkort! </para> +</question> +<answer> +<para +>Eftersom &arts;-ljudservern som används av &kde; kör, använder den ljudenheten. Om servern är oanvänd i 60 sekunder, går den till vänteläge och släpper enheten automatiskt. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Du sa att den går till vänteläge efter 60 sekunder, det gör den inte för mig! </para> +</question> +<answer> +<para +>Om du startar artsd från KDE:s inställningscentral, är det förvalda värdet att gå till vänteläge efter 60 sekunder. Om du startar artsd från kommandoraden måste du använda väljaren -s för att ange väntelägesvärdet, annars är det förvalda beteendet att stänga av väntelägesfunktionen. </para> +<para +>För närvarande går servern inte till vänteläge om full duplex används. Stäng av full duplex i inställningscentralen så går den till vänteläge. Att stänga av full duplex är i allmänhet en bra idé ändå, om du bara använder &arts; för att spela upp ljud och inte för att spela in. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Hur kan jag köra gamla program som inte stöder &arts;? </para> +</question> + +<answer> +<para +>Kör dem med &artsdsp;. Om du till exempel normalt skulle köra: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>mpg123</command +> <option +>foo.mp3</option +></userinput +></screen> + +<para +>använd istället:</para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>mpg123 foo.mp3</option +></userinput +></screen> + +<para +>Det här skickar ljudutmatning till &arts;. Den här metoden kräver inte några ändringar i programmet. Den är ändå något av en ful snabbfix, och stöder ännu inte alla funktioner i ljudkortsenheten, så vissa program kanske inte fungerar. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Jag kan inte köra &artsdsp; med något program. Den kraschar alltid! </para> +</question> +<answer> +<para +>Du behöver en aktuell version av glibc-bilblioteket. &artsdsp; fungerar inte tillförlitligt på vissa äldre &Linux;-distributioner. Till exempel på Debian 2.1 (som är baserat på glibc 2.0) fungerar den inte, medan på Debian 2.2 (som är baserat på glibc 2.1.3), gör den det. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Finns det teoretiska begränsningar med vissa program som förhindrar att de någonsin fungerar med &artsdsp;? </para> +</question> +<answer> +<para +>Nej. Att använda &artsdsp; kan resultera i något högre latenstider och <acronym +>CPU</acronym +>-användning än att använda &arts; programmeringsgränssnitt direkt. Förutom det, ska alla program som inte fungerar anses som ett fel i &artsdsp;. Tekniken som används av &artsdsp; ska, om den är riktigt implementerad, tillåta <emphasis +>varje</emphasis +> program att fungera med den (inklusive stora program som <application +>Quake</application +> 3). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad kan jag göra om ett program inte fungerar med &artsdsp;? </para> +</question> +<answer> +<para +>Du kan vänta på att &artsd; går till vänteläge eller använda kommandot <userinput +><command +>artsshell</command +> <option +>suspend</option +></userinput +> för att begära att servern ska gå till vänteläge. Du kommer bara kunna få servern att gå till vänteläge om inget &arts;-program använder den för närvarande, och inga &arts;-program kan köra medan servern är i vänteläge. </para> + +<para +>Om servern är upptagen ser ett grovt men effektivt sätt att bli av med den ut så här: </para> + + +<screen +><prompt +>%</prompt +> <userinput +><command +>killall</command +> <option +>artsd</option +> ; <command +>killall</command +> <option +>artswrapper</option +></userinput> +<lineannotation +>Starta nu ditt eget program.</lineannotation> +<prompt +>%</prompt +> <userinput +><command +>kcminit</command +> <option +>arts</option +></userinput +> +</screen> + +<para +>Alla &arts;-program som för närvarande kör kan krascha, när du väl avslutar servern. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>Vad gäller för program skrivna för &kde; 1.x? </para> +</question> +<answer> +<para +>Om du kör &kde; 1.x program, som spelar upp ljud via ljudservern i &kde; 1, måste du köra <application +>kaudioserver</application +> för att det ska fungera. Du kan starta <application +>kaudioserver</application +> på samma sätt som andra program som inte stöder &arts;: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>kaudioserver</option +></userinput +> +</screen> + +<para +>Du måste ha installerat kaudioserver (från samma källa där du skaffade &kde; 1.x programmen). Den hör till &kde; 1.x, inte &kde; 2. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad gäller för program som använder Enlightened Sound Daemon, <acronym +>ESD</acronym +>? </para> +</question> +<answer> +<para +>Det här problemet liknar fallet med <application +>kaudioserver</application +>. Sådana program kräver en esd-server som kör. Du kan starta <command +>esd</command +> via &artsdsp;, och alla program som stöder <acronym +>ESD</acronym +> ska fungera bra, så här: </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>esd</option +></userinput +> +</screen> +<para +>Nyare versioner av aRts ( +>= 1.2.0) kan också använda Enlightened Sound Daemon istället för direkt åtkomst av ljudkortet. På kommandoraden kan du använda väljaren -a, på följande sätt </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-a esd</option +></userinput +> +</screen> +<para +>för att få stöd för ESD. I stället, i KDE, kan du använda Inställningscentralen för att anpassa artsd att använda ESD, via Ljud -> Ljudserver -> Ljud I/O. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-latency"> +<title +>Latenstid</title> + +<qandaentry> +<question> +<para +>Ibland hör jag korta pauser när jag lyssnar på musik. Är detta ett fel? </para> +</question> +<answer> +<para +>Det här är troligen inget fel, utan orsakas av det faktum att &Linux; kärna inte är särskilt bra på realtidsschemaläggning. Det finns situationer då &arts; inte kan hänga med i uppspelningen. Du kan dock aktivera realtidsrättigheter (via inställningscentralen), och använda en stor latenstidsinställning (som <guilabel +>250 ms</guilabel +> eller <guilabel +>så stor som möjligt</guilabel +>), vilket bör förbättra situationen. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad är effekten av svarstidsinställningen? </para> +</question> +<answer> +<para +>Hjälptexten för den här inställningen i inställningscentralen kan vara förvirrande. Ett lägre värde betyder att &arts; reagerar snabbare på yttre händelser (dvs tiden det tar mellan ett fönster stängs och ljudet spelas av &artsd;). Den kommer också att använda mer <acronym +>CPU</acronym +>-resurser och vara mer benäget att orsaka pauser i ljudet.</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Finns det någonting annat jag kan göra för att undvika pauser? </para> +</question> +<answer> +<para +>För användare av <acronym +>IDE</acronym +>-enheter, kan man använda kommandot <command +>hdparm</command +> för att ställa in din <acronym +>IDE</acronym +>-enhet att använda <acronym +>DMA</acronym +>-läge. Ett varningens ord: Det här fungerar inte med all sorts hårdvara, och kan orsaka att man måste göra en hårdvaruåterställning, eller i ovanliga fall, förlust av data. Läs dokumentationen för kommandot <command +>hdparm</command +> för mer detaljer. Jag har använt följande kommando med lyckat resultat: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>hdparm</command +> <option +>-c1</option +> <option +>-d1</option +> <option +>-k1</option +> <option +>-K1</option +> <parameter +>/dev/hda</parameter +></userinput +> +</screen> + +<para +>Du måste köra det här efter varje omstart, så du kanske vill lägga det i ett uppstartsskript för systemet (hur man gör detta är specifikt för varje distribution, på Debian &Linux; läggs det oftast i <filename +>/etc/rc.boot</filename +>). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Realtidsprioritet verkar inte få någon effekt för mig? </para> +</question> +<answer> +<para +>Kontrollera att artswrapper verkligen är installerad suid <systemitem class="username" +>root</systemitem +>, som det är meningen att den ska vara. Många distributioner (till exempel SuSE7.x) gör inte detta. Du kan kontrollera det med: ls -l $(which artswrapper). Bra: <screen> +<prompt +>%</prompt +> <userinput +><command +>ls</command +> <option +>-l</option +> <parameter +>$(which artswrapper)</parameter +></userinput> +-rwsr-xr-x 1 root root 4556 Sep 24 18:05 /opt/kde2/bin/artswrapper +</screen +> Dåligt: <screen> +<prompt +>%</prompt +> <userinput +><command +>ls</command +> <option +>-l</option +> <parameter +>$(which artswrapper)</parameter +></userinput> +-rwxr-xr-x 1 root root 4556 Sep 24 18:05 /opt/kde2/bin/artswrapper +</screen +> Om du inte har med s:et, kan du få det med: <screen +><prompt +>%</prompt +> <userinput +><command +>chown</command +> <option +>root</option +> <parameter +>$(which artswrapper)</parameter +></userinput> +<prompt +>%</prompt +> <userinput +><command +>chmod</command +> <option +>4755</option +> <parameter +>$(which artswrapper)</parameter +></userinput +> +</screen> +</para> + +<para +>Om du gör &artswrapper; SUID <systemitem class="username" +>root</systemitem +>, kommer det troligen förbättra kvaliteten på ljudåtergivningen genom att reducera uppehåll i musiken. Dock ökar det också risken att ett fel i koden, eller en användare med uppsåt att skada kan krascha eller skada datorn på något sätt. Dessutom, att prioritera hög ljudkvalitet på fleranvändardatorer kan orsaka försämrad prestanda för användare som försöker använda datorn på ett <quote +>produktivt</quote +> sätt.</para> + +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>Varför tar &artsd; så mycket <acronym +>CPU</acronym +>-tid? </para> +</question> +<answer> +<para +>Kontrollera dina svarstidsinställningar. Dessutom är den nuvarande versionen inte egentligen optimerad. Det här kommer att bli bättre, och till dess kan inte någon riktig förutsägelse göras om hur snabb &artsd; kan vara. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-network"> +<title +>Nätverkstransparens</title> + +<qandaentry> +<question> +<para +>Vad måste jag göra för att få nätverkstransparens? </para> +</question> +<answer> +<para +>Aktivera det i inställningscentralens inställningar för <guilabel +>Ljudserver</guilabel +> (<guilabel +>Utbyt säkerhets- och referensinformation över X11-servern</guilabel +> och <guilabel +>Aktivera nätverkstransparens</guilabel +>). Kopiera sedan din <filename +>.mcoprc</filename +>-fil till alla maskiner som du tänker använda nätverkstransparensen från. Logga in igen. Försäkra dig om att värddatorerna som ska samarbeta känner till varandras namn (dvs. de har namn som kan lösas upp eller finns i <filename +>/etc/hosts</filename +>). </para> + +<para +>Det här bör vara allt du behöver göra. Om det inte fungerar ändå, följer några ytterligare detaljer. &arts; ljudserverprocess &artsd; ska bara köras på en värddator, den med ljudkortet där ljud ska spelas upp. Den kan startas automatiskt vid inloggning av &kde; (om du anger det i inställningscentralen), eller manuellt med någonting i stil med: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-n</option +> <option +>-F</option +> <parameter +>5</parameter +> <option +>-S</option +> <parameter +>8192</parameter +></userinput +> +</screen> + +<para +>Väljaren <option +>-n</option +> anger nätverkstransparens, medan de övriga anpassar latenstider. </para> + +<para +>Din <filename +>.mcoprc</filename +>-fil måste innehålla den här raden: </para> + +<screen +><userinput +>GlobalComm=Arts::X11GlobalComm</userinput +> +</screen> + +<para +>för alla maskiner som är inblandade, för att nätverkstransparens ska fungera. Det är det här som aktiveras av inställningen <guilabel +>Utbyt säkerhets- och referensinformation över X11-servern</guilabel +> i inställningscentralen. </para> + +<para +>Till sist, i alla &kde;-versioner i 2.0.x serien, finns det ett fel som visar sig om du inte har ett domännamn inställt. Klienter till &artsd; försöker hitta anslutningen via kombinationen av <systemitem class="systemname" +><replaceable +>värddatornamn</replaceable +>.<replaceable +>domännamn</replaceable +></systemitem +>. Om domännamnet är tomt, försöker de ansluta till <systemitem class="systemname" +><replaceable +>värddatornamn</replaceable +></systemitem +>. (observera den extra punkten). Att lägga till en post som ser ut så här i <filename +>/etc/hosts</filename +> (dvs <userinput +>orion.</userinput +> om värddatornamnet är <systemitem class="systemname" +>orion</systemitem +>) gör att man undviker problemet. </para> +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>Hur avlusar jag nätverkstransparens om det inte fungerar? </para> +</question> +<answer> +<para +>Om du har &kde;:s källkod, gå till <filename class="directory" +>kdelibs/arts/examples</filename +>, och kör <userinput +><command +>make</command +> <option +>check</option +></userinput +> för att kompilera några program, inklusive <application +>referenceinfo</application +>. Kör sedan </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>./referenceinfo</command +> <option +>global:Arts_SimpleSoundServer</option +></userinput +> +</screen> + +<para +>Utmatningen anger värddatornamnet och porten som används av &arts;. Till exempel, <computeroutput +>tcp:orion:1698</computeroutput +> skulle betyda att alla klienter som försöker använda nätverkstransparens måste veta hur värddatorn <systemitem class="systemname" +>orion</systemitem +> kan nås. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-hardware-specific"> +<title +>Hårdvaruspecifika frågor</title> + +<qandaentry> +<question> +<para +>Vilken hårdvara fungerar artsd inte bra tillsammans med? </para> +</question> +<answer> +<para +>Det verkar som om det finns några få Linux-drivrutiner som inte fungerar bra tillsammans med aRts för vissa versioner av kärnan. Läs först den här listan innan du rapporterar ett fel. Om du märker att informationen i listan inte är fullständig, tveka inte att tala om det för oss. <informaltable +> <tgroup cols="4"> +<thead> +<row> +<entry +>Linux-drivrutin/ljudkort</entry> +<entry +>Fungerar inte med</entry> +<entry +>Fungerar med</entry> +<entry +>Anmärkning</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>i810-drivrutin (Intel 810 + AC97 Audio)</entry> +<entry +>2.4.9</entry> +<entry +>2.4.18, 2.2.20, kommersiell OSS-drivrutin, alsa-0.5.12a med OSS-emulering</entry> +<entry +>drivrutinen orsakar för mycket CPU-last (se nedan)</entry> +</row> + +<row> +<entry +>maestro 3/4-kretsar</entry> +<entry +>2.4.9</entry> +<entry +>?</entry> +<entry +>drivrutinen orsakar ibland överlast av processorn (se nedan)</entry> +</row> + +<row> +<entry +>aureal8820, aureal8830-drivrutiner från sourceforge</entry> +<entry +>2.4.17</entry> +<entry +>?</entry> +<entry +>drivrutinen orsakar felmeddelande / för mycket CPU-last (se nedan)</entry> +</row> + +<row> +<entry +>OSS kommersiell 3.9.4g med Aureal Vortex</entry> +<entry +>?</entry> +<entry +>?</entry> +<entry +>systemet låser sig</entry> +</row> + +<row> +<entry +>ymfpci</entry> +<entry +>2.4.0, 2.4.12</entry> +<entry +>2.4.17</entry> +<entry +>drivrutinen orsakar felmeddelande (se nedan)</entry> +</row> + + + +</tbody> +</tgroup> +</informaltable> +</para> +</answer> +</qandaentry> + + + +<qandaentry> +<question> +<para +>Varför finns det hårdvaruspecifika problem, och hur ser jag dem? </para> +</question> +<answer> +<para +>De vanliga problemen är att drivrutinen inte ger aRts tillräcklig eller tillräckligt noggrann information om när ljuddata ska skrivas. De flesta OSS-drivrutiner ger riktig information, men inte alla. </para> +<para +>Du kan märka att vissa andra program (som xmms) inte behöver den här informationen, och därför fungerar på ett riktigt sätt till och med för din hårdvara. Men &arts; behöver den här informationen, så artsd kan sluta fungera. Det här är fortfarande ett fel i drivrutinen, och inte i &arts;. </para> +<para +>Det finns två sorters beteende som artsd påvisar när den körs med en felaktig drivrutin. Antingen försöker den skicka ny data, men lyckas egentligen aldrig, vilket till slut leder till att för mycket CPU-last används, att detta rapporteras, och att den avslutas. Det andra problemet är att artsd kan få fel information om hur mycket data som ska skrivas. Då <emphasis +>stoppar</emphasis +> artsd med ett felmeddelande som: <screen +>artsd: audiosubsys.cc:458: void Arts::AudioSubSystem::handleIO(int): +Assertion `len == can_write' failed. +Aborted +</screen> +</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad är fel i drivrutinen om jag får problemet med för mycket CPU-last? </para> +</question> +<answer> +<para +>Oftast använder artsd anropet select() för att ta reda på när ny data ska skrivas. Därefter använder den anropet ioctl(...GETOSPACE...), för att ta reda på hur mycket data som ska skrivas. Till sist skriver den data. </para> +<para +>Ett problem uppstår om artsd antingen alltid väcks, eller om det finns mycket lite data att skriva. OSS-dokumentationen anger att anropet select() bara väcker en process om det finns minst ett fragment att skriva. Om artsd väcks när det inte finns någon, eller mycket lite, data att skriva, till exempel en sampling, försöker den skriva småbitar med ljuddata, vilket kan bli mycket kostsamt, och till slut ge för mycket CPU-last. </para> +<para +>För att rätta detta, ska drivrutinen bara väcka artsd om ett helt fragment kan skrivas. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Vad är det för fel i drivrutinen om jag får det här felmeddelandet? </para> +</question> +<answer> +<para +>Oftast använder artsd anropet select() för att ta reda på när ny data ska skrivas. Därefter använder den anropet ioctl(...GETOSPACE...), för att ta reda på hur mycket data som ska skrivas. Till sist skriver den data. </para> +<para +>Om artsd inte kan skriva så mycket data som anges av anropet ioctl, så stoppar den med felmeddelandet ovan. För att rätta detta, ska drivrutinen ange rätt storlek på det lediga utrymmet. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-other"> +<title +>Övriga problem</title> + +<qandaentry> +<question> +<para +>Jag kan inte använda aRts-byggaren. Den kraschar när jag kör en modul! </para> +</question> +<answer> +<para +>Den troligaste orsaken är att du använder gamla strukturer eller moduler som inte stöds i &kde; 2 versionen. Tyvärr gäller dokumentationen på nätet &arts;-0.3.4.1 som är helt föråldrad. Den oftast rapporterade kraschen är att om en struktur körs i aRts-byggaren fås felmeddelandet <errorname +>[artsd] Synth_PLAY: ljuddelsystemet används redan.</errorname +> </para> + +<para +>Du måste använda en Synth_AMAN_PLAY modul istället för Synth_PLAY och problemet försvinner. Se också aRts-byggarens hjälpfil (tryck på <keycap +>F1</keycap +> i aRts-byggaren). </para> + +<para +>Senare versioner av aRts-byggaren (&kde; 2.1 beta 1 och senare) levereras med ett antal exempel som du kan använda. </para> +</answer> +</qandaentry> + +</qandaset> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/future.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/future.docbook new file mode 100644 index 00000000000..0692bc71610 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/future.docbook @@ -0,0 +1,399 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.1.2-Based Variant +V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="future-work"> +<title +>Framtida arbete</title> + +<para +>Det här avsnittet beskriver en del av det pågående arbetet med &arts;. Utvecklingen går snabbt framåt, så den här informationen kan vara föråldrad. Du bör kontrollera listfilen TODO och arkiven för <link linkend="mailing-lists" +>e-postlistorna</link +> för att ta reda på vilka nya funktioner som planeras. Delta gärna i ny konstruktion och implementering. </para> + +<para +>Det här är ett utkast som försöker ge dig en översikt av hur nya teknologier kommer att integreras i &arts;. Det täcker följande: </para> + +<itemizedlist> +<listitem +><para +>Hur gränssnitt fungerar.</para +></listitem> +<listitem +><para +>Avkodare - avkodning av mp3 eller wav-flöden till en form som gör att de kan användas som data.</para +></listitem> +<listitem +><para +>Video.</para +></listitem> +<listitem +><para +>Trådning.</para +></listitem> +<listitem +><para +>Synkronisering.</para +></listitem> +<listitem +><para +>Dynamisk utökning/maskering.</para +></listitem> +<listitem +><para +>Dynamisk sammansättning.</para +></listitem> +<listitem +><para +>&GUI;</para +></listitem> +<listitem +><para +>&MIDI;</para +></listitem> +</itemizedlist> + +<para +>Det här är pågående arbete. Det bör dock kunna ge grunden om du vill titta på ny teknologi i &arts;. Det bör ge dig en allmän idé om hur de här problemen kommer att attackeras. Korrigera gärna allt du ser här. </para> + +<para +>Saker som kommer att använda &arts;-teknologi (så var snäll och koordinera ansträngningarna): </para> + +<itemizedlist> +<listitem> +<para +><application +>K-telefon</application +> (röst via <acronym +>IP</acronym +>) </para> +</listitem> + +<listitem> +<para +>&noatun; (videospelare / ljudspelare) </para> +</listitem> + +<listitem> +<para +>&artscontrol; (styrprogram för ljudservern, och för mätare) </para> +</listitem> + +<listitem> +<para +><application +>Brahms</application +> (musiksequencer) </para> +</listitem> + +<listitem> +<para +><application +>Kaiman</application +> (&kde;2 mediaspelare - kmedia2-anpassad) </para> +</listitem> + +<listitem> +<para +><application +>mpglib</application +>/<application +>kmpg</application +> (<acronym +>mpg</acronym +> ljud- och videouppspelningsteknologi) </para> +</listitem> + +<listitem> +<para +><application +>SDL</application +> (direktmedialager för spel, som ännu inte påbörjats men som kan vara trevligt) </para> +</listitem> + +<listitem> +<para +><application +>Elektriska öron</application +> (upphovsmannen kontaktade mig - status okänd) </para> +</listitem> +</itemizedlist> + +<sect1 id="interfaces-how"> +<title +>Hur gränssnitt fungerar</title> + +<!-- I think this is now obsolete and documented elsewhere ? --> + +<para +>&MCOP;-gränssnitt är grunden för &arts;-konceptet. De är den nätverkstransparenta motsvarigheten till C++ klasser. Så snart det är möjligt bör du rikta in din konstruktion mot gränssnitt. Ett gränssnitt består av fyra delar: </para> + +<itemizedlist> +<listitem +><para +>Synkrona strömmar</para +></listitem> +<listitem +><para +>Asynkrona strömmar</para +></listitem> +<listitem +><para +>Metoder</para +></listitem> +<listitem +><para +>Egenskaper</para +></listitem> +</itemizedlist> + +<para +>De här kan blandas på vilket sätt du vill. Nya teknologier bör definieras med hjälp av gränssnitt. Läs avsnitten om asynkrona strömmar och synkrona strömmar, samt KMedia2-gränssnittet, som är bra exempel på hur sådana saker fungerar. </para> + +<para +>Gränssnitt specificeras i <literal role="extension" +>.idl</literal +>-kod och körs genom <command +>mcopidl</command +>-kompilatorn. Man härleder <classname +><replaceable +>Gränssnittsnamn</replaceable +>_impl</classname +> klassen för att implementera dem, och använder <function +>REGISTER_IMPLEMENTATION (Gränssnittsnamn_impl)</function +> för att infoga en objektimplementering i &MCOP;:s objektsystem. </para> + +</sect1> + +<sect1 id="codecs"> +<title +>Codec, dataavkodning</title> + +<para +>Kmedia2-gränssnittet låter dig bortse från att wav-filer, mp3-filer eller vad som helst består av dataflöden. Istället implementerar du bara metoder för att spela dem. </para> + +<para +>På så sätt kan du skriva en vågformsladdningsrutin på ett sätt så att du kan spela vågformsfiler (som PlayObject), men ingen annan kan använda din kod. </para> + +<para +>Asynkrona strömmar skulle vara alternativet. Man definierar ett gränssnitt som tillåter att datablock skickas in, och hämtas ut. Detta ser ut så här i &MCOP;: </para> + +<programlisting +>interface Codec { + in async byte stream indata; + out async byte stream outdata; +}; +</programlisting> + + +<para +>Avkodare kan förstås också ange egenskaper för att skicka ut ytterligare data, som formatinformation. </para> + +<programlisting +>interface ByteAudioCodec { + in async byte stream indata; + out async byte stream outdata; + readonly attribute samplingRate, bits, channels; +}; +</programlisting> + +<para +>Den här <interfacename +>ByteAudioCodec</interfacename +> kan till exempel anslutas till ett <interfacename +>ByteStreamToAudio</interfacename +>-objekt, för att skapa riktigt flytande ljud. </para> + +<para +>Andra typer av avkodare kan förstås innefatta att direkt skicka ut videodata, som </para> + +<programlisting +>interface VideoCodec { + in async byte stream indata; + out video stream outdata; /* observera: videoströmmar finns inte ännu */ +}; +</programlisting> + +<para +>Troligtvis bör ett avkodningskoncept användas istället för sättet <quote +>du vet hur det spelas upp med det gör inte jag</quote +> som till exempel <interfacename +>WavPlayObject</interfacename +> använder för närvarande. Någon måste dock sätta sig ner och experimentera lite innan ett programmeringsgränssnitt kan definieras. </para> + +</sect1> + +<sect1 id="video"> +<title +>Video</title> + +<para +>Min idé är att tillhandahålla video som asynkrona strömmar för någon inbyggd &MCOP;-datatyp som innehåller bilder. Den här datatypen har inte skapats än. Genom att göra detta, kan insticksprogram som hanterar video kopplas ihop på samma sätt som ljudinsticksprogram. </para> + +<para +>Det finns några saker som är viktiga att inte utelämna: </para> + +<itemizedlist> +<listitem> +<para +>Det finns <acronym +>RGB</acronym +> och <acronym +>YUV</acronym +> färgrymder. </para> +</listitem> +<listitem> +<para +>Formatet bör markeras i strömmen på något sätt. </para> +</listitem> +<listitem> +<para +>Synkronisering är viktig. </para> +</listitem> +</itemizedlist> + +<para +>Min idé är att lämna möjligheten att ändra implementeringen av <classname +>VideoFrame</classname +>-klassen öppen, så att den kan lagra grejor i ett delat minnessegment. Genom att göra detta kan till och med videoströmmar mellan olika processer bli möjligt utan alltför mycket problem. </para> + +<para +>För video är dock den vanliga situationen att alla saker är i samma process, från avkodningen till renderingen. </para> + +<para +>Jag har gjort en prototypimplementering av videoströmmar, som kan laddas ner <ulink url="http://space.twc.de/~stefan/kde/download/video-quickdraw.tar.gz" +>härifrån</ulink +>. Det här behöver integreras med &MCOP; efter några experiment. </para> + +<para +>En rederingskomponent som stöder XMITSHM (med <acronym +>RGB</acronym +> och <acronym +>YUV</acronym +>) bör tillhandahållas. Martin Vogt talade om för mig att han arbetar på en sådan. </para> + +</sect1> + +<sect1 id="threading"> +<title +>Trådning</title> + +<para +>För närvarande är &MCOP; helt och hållet en enda tråd. För video kanske vi inte längre kan komma undan trådar. Ok. Det finns några saker som ska hanteras med försiktighet: </para> + + +<itemizedlist> +<listitem +><para +>SmartWrappers - de är inte trådsäkra på grund av osäker referensräkning och liknande. </para> +</listitem> +<listitem> +<para +>Avsändaren / I/O - inte heller trådsäkra. </para> +</listitem> +</itemizedlist> + +<para +>Vad jag i alla fall kan tänka mig är att göra utvalda moduler trådsäkra, för både synkrona och asynkrona strömmar. På det här sättet kan man schemalägga signalflödet på två eller flera processorer, med ett flödessystem som känner till trådar. Det här borde också hjälpa en hel del med ljud med multiprocessorer. </para> + +<para +>Hur det skulle fungera: </para> + + +<itemizedlist> +<listitem> +<para +>Flödessystemet bestämmer vilka moduler som ska beräkna vad, dvs: </para> + <itemizedlist> + <listitem +><para +>videobilder (med metoden process_indata)</para +></listitem> + <listitem +><para +>synkrona ljudflöden (calculateBlock)</para +></listitem> + <listitem +><para +>andra asynkrona flöden, i huvudsak dataströmmar</para +></listitem> + </itemizedlist> +</listitem> +<listitem> +<para +>Modulerna kan beräkna de här sakerna i egna trådar. För ljud är det vettigt att återanvända trådar (t.ex. hantera det med fyra trådar om det finns fyra processorer, även om 100 moduler kör). För video- och datauppackning, kan det vara bekvämare att ha en blockerande implementering i en egen tråd, som synkroniseras med resten av &MCOP; med flödessystemet. </para> +</listitem> + +<listitem> +<para +>Moduler får inte använda &MCOP;-funktioner (som fjärranrop) medan trådade operationer pågår. </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="synchronization"> +<title +>Synkronisering</title> + +<para +>Video och &MIDI; (och ljud) kan kräva synkronisering. I grund och botten är det här tidsstämplar. Idén jag har är att bifoga tidsstämplar till de asynkrona strömmarna, genom att lägga till en tidsstämpel till varje paket. Om man skickar två videobilder, görs det helt enkelt som två paket (de är stora ändå), så att man kan ha två olika tidsstämplar. </para> + +<para +>Ljud ska ha underförstådda tidsstämplar, eftersom det är synkront. </para> + +</sect1> + +<sect1 id="dynamic-composition"> +<title +>Dynamisk sammansättning</title> + +<para +>Det bör vara möjligt att säga: En effekt FX består av de här enklare modulerna. FX bör se ut som en normal &MCOP;-modul (se maskering), men i själva verket bestå av andra moduler. </para> + +<para +>Det här krävs för aRts-byggaren. </para> + +</sect1> + +<sect1 id="gui"> +<title +>&GUI;</title> + +<para +>Alla komponenter i det grafiska gränssnittet kommer att vara &MCOP;-moduler. De bör ha egenskaper som storlek, etikett, färg, ... En <acronym +>RAD</acronym +>-byggare (aRts-byggaren) bör kunna sätta samman dem visuellt. </para> + +<para +>Det grafiska gränssnittet bör vara möjligt att spara genom att spara egenskaperna. </para> + +</sect1> + +<sect1 id="midi-stuff"> +<title +>&MIDI;</title> + +<para +>&MIDI;-grejorna kommer att implementeras som asynkrona strömmar. Det finns två alternativ, ett är att använda normala &MCOP;-strukturer för att definiera typerna och det andra är att introducera ytterligare egna typer. </para> + +<para +>Jag tror att normala strukturer kan räcka till, dvs något som: </para> + +<programlisting +>struct MidiEvent { + byte b1,b2,b3; + sequence<byte> sysex; +} +</programlisting> + +<para +>Asynkrona strömmar bör stöda egna flödestyper. </para> + +</sect1> + +</chapter> + + diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/glossary.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/glossary.docbook new file mode 100644 index 00000000000..076741e6bee --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/glossary.docbook @@ -0,0 +1,173 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE glossary PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<glossary id="glossary"> + +<glossentry id="gloss-alsa"> +<glossterm +><acronym +>ALSA</acronym +></glossterm> +<glossdef> +<para +>Advanced &Linux; Sound Architecture. En ljudkortsdrivrutin för &Linux; som för närvarande inte ingår i standardkällkoden för kärnan. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-arts"> +<glossterm +>&arts;</glossterm> +<glossdef> +<para +>Analog realtidssynthesizer. Namnet på den multimediaarkitektur/bibliotek/verktygslåda som används av &kde;-projektet (observera den stora bokstaven) </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-bsd"> +<glossterm +><acronym +>BSD</acronym +></glossterm> +<glossdef> +<para +>Berkeley Software Distribution. Anger här ett av flera olika &UNIX;-kompatibla operativsystem som har sitt ursprung i <acronym +>BSD</acronym +> &UNIX;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-corba"> +<glossterm +><acronym +>CORBA</acronym +></glossterm> +<glossdef> +<para +>Common Object Request Broker Architecture. En standard för att implementera objektorienterad fjärrkörning. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-cvs"> +<glossterm +><acronym +>CVS</acronym +></glossterm> +<glossdef> +<para +>Concurrent Versions System. Ett konfigurationshanteringssystem för programvara som används av många programvaruprojekt inklusive &kde; och &arts;. </para> +</glossdef> +</glossentry> + +<glossentry id="glos-fft"> +<glossterm +><acronym +>FFT</acronym +></glossterm> +<glossdef> +<para +>Fast Fourier Transform. En algoritm för att konvertera data från tidsdomänen till frekvensdomänen, som ofta används i signalbehandling. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-full-duplex"> +<glossterm +>Full duplex</glossterm> +<glossdef> +<para +>Möjligheten hos ett ljudkort att samtidigt spela in och spela upp ljud. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gpl"> +<glossterm +><acronym +>GPL</acronym +></glossterm> +<glossdef> +<para +><acronym +>GNU</acronym +> General Public License. En programvarulicens som skapats av Free Software Foundation, som definierar villkoren för att ge ut fri programvara. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gui"> +<glossterm +>&GUI;</glossterm> +<glossdef> +<para +>Grafiskt användargränssnitt </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-idl"> +<glossterm +><acronym +>IDL</acronym +></glossterm> +<glossdef> +<para +>Interface Definition Language. Ett format oberoende av programmeringsspråk för att definiera gränssnitt (metoder och data). </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-kde"> +<glossterm +>&kde;</glossterm> +<glossdef> +<para +>K skrivbordsmiljö. Ett projekt för att utveckla en fri grafisk skrivbordsmiljö för &UNIX;-kompatibla system. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-lgpl"> +<glossterm +><acronym +>LGPL</acronym +></glossterm> +<glossdef> +<para +><acronym +>GNU</acronym +> Lesser General Public License. En programvarulicens som skapats av Free Software Foundation, som definierar villkoren för att ge ut fri programvara, med mindre begränsningar än <acronym +>GPL</acronym +> som ofta används för programvarubibliotek. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-mcop"> +<glossterm +>&MCOP;</glossterm> +<glossdef> +<para +>Multimedia COmmunication Protocol. Protokollet som används för kommunikation mellan &arts; programmoduler, som har likheter med <acronym +>CORBA</acronym +> men är enklare och optimerat för multimedia. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-midi"> +<glossterm +>&MIDI;</glossterm> +<glossdef> +<para +>Musical Instrument Digital Interface. Ett standardprotokoll för kommunikation mellan elektroniska musikinstrument, anger också ofta filformatet som används för att lagra &MIDI;-kommandon. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-oss"> +<glossterm +><acronym +>OSS</acronym +></glossterm> +<glossdef> +<para +>Open Sound System. Ljuddrivrutinerna som ingår i &Linux; kärna (ibland benämnda <acronym +>OSS</acronym +>/Free) eller en kommersiell version som säljs av 4Front Technologies. </para> +</glossdef> +</glossentry> + +</glossary> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/gui.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/gui.docbook new file mode 100644 index 00000000000..b769c161b6b --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/gui.docbook @@ -0,0 +1,29 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<!-- +<chapter id="gui-elements"> +<title +>&GUI; Elements</title> + +<sect1 id="gui-introduction"> +<title +>Introduction</title> + +</sect1> + +<sect1 id="parents"> +<title +>Parents</title> + +</sect1> + +<sect1 id="mixers"> +<title +>Mixers</title> + +</sect1> +</chapter> +--> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/helping.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/helping.docbook new file mode 100644 index 00000000000..a02e0e26794 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/helping.docbook @@ -0,0 +1,237 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="contributing"> +<title +>Att bidra till &arts;</title> + +<sect1 id="how-to-help"> +<title +>Hur du kan hjälpa till</title> + +<para +>&arts;-projektet behöver hjälp från utvecklare att att lägga till stöd för &arts; i befintliga multimediaprogram, skriva nya multimediaprogram och förbättra &arts; möjligheter. Du behöver dock inte vara en utvecklare för att bidra. Vi behöver också hjälp från testare för att skicka in felrapporter, översättare för att översätta programtexten och dokumentationen till andra språk, grafiker för att skapa ikoner (särskilt för <application +>artsbuilder</application +> moduler), musiker för att skapa &arts;-modulexempel, och författare för att skriva eller granska dokumentation. </para> +</sect1> + +<sect1 id="mailing-lists"> +<title +>E-postlistor</title> + +<para +>De flesta utvecklingsdiskussioner om &arts; äger rum via två e-postlistor. Det här är stället att diskutera nya funktioner och implementeringsidéer och att fråga efter hjälp med problem. </para> + +<para +>&kde;:s multimedia e-postlista är till för generella &kde; multimediafrågor inklusive &arts; samt multimediaprogram som &noatun; och &aktion;. Du kan prenumerera från webbsidan på <ulink url="http://www.kde.org/mailinglists.html" +> http://www.kde.org/mailinglists.html</ulink +> eller skicka e-post med rubriken <userinput +>subscribe <replaceable +>din-e-postadress</replaceable +></userinput +> till <email +>kde-multimedia-request@kde.org</email +>. Listan finns också arkiverad på <ulink url="http://lists.kde.org" +> http://lists.kde.org</ulink +>. </para> + +<para +>E-postlistan för &arts; är till för frågor som enbart rör &arts;, inklusive användning av &arts; utanför &kde;. För att prenumerera, skicka e-post till <email +>arts-request@space.twc.de</email +> med meddelandetexten <userinput +>subscribe <replaceable +>din-epostadress</replaceable +></userinput +>. Listan arkiveras på <ulink url="http://space.twc.de/~stefan/arts-archive" +> http://space.twc.de/~stefan/arts-archive</ulink +>. </para> + +</sect1> + +<sect1 id="coding-standards"> +<title +>Kodningsstandarder</title> + +<para +>För att åstadkomma en konsekvent läsning av all källkod, är det viktigt att hålla kodningsstilen likadan i hela &arts; källkod. Var snäll och försök skriva/formattera din källkod i enlighet med detta, även om du bara skriver en modul, eftersom det gör det enklare för olika personer att underhålla källkodsträdet, och lättare att kopiera delar av källkoden från en fil till en annan. </para> + +<variablelist> +<varlistentry> +<term +>Namngivning av medlemsfunktioner</term> +<listitem> +<para +>&Qt;/&Java;-stil. Det här betyder att stora bokstäver används för att markera nya ord, och att första bokstaven alltid är liten. Inga understreck. </para> +<para +>Det här betyder till exempel:</para> + +<programlisting +>createStructureDesc() + updateWidget(); + start(); </programlisting> + +</listitem> +</varlistentry> + +<varlistentry> +<term +>Klassmedlemmar</term> +<listitem> +<para +>Klassmedlemmar har inte stora bokstäver, som till exempel menubar eller button. </para> + +<para +>När det finns funktioner som används för åtkomst, ska standarden som används vara enligt &MCOP;-sättet, dvs. om det finns en "long" medlem <function +>foo</function +>, som inte ska vara synlig, så skapas: </para> + +<programlisting +>foo(long new_value); + long foo(); </programlisting> + +<para +>funktioner för att hämta eller sätta ett värde. I detta fall, ska det riktiga värdet för <function +>foo</function +> lagras i <returnvalue +>_foo</returnvalue +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Klassnamn</term> +<listitem> +<para +>Alla klasser ska ha stora bokstäver för varje ord, vilket betyder <classname +>ModuleView</classname +>, <classname +>SynthModule</classname +>. Alla klasser som hör till biblioteken ska använda &arts;-namnrymden, som <classname +>Arts::Soundserver</classname +>. </para> +<para +>Implementeringar av &MCOP;-klasser ska döpas <classname +>Class_impl</classname +>, som till exempel <classname +>SoundServer_impl</classname +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Parametrar</term> +<listitem> +<para +>Parametrar har alltid små bokstäver. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Lokala variabler</term> +<listitem> +<para +>Lokala variabler har alltid små bokstäver, och kan ha namn som <varname +>i</varname +>, <varname +>p</varname +>, <varname +>x</varname +> etc. om det passar. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Tabulatorbredd (skiftbredd)</term> +<listitem> +<para +>Ett tabulatortecken är lika mycket som fyra blanktecken. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Mellanslag i uttryck</term> +<listitem> +<para +>Normalt behöver du inte använda mellanslag i uttryck. Du kan i alla fall använda dem mellan operatorer och deras operander. Om du skriver ett mellanslag före en operator (t.ex. +), måste du också skriva ett mellanslag efter operatorn. Det enda undantaget från detta är uttryck som liknar listor (med ,), där du bara ska använda ett mellanslag efter ",", men inte före. Det är också ok att utelämna mellanslag här. </para> +<para +>Följande exempel demonstrerar bra användning av mellanslag: </para> +<programlisting +>{ + int a,b; + int c, d, e; + int f = 4; + + a=b=c=d+e+f; + a = b = c = d + e + f; + + if(a == 4) { + a = b = c = (d+e)/2; + } + + while(b<3) + c--; + + arts_debug("%d\n", c); +} +</programlisting> +<para +>Följande exempel demonstrerar hur man <emphasis +>inte</emphasis +> ska använda mellanslag. För funktionsanrop, efter if, while, for, switch och så vidare, skrivs inget mellanslag. </para> +<programlisting +>{ + // DÅLIGT: Om du skriver en lista, skriv bara mellanslag efter "," + int a , b , c , d , e , f; + + // DÅLIGT: inte symmetrisk användning av mellanslag för = operatorn + a= 5; + + // DÅLIGT: Om det anses vara en funktion, och inte följs av ett mellanslag + if (a == 5) { + } + + // DÅLIGT: skriv inte ett mellanslag efter while + while (a--) + b++; + + // DÅLIGT: Funktionsnamn följs inte av ett mellanslag + arts_debug ("%d\n", c); + + // DÅLIGT: inte heller medlemsnamn + Arts::Object o = Arts::Object::null (); +} +</programlisting> +</listitem> +</varlistentry> + + +<varlistentry> +<term +>Namngivning av källkodsfiler</term> +<listitem> +<para +>Källkodsfiler ska inte ha några stora bokstäver i namnet. De ska ha samma namn som klassen om de implementerar en enda klass. Deras filändelse ska vara <literal role="extension" +>.cc</literal +> om de innehåller &Qt;- och grafikoberoende kod, och <literal role="extension" +>.cpp</literal +> om de innehåller &Qt;- och grafikberoende kod. Implementeringsfiler för gränssnitt ska benämnas <filename +><replaceable +>foo</replaceable +>_impl</filename +>, om Foo är gränssnittets namn. </para> + +<para +>&IDL;-filer ska benämnas på ett beskrivande sätt med tanke på den samling gränssnitt de innehåller, också helt med små bokstäver. I synnerhet är det inte bra att benämna en &IDL;-fil som klassen själv, eftersom .mcopclass-handlaren och typinfoposterna då kommer att kollidera. </para> +</listitem> +</varlistentry> +</variablelist> +</sect1> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.am b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.am new file mode 100644 index 00000000000..05163865c86 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = sv +SUBDIRS = $(AUTODIRS) +KDE_DOCS = artsbuilder/images +KDE_MANS = AUTO diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.in b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.in new file mode 100644 index 00000000000..249229ed9b2 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Makefile.in @@ -0,0 +1,613 @@ +# Makefile.in generated by automake 1.10.1 from Makefile.am. +# KDE tags expanded automatically by am_edit - $Revision: 483858 $ +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +subdir = docs/kdemultimedia/artsbuilder/images +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ + $(top_srcdir)/configure.in +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +SOURCES = +DIST_SOURCES = +#>- RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ +#>- html-recursive info-recursive install-data-recursive \ +#>- install-dvi-recursive install-exec-recursive \ +#>- install-html-recursive install-info-recursive \ +#>- install-pdf-recursive install-ps-recursive install-recursive \ +#>- installcheck-recursive installdirs-recursive pdf-recursive \ +#>- ps-recursive uninstall-recursive +#>+ 7 +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive nmcheck-recursive bcheck-recursive +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +#>- DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +#>+ 1 +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) $(KDE_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +ARTSCCONFIG = @ARTSCCONFIG@ +AUTOCONF = @AUTOCONF@ +AUTODIRS = @AUTODIRS@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CONF_FILES = @CONF_FILES@ +CYGPATH_W = @CYGPATH_W@ +DCOPIDL = @DCOPIDL@ +DCOPIDL2CPP = @DCOPIDL2CPP@ +DCOPIDLNG = @DCOPIDLNG@ +DCOP_DEPENDENCIES = @DCOP_DEPENDENCIES@ +DEFS = @DEFS@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +GMSGFMT = @GMSGFMT@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +KCFG_DEPENDENCIES = @KCFG_DEPENDENCIES@ +KCONFIG_COMPILER = @KCONFIG_COMPILER@ +KDECONFIG = @KDECONFIG@ +KDE_EXTRA_RPATH = @KDE_EXTRA_RPATH@ +KDE_RPATH = @KDE_RPATH@ +KDE_XSL_STYLESHEET = @KDE_XSL_STYLESHEET@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MAKEKDEWIDGETS = @MAKEKDEWIDGETS@ +MCOPIDL = @MCOPIDL@ +MEINPROC = @MEINPROC@ +MKDIR_P = @MKDIR_P@ +MSGFMT = @MSGFMT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TOPSUBDIRS = @TOPSUBDIRS@ +VERSION = @VERSION@ +XGETTEXT = @XGETTEXT@ +XMLLINT = @XMLLINT@ +X_RPATH = @X_RPATH@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +am__leading_dot = @am__leading_dot@ +am__tar = @am__tar@ +am__untar = @am__untar@ +#>- bindir = @bindir@ +#>+ 2 +DEPDIR = .deps +bindir = @bindir@ +build_alias = @build_alias@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host_alias = @host_alias@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +kde_appsdir = @kde_appsdir@ +kde_bindir = @kde_bindir@ +kde_confdir = @kde_confdir@ +kde_datadir = @kde_datadir@ +kde_htmldir = @kde_htmldir@ +kde_icondir = @kde_icondir@ +kde_kcfgdir = @kde_kcfgdir@ +kde_libs_htmldir = @kde_libs_htmldir@ +kde_libs_prefix = @kde_libs_prefix@ +kde_locale = @kde_locale@ +kde_mimedir = @kde_mimedir@ +kde_moduledir = @kde_moduledir@ +kde_servicesdir = @kde_servicesdir@ +kde_servicetypesdir = @kde_servicetypesdir@ +kde_sounddir = @kde_sounddir@ +kde_styledir = @kde_styledir@ +kde_templatesdir = @kde_templatesdir@ +kde_wallpaperdir = @kde_wallpaperdir@ +kde_widgetdir = @kde_widgetdir@ +kdeinitdir = @kdeinitdir@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +xdg_appsdir = @xdg_appsdir@ +xdg_directorydir = @xdg_directorydir@ +xdg_menudir = @xdg_menudir@ +KDE_LANG = sv +#>- SUBDIRS = $(AUTODIRS) +#>+ 1 +SUBDIRS =. +KDE_DOCS = artsbuilder/images +KDE_MANS = AUTO +#>- all: all-recursive +#>+ 1 +all: docs-am all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) +#>- @for dep in $?; do \ +#>- case '$(am__configure_deps)' in \ +#>- *$$dep*) \ +#>- cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ +#>- && exit 0; \ +#>- exit 1;; \ +#>- esac; \ +#>- done; \ +#>- echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile'; \ +#>- cd $(top_srcdir) && \ +#>- $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile +#>+ 12 + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/kdemultimedia/artsbuilder/images/Makefile.in +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. +$(RECURSIVE_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +$(RECURSIVE_CLEAN_TARGETS): + @failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + rev=''; for subdir in $$list; do \ + if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ + fi; \ + done; \ + rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +#>- distdir: $(DISTFILES) +#>+ 1 +distdir: distdir-nls $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done + list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + distdir=`$(am__cd) $(distdir) && pwd`; \ + top_distdir=`$(am__cd) $(top_distdir) && pwd`; \ + (cd $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$top_distdir" \ + distdir="$$distdir/$$subdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +#>- uninstall: uninstall-recursive +#>+ 1 +uninstall: uninstall-nls uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +#>- clean: clean-recursive +#>+ 1 +clean: kde-rpo-clean clean-recursive + +#>- clean-am: clean-generic mostlyclean-am +#>+ 1 +clean-am: clean-bcheck clean-generic mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +info: info-recursive + +info-am: + +#>- install-data-am: +#>+ 1 +install-data-am: install-nls + +install-dvi: install-dvi-recursive + +install-exec-am: + +install-html: install-html-recursive + +install-info: install-info-recursive + +install-man: + +install-pdf: install-pdf-recursive + +install-ps: install-ps-recursive + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) install-am \ + install-strip + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am check check-am clean clean-generic ctags \ + ctags-recursive distclean distclean-generic distclean-tags \ + distdir dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic pdf pdf-am ps ps-am tags \ + tags-recursive uninstall uninstall-am + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: + +#>+ 2 +KDE_DIST=Synth_AMAN_PLAY.png Synth_CAPTURE.png Synth_NOISE.png Synth_MOOG_VCF.png Synth_MULTI_ADD.png Synth_PITCH_SHIFT.png Synth_FX_CFLANGER.png Synth_DATA.png Synth_MIDI_TEST.png Synth_RECORD.png Synth_AMAN_RECORD.png Synth_BRICKWALL_LIMITER.png Synth_WAVE_PULSE.png Makefile.in Synth_FREEVERB.png Synth_TREMOLO.png Makefile.am Synth_WAVE_SOFTSAW.png + +#>+ 2 +docs-am: Synth_FX_CFLANGER.png Synth_BRICKWALL_LIMITER.png Synth_DATA.png Synth_TREMOLO.png Synth_WAVE_PULSE.png Synth_MIDI_TEST.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_AMAN_PLAY.png Synth_PITCH_SHIFT.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_MOOG_VCF.png Synth_NOISE.png + +#>+ 13 +install-nls: + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/images + @for base in Synth_FX_CFLANGER.png Synth_BRICKWALL_LIMITER.png Synth_DATA.png Synth_TREMOLO.png Synth_WAVE_PULSE.png Synth_MIDI_TEST.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_AMAN_PLAY.png Synth_PITCH_SHIFT.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_MOOG_VCF.png Synth_NOISE.png ; do \ + echo $(INSTALL_DATA) $$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/images/$$base ;\ + $(INSTALL_DATA) $(srcdir)/$$base $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/images/$$base ;\ + done + +uninstall-nls: + for base in Synth_FX_CFLANGER.png Synth_BRICKWALL_LIMITER.png Synth_DATA.png Synth_TREMOLO.png Synth_WAVE_PULSE.png Synth_MIDI_TEST.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_AMAN_PLAY.png Synth_PITCH_SHIFT.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_MOOG_VCF.png Synth_NOISE.png ; do \ + rm -f $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder/images/$$base ;\ + done + + +#>+ 5 +distdir-nls: + for file in Synth_FX_CFLANGER.png Synth_BRICKWALL_LIMITER.png Synth_DATA.png Synth_TREMOLO.png Synth_WAVE_PULSE.png Synth_MIDI_TEST.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_AMAN_PLAY.png Synth_PITCH_SHIFT.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_MOOG_VCF.png Synth_NOISE.png ; do \ + cp $(srcdir)/$$file $(distdir); \ + done + +#>+ 15 +force-reedit: + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/kdemultimedia/artsbuilder/images/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/kdemultimedia/artsbuilder/images/Makefile.in + + +#>+ 21 +clean-bcheck: + rm -f *.bchecktest.cc *.bchecktest.cc.class a.out + +bcheck: bcheck-recursive + +bcheck-am: + @for i in ; do \ + if test $(srcdir)/$$i -nt $$i.bchecktest.cc; then \ + echo "int main() {return 0;}" > $$i.bchecktest.cc ; \ + echo "#include \"$$i\"" >> $$i.bchecktest.cc ; \ + echo "$$i"; \ + if ! $(CXX) $(DEFS) -I. -I$(srcdir) -I$(top_builddir) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(KDE_CXXFLAGS) --dump-class-hierarchy -c $$i.bchecktest.cc; then \ + rm -f $$i.bchecktest.cc; exit 1; \ + fi ; \ + echo "" >> $$i.bchecktest.cc.class; \ + perl $(top_srcdir)/admin/bcheck.pl $$i.bchecktest.cc.class || { rm -f $$i.bchecktest.cc; exit 1; }; \ + rm -f a.out; \ + fi ; \ + done + + +#>+ 3 +final: + $(MAKE) all-am + +#>+ 3 +final-install: + $(MAKE) install-am + +#>+ 3 +no-final: + $(MAKE) all-am + +#>+ 3 +no-final-install: + $(MAKE) install-am + +#>+ 3 +kde-rpo-clean: + -rm -f *.rpo + +#>+ 3 +nmcheck: +nmcheck-am: nmcheck diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png Binary files differnew file mode 100644 index 00000000000..19716d76094 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png Binary files differnew file mode 100644 index 00000000000..367f1b09d34 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png Binary files differnew file mode 100644 index 00000000000..2b5d6839989 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_CAPTURE.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_CAPTURE.png Binary files differnew file mode 100644 index 00000000000..2360a709061 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_CAPTURE.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_DATA.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_DATA.png Binary files differnew file mode 100644 index 00000000000..749d751d434 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_DATA.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FREEVERB.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FREEVERB.png Binary files differnew file mode 100644 index 00000000000..a0737838ac9 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FREEVERB.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png Binary files differnew file mode 100644 index 00000000000..edac1e438f1 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png Binary files differnew file mode 100644 index 00000000000..03ea8fdf98a --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png Binary files differnew file mode 100644 index 00000000000..7e5da9a6e58 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png Binary files differnew file mode 100644 index 00000000000..f20e7f35fcd --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_NOISE.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_NOISE.png Binary files differnew file mode 100644 index 00000000000..bf20ef5bd80 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_NOISE.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png Binary files differnew file mode 100644 index 00000000000..1249ac4cd95 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_RECORD.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_RECORD.png Binary files differnew file mode 100644 index 00000000000..eee096d53c4 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_RECORD.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_TREMOLO.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_TREMOLO.png Binary files differnew file mode 100644 index 00000000000..f98830e75e1 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_TREMOLO.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png Binary files differnew file mode 100644 index 00000000000..e2a714bac11 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png Binary files differnew file mode 100644 index 00000000000..f3e920d3b89 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.cache.bz2 b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.cache.bz2 Binary files differnew file mode 100644 index 00000000000..9034ac71104 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.cache.bz2 diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.docbook new file mode 100644 index 00000000000..baa9134c276 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/index.docbook @@ -0,0 +1,415 @@ +<?xml version="1.0" ?> +<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [ + <!ENTITY kappname "&arts;"> + <!ENTITY tools SYSTEM "tools.docbook"> + <!ENTITY artsbuilder-doc SYSTEM "artsbuilder.docbook" +> + <!ENTITY detail SYSTEM "detail.docbook"> + <!ENTITY arts-midi SYSTEM "midi.docbook"> + <!ENTITY gui SYSTEM "gui.docbook"> + <!ENTITY mcop-ref SYSTEM "mcop.docbook"> + <!ENTITY arts-mcop SYSTEM "mcop.docbook"> + <!ENTITY apis SYSTEM "apis.docbook"> + <!ENTITY modules SYSTEM "modules.docbook"> + <!ENTITY porting SYSTEM "porting.docbook"> + <!ENTITY helping SYSTEM "helping.docbook"> + <!ENTITY future SYSTEM "future.docbook"> + <!ENTITY references SYSTEM "references.docbook"> + <!ENTITY arts-faq SYSTEM "faq.docbook"> + <!ENTITY arts-glossary SYSTEM "glossary.docbook"> + <!ENTITY digitalaudio SYSTEM "digitalaudio.docbook"> + <!ENTITY midiintro SYSTEM "midiintro.docbook"> + <!ENTITY MCOP "<acronym +>MCOP</acronym +>"> + <!ENTITY DCOP "<acronym +>DCOP</acronym +>"> + <!ENTITY MIDI "<acronym +>MIDI</acronym +>"> + <!ENTITY mcopidl "<application +>mcopidl</application +>"> + <!ENTITY IDL "<acronym +>IDL</acronym +>"> + <!ENTITY % Swedish "INCLUDE" +> <!-- change language only here --> + <!ENTITY % addindex "IGNORE"> +]> + +<book lang="&language;"> +<bookinfo> +<title +>Handbok &arts;</title> +<authorgroup> + +<author +><firstname +>Stefan</firstname +> <surname +>Westerfeld</surname +> <affiliation +> <address +><email +>stefan@space.twc.de</email +></address> +</affiliation> +</author> + +<author +><firstname +>Jeff</firstname +> <surname +>Tranter</surname +> <affiliation +> <address +><email +>tranter@kde.org</email +></address> +</affiliation> +</author> + +<othercredit role="translator" +> <firstname +>Stefan</firstname +> <surname +>Asserhäll</surname +> <affiliation +><address +><email +>stefan.asserhall@comhem.se</email +></address +></affiliation +> <contrib +>Översättare</contrib +></othercredit +> +</authorgroup> + +<copyright> +<year +>1999-2001</year> +<holder +>Stefan Westerfeld & Jeff Tranter</holder> +</copyright> +<legalnotice +>&FDLNotice;</legalnotice> + +<date +>2001-06-10</date> +<releaseinfo +>1.00.09</releaseinfo> + +<abstract +><para +>Den här handboken beskriver &arts;, den analoga realtidssynthesizern.</para> + +</abstract> + +<keywordset> +<keyword +>aRts</keyword> +<keyword +>artsbuilder</keyword> +<keyword +>synthesizer</keyword> +<keyword +>multimedia</keyword> +<keyword +>struktur</keyword> +<keyword +>musik</keyword> +<keyword +>ljud</keyword> +<keyword +>KDE</keyword> +</keywordset> +</bookinfo> + +<chapter id="introduction"> +<title +>Inledning</title> + +<sect1 id="what-is-arts"> +<title +>Vad är &arts;?</title> + +<para +>Den analoga realtidssynthesizern, eller &arts;, är ett modulärt system för att syntetisera ljud och musik på en digital dator. Med små byggblock, som kallas moduler, kan användaren lätt bygga komplexa verktyg för att behandla ljud. Moduler tillhandahåller typiskt funktioner som vågformsgeneratorer, filter, ljudeffekter, samt mixning och uppspelning av digitalt ljud med olika filformat.</para> + +<para +>Ljudservern &artsd; blandar ljud från olika källor i realtid, vilket låter flera ljudprogram transparent få delad tillgång till ljudhårdvaran.</para> + +<para +>Genom att använda &MCOP;, multimediakommunikationsprotokollet, kan multimediaprogram bli nätverkstransparenta, säkerhetsidentifierade, och fungera på flera plattformar med gränssnitt som definieras på ett språkoberoende sätt med &IDL;. Äldre program som inte stöder &arts; hanteras också. Som en central komponent i skrivbordsmiljön &kde; 2, tillhandahåller &arts; grunden för &kde;:s arkitektur för multimedia, och kommer att stöda fler mediatyper inklusive video i framtiden. Som &kde;, så kör &arts; på flera operativsystem, inklusive &Linux; och BSD-varianter. Det kan också användas oberoende av &kde;.</para> + +</sect1> + +<sect1 id="using-this-manual"> +<title +>Att använda den här handboken</title> + +<para +>Den här handboken är tänkt att ge fullständig dokumentation om &arts; för användare med olika kunskapsnivåer. Beroende på om du är en vardagsanvändare av multimediaprogram som kör med hjälp av &arts; eller en utvecklare av multimediaprogram, kan du välja att läsa handbokens avsnitt i olika ordning.</para> + +<para +>Vi föreslår att du först läser kapitlet <link linkend="installation" +>Ladda ner och bygga &arts;</link +> om du måste få &arts; installerad och körbar från början. Om du redan har ett fungerande system, troligen installerade tillsammans med din operativsystemdistribution, kan du välja att hoppa över det här avsnittet.</para> + +<para +>Därefter bör du läsa avsnitten i kapitlet <link linkend="arts-tools" +>&arts; verktyg</link +>, särskilt &artsd;, artscontrol;, &artsshell;, och &artsdsp;. Det här hjälper dig använda &arts; på det effektivaste sättet.</para> + +<para +>Om du är intresserad av att tränga in ytterligare i &arts; funktion, läs kapitlet om <link linkend="artsbuilder" +>aRts-byggaren</link +> och gå igenom handledningen. Det här bör ge dig en förståelse för &arts; kraftfulla möjligheter och de moduler som är tillgängliga att använda utan att behöva kunna programmera.</para> + +<para +>Om du vill lära dig mer om hur &arts; fungerar internt, antingen för att utveckla multimediaprogram eller för att utöka &arts; själv, läs några eller alla kapitlen om <link linkend="arts-in-detail" +>&arts; i detalj</link +>. Det här bör ge dig en förståelse för alla koncept som krävs för &arts;-programvaruutveckling.</para> + +<para +>Om du är särskilt intresserad av <acronym +>MIDI</acronym +>-funktionerna i &arts;, bör du läsa kapitlet om <link linkend="midi" +>&MIDI;</link +>.</para> + +<!-- TODO +<para +>To learn more about the &arts; graphical elements, either as an advanced +user of artsbuilder or to create new elements, read the section on <link +linkend="gui-elements" +><acronym +>GUI</acronym +> Elements</link +>.</para> +--> + +<para +>Om du vill utveckla multimediaprogram som använder &arts;, beskrivs de olika programvarugränssnitten (<acronym +>API</acronym +>) detaljerat i kapitlet <link linkend="arts-apis" +>&arts; programvarugränssnitt</link +>.</para> + +<para +>Om du vill utöka &arts; genom att skapa nya moduler, läs kapitlet <link linkend="arts-modules" +>&arts;-moduler</link +>.</para> + +<para +>Om du ändrar ett befintligt program för att köra ihop med &arts;, läs kapitlet <link linkend="porting" +>Ändra program för att passa &arts;</link +>.</para> + +<para +>Du kan också ta reda på hur du kan hjälpa till och bidra till &arts;-projektet i kapitlet <link linkend="contributing" +>Bidra till &arts;</link +>, läsa om kommande utveckling av &arts; i kapitlet <link linkend="future-work" +>Framtida arbete</link +>, och hitta länkar till mer information i avsnittet <link linkend="references" +>Referenser</link +>.</para> + +<para +>Vi har också avrundat handboken med en del ytterligare material, inklusive <link linkend="faq" +>svar på vanliga frågor</link +>, en <link linkend="contributors" +>lista på bidragsgivare</link +>, detaljer om &arts; <link linkend="copyright-and-licenses" +>copyright och licenser</link +>, och en del bakgrundsmaterial om <link linkend="intro-digital-audio" +>digitalljud</link +> och <link linkend="midi-introduction" +>&MIDI;</link +>. En <link linkend="glossary" +>gloslista</link +> ingår också.</para> + +<note> +<para +>Den här handboken är fortfarande i stor utsträckning pågående arbete. Du får gärna bidra genom att skriva delar av den, men om du vill göra det, kontakta först Jeff Tranter <email +>tranter@kde.org</email +> eller Stefan Westerfeld <email +>stefan@space.twc.de</email +> för att undvika dubbelarbete. </para> +</note> + +</sect1> + +<sect1 id="history"> +<title +>Historik</title> + +<para +>Mot slutet av 1997 började Stefan Westerfeld arbeta med ett modulärt realtidssystem för ljudsyntes. Koden kördes ursprungligen på ett PowerPC-system med &AIX;. Den första implementeringen var mycket enkel, men stödde ett flödessystem med fullständig funktion som kunde göra sådana saker som spela MP3-filer och skicka data genom ljudeffektmoduler. </para> + + +<para +>Nästa steg var att implementera ett grafiskt gränssnitt, så att moduler kunde manipuleras grafiskt. Stefan hade en del god erfarenhet av att använda &kde;, så därför valdes &kde; som den grafiska verktygslådan, (med vetskap om att det kunde bli nödvändigt att göra en version med GNOME/Gtk+ också) och det här gjorde att &Linux; senare valdes som den huvudsakliga utvecklingsplattformen. Projektet, som ursprungligen hette <application +>ksynth</application +>, döptes om till &arts; och utvecklingstakten ökade. Vid det här laget var projektet nästan komplett, med ett <acronym +>CORBA</acronym +>-baserat protokoll, dussintals moduler, ett grafiskt modulredigeringsverktyg, C och C++ gränssnitt, dokumentation, verktyg och en e-postlista och webbsida med en liten grupp utvecklare. Projektet hade kommit en bra bit på vägen efter bara något mer än ett års utveckling.</para> + +<para +>När &kde;-gruppen började planera för &kde; 2.0, blev det klart att &kde; behövde en kraftfullare infrastruktur för ljud och andra mediatyper. Beslutet togs att anpassa &arts;, eftersom det var ett steg i rätt riktning med en beprövad arkitektur. En ny stor utvecklingsansträngning gjordes för den här nya versionen av &arts;, framförallt utbytet av <acronym +>CORBA</acronym +>-koden mot ett helt nytt subsystem, &MCOP;, optimerat för multimedia. Version 0.4 av &arts; ingick i utgåva 2.0 av &kde;.</para> + +<para +>Arbetet med &arts; forsätter, för att förbättra prestanda och lägga till nya funktioner. Observera att även om &arts; nu är en central komponent i &kde;, kan den användas utan &kde;, och används också av program som går utanför traditionell multimedia. Projektet har skapat visst intresse från GNOME-gruppen, som öppnar en möjlighet att det i framtiden kan bli standardarkitekturen för multimedia på &UNIX; skrivbordssystem.</para> + +</sect1> + +</chapter> + +&tools; +&artsbuilder-doc; +&detail; +&arts-midi; +&gui; +&mcop-ref; +&apis; +&modules; +&porting; +&helping; +&future; +&references; +&arts-faq; + +<chapter id="copyright-and-licenses"> + +<title +>&arts; Copyright och licens</title> + +<para +>&arts; programvara copyright 1998-2001 Stefan Westerfeld <email +>stefan@space.twc.de</email +></para> + +<para +><anchor id="contributors"/> Dokumentation copyright 1999-2001 Stefan Westerfeld <email +>stefan@space.twc.de</email +> och Jeff Tranter <email +>tranter@kde.org</email +>. </para> +<para +>Översättning Stefan Asserhäll <email +>stefan.asserhall@comhem.se</email +></para +> +&underFDL; <para +>Alla bibliotek som ingår i &arts; licensieras under villkoren i <acronym +>GNU</acronym +> Lesser General Public license. En överväldigande majoritet av koden i &arts; finns i biblioteken, inklusive hela <acronym +>MCOP</acronym +> och ArtsFlow. Det här tillåter att biblioteken används för program som inte är fri eller öppen programvara om så önskas. </para> + +<para +>Det finns ett fåtal program (som <application +>artsd</application +>), som ges ut under villkoren i <acronym +>GNU</acronym +> General Public License. Eftersom det har funnits olika åsikter om det är tillåtet eller inte att länka <acronym +>GPL</acronym +>-program med &Qt;, har jag också lagt till en uttrycklig anmärkning som tillåter det, som ett tillägg till <acronym +>GPL</acronym +>: tillåtelse ges också att länka det här programmet med &Qt;-biblioteket, där &Qt; behandlas som ett bibliotek som normalt följer med operativsystemets kärna, vare sig detta är fallet eller inte.</para> + +</chapter> + +<appendix id="installation"> +<title +>Installera &arts;</title> + +<para +>För att kunna använda &arts; måste du naturligtvis ha det installerat och köra det på systemet. Det finns två metoder att åstadkomma detta, som beskrivs i de följande avsnitten. </para> + +<sect1 id="binary-install"> +<title +>Installera en färdigkompilerad binärutgåva</title> + +<para +>Det snabbaste och enklaste sättet att få &arts; körklart är att installera färdigkompilerade binärpaket för systemet. De flesta nyare &Linux;-distributioner innehåller &kde;, och om det är &kde; 2.0 eller senare finns &arts; med. Om &kde; inte följer med installationen, kan det finnas tillgängligt för nerladdning från din operativsystemleverantör. Som ett alternativ kan det finnas tillgängligt från tredje part. Försäkra dig om att du använder paket som passar ihop med ditt operativsystem. </para> + +<para +>En grundläggande installation av &kde; innehåller ljudservern, som låter de flesta program spela upp ljud. Om du vill ha hela uppsättningen med multimediaverktyg och program behöver du troligen installera ytterligare valfria paket. </para> + +<para +>Nackdelen med att använda färdigkompilerade binärfiler är att de kanske inte innehåller den senaste versionen av &arts;. Det här är särskilt troligt om de tillhandahålls på CD-ROM, eftersom utvecklingstakten för &arts; och &kde; är sådan att CD-ROM utgåvor oftast inte kan hålla samma takt. Du kan också råka ut för att färdigkompilerade binärpaket inte är tillgängliga, om du har en mindre vanlig arkitektur eller operativsystemdistribution, och du måste därför använda den andra metoden. </para> + +</sect1> + +<sect1 id="source-install"> +<title +>Bygga från källkod</title> + +<para +>Även om det tar tid, är det mest flexibla sättet att bygga &arts; att själv kompilera det från källkod. Det här försäkrar dig om att du har en version som är optimalt kompilerad för din systemuppsättning och låter dig bygga den senaste versionen. </para> + +<para +>Här har du två alternativ, du kan antingen installera den senaste stabila versionen som ingår i &kde; eller du kan skaffa den senaste (men kanske instabila) versionen direkt från &kde;-projektets <acronym +>CVS</acronym +>-arkiv. De flesta användare som inte utvecklar med &arts; bör använda den stabila versionen. Du kan ladda ner den från <ulink url="ftp://ftp.kde.org" +>ftp://ftp.kde.org</ulink +> eller en av de många spegelplatserna. Om du redan utvecklar aktivt med &arts; vill du troligen använda <acronym +>CVS</acronym +>-versionen. Om du vill använda aRts utan KDE, kan du ladda ner en självständig utvecklingsversion från <ulink url="http://space.twc.de/~stefan/kde/arts-snapshot-doc.html" +> http://space.twc.de/~stefan/kde/arts-snapshot-doc.html</ulink +>. </para> + +<para +>Om du bygger från <acronym +>CVS</acronym +>, observera att vissa komponenter i &arts; (dvs. de grundläggande centrala komponenterna inklusive ljudservern) finns i <acronym +>CVS</acronym +>-modulen kdelibs, medan ytterligare komponenter (t.ex. <application +>artsbuilder</application +>) ingår i kdemultimedia. Det här kan ändras i framtiden. Du kan också hitta en version i modulen kmusic, det är den gamla versionen (före &kde; 2.0) som nu är föråldrad. </para> + +<para +>Kraven för att bygga &arts; är i huvudsak likadana som för &kde;. Konfigurationsskripten bör upptäcka systeminställningarna och ange om några nödvändiga komponenter saknas. Försäkra dig om att du har en fungerande ljuddrivrutin på systemet (antingen <acronym +>OSS</acronym +>/Free drivrutinen i kärnan, <acronym +>OSS</acronym +>-drivrutinen från 4Front Technologies, eller en <acronym +>ALSA</acronym +>-drivrutin med <acronym +>OSS</acronym +>-stöd). </para> + +<para +>Mer information om att ladda ner och installera &kde; (inklusive &arts;) finns i <ulink url="http://www.kde.org/documentation/faq/index.html" +>&kde;:s vanliga frågor</ulink +>.</para> + +</sect1> + +</appendix> + +&digitalaudio; +&midiintro; +&arts-glossary; + +</book> +<!-- +Local Variables: +mode: sgml +sgml-omittag:nil +sgml-shorttag:t +sgml-namecase-general:t +sgml-general-insert-case:lower +sgml-minimize-attributes:nil +sgml-always-quote-attributes:t +sgml-indent-step:0 +sgml-indent-data:nil +End: +--> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/mcop.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/mcop.docbook new file mode 100644 index 00000000000..781ba93cc49 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/mcop.docbook @@ -0,0 +1,1972 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="mcop"> +<title +>&MCOP;: objektmodell och strömmar</title> + +<sect1 id="mcop-overview"> + +<title +>Översikt</title> + +<para +>&MCOP; är standarden som &arts; använder för: </para> + +<itemizedlist> +<listitem> +<para +>Kommunikation mellan objekt. </para> +</listitem> + +<listitem> +<para +>Nätverkstransparens. </para> +</listitem> + +<listitem> +<para +>Beskriva objektgränssnitt. </para> +</listitem> + +<listitem> +<para +>Språkoberoende. </para> +</listitem> +</itemizedlist> + +<para +>En viktig del av &MCOP; är <emphasis +>gränssnittsbeskrivningsspråket</emphasis +>, &IDL;, som används för att definiera många av &arts; programmeringsgränssnitt och andra gränssnitt på ett språkoberoende sätt. </para> + +<para +>För att använda ett &IDL;-gränssnitt från C++, kompileras det med &IDL; kompilatorn till C++ kod. När du implementerar ett gränssnitt, härleder du från stomklassen som &IDL; kompilatorn har skapat. När man använder ett gränssnitt gör man det med ett omgärdande skal. På det här sättet kan &MCOP; använda ett protokoll om objektet du pratar med inte är lokalt - man får nätverkstransparens. </para> + +<para +>Det här kapitlet är ämnat att beskriva de grundläggande funktionerna i objektmodellen som är resultatet av att använda &MCOP;, protokollet, hur &MCOP; används med C++ (språkbindning), och så vidare. </para> + +</sect1> + +<sect1 id="interfaces"> + +<title +>Gränssnitt och &IDL;</title> + +<para +>Mycket av den service som tillhandahålls av &arts;, som modulerna och ljudservern definieras i form av <acronym +>gränssnitt</acronym +>. Gränssnitt specificeras i ett programspråksoberoende format: &IDL;. </para> + +<para +>Det här tillåter att många av implementeringsdetaljerna som formatet på multimediadataflöden, nätverkstransparens och programspråksoberoende döljs för specifikationen av gränssnittet. Ett verktyg, &mcopidl;, översätter gränssnittsdefinitionen till ett specifikt programspråk (för närvarande stöds enbart C++). </para> + +<para +>Verktyget skapar en stomklass med all standardkod och grundläggande funktionalitet. Man härleder från den här klassen för att implementera de funktioner man vill ha. </para> + +<para +>Det &IDL; som används av &arts; liknar det som används av <acronym +>CORBA</acronym +> och <acronym +>DCOM</acronym +>. </para> + +<para +>&IDL;-filer kan innehålla: </para> + +<itemizedlist> +<listitem> +<para +>C-stil #include-direktiv för andra &IDL;-filer. </para> +</listitem> + +<listitem> +<para +>Definitioner av uppräkningstyper och struct-typer, som i C/C++. </para> +</listitem> + +<listitem> +<para +>Definitioner av gränssnitt. </para> +</listitem> +</itemizedlist> + +<para +>I &IDL; definieras gränssnitt på ett sätt som påminner mycket om en C++ klass eller C-struct, dock med vissa begränsningar. Som i C++, så kan gränssnitt vara underklasser till andra gränssnitt med arv. Gränssnittsdefinitioner kan innehålla tre saker: Strömmar, egenskaper och metoder. </para> + +<sect2 id="streams"> + +<title +>Strömmar</title> + +<para +>Strömmar definierar multimediadata, en av de viktigaste komponenterna i en modul. Strömmar definieras med följande format: </para> + +<para +>[ async ] in|out [ multi ] <replaceable +>typ</replaceable +> stream <replaceable +>namn</replaceable +> [ , <replaceable +>namn</replaceable +> ] ; </para> + +<para +>Strömmar har en definierad riktning i förhållande till modulen, som anges av de nödvändiga bestämningarna in eller out. Typargumentet definierar datatypen, som kan vara vilken som helst av typerna för egenskaper som beskrivs senare (alla stöds inte än). Många moduler använder strömtypen audio, som är ett alias för float eftersom det är det interna dataformatet för ljudströmmar. Flera strömmar av samma typ kan ingå i samma definition med namn separerade med kommatecken. </para> + +<para +>Strömmar är normalt synkrona, vilket betyder att de är kontinuerliga dataflöden med en konstant hastighet, som <acronym +>PCM</acronym +>-ljud. Bestämningen async anger en asynkron ström, som används för icke-kontinuerliga dataflöden. Det vanligaste exemplet på en asynkron ström är &MIDI;-meddelanden. </para> + +<para +>Nyckelordet multi, som bara är giltigt för indataströmmar, anger att gränssnittet stöder ett variabelt antal ingångar. Det här är användbart för att implementera enheter som en mixer som kan ta emot vilket antal indataströmmar som helst. </para> + +</sect2> +<sect2 id="attributes"> + +<title +>Egenskaper</title> + +<para +>Egenskaper är data som hör ihop med en instans av ett gränssnitt. De deklareras som medlemsvariabler i C++, och kan använda vilken som helst av de primitiva typerna boolean, byte, long, string, eller float. Du kan också använda egendefinierade struct- eller uppräkningstyper samt sekvenser av variabel storlek med syntaxen sekvens<typ>. Egenskaper kan valfritt markeras som skrivskyddade. </para> + +</sect2> +<sect2 id="methods"> + +<title +>Metoder</title> + +<para +>Som i C++, kan metoder definieras i gränssnitt. Metodparametrarna är begränsade till samma typer som egenskaperna. Nyckelordet oneway anger en metod som returnerar omedelbart och körs asynkront. </para> + +</sect2> + +<sect2 id="standardinterfaces"> + +<title +>Standardgränssnitt</title> + +<para +>Flera gränssnitt för standardmoduler är redan definierade åt dig i &arts;, som <interfacename +>StereoEffect</interfacename +>, och <interfacename +>SimpleSoundServer</interfacename +>. </para> + +</sect2> + +<sect2 id="example"> +<title +>Exempel</title> + +<para +>Ett enkelt exempel på en modul taget från &arts; är modulen med konstant fördröjning, som finns i filen <filename +>kdemultimedia/arts/modules/artsmodules.idl</filename +>. Gränssnittsdefinitionen anges nedan: </para> + +<programlisting +>interface Synth_CDELAY : SynthModule { + attribute float time; + in audio stream invalue; + out audio stream outvalue; +}; +</programlisting> + +<para +>Modulen ärver <interfacename +>SynthModule</interfacename +>. Det gränssnittet, som finns i <filename +>artsflow.idl</filename +>, definierar alla standardmetoder som implementeras i alla syntesmoduler. </para> + +<para +>CDELAY-effekten fördröjer ett stereoljudflöde med tidsvärdet som anges som en flyttalsparameter. Gränssnittsdefinitionen har ett attribut av typen float för att lagra fördröjningsvärdet. Det definierar två indata- och två utdataströmmar (typiskt för stereoeffekter). Inga metoder krävs förutom de ärvda. </para> + +</sect2> + +</sect1> + +<sect1 id="more-about-streams"> +<title +>Mer om strömmar</title> + +<para +>Det här avsnittet täcker en del ytterligare ämnesområden som hör ihop med strömmar. </para> + +<sect2 id="stream-types"> +<title +>Strömtyper</title> + +<para +>Det finns olika krav för hur en modul kan hantera flöden. För att illustrera detta, betrakta följande exempel: </para> + +<itemizedlist> +<listitem> +<para +>Skala en signal med en faktor två. </para> +</listitem> + +<listitem> +<para +>Utför frekvenskonvertering av samplingar. </para> +</listitem> + +<listitem> +<para +>Packa upp en runlength-kodad signal. </para> +</listitem> + +<listitem> +<para +>Läs &MIDI;-händelser från <filename class="devicefile" +>/dev/midi00</filename +> och infoga dem i en ström. </para> +</listitem +> +</itemizedlist> + +<para +>Det första fallet är det enklaste: när modulen tar emot 200 indatasamplingar producerar den 200 utdatasamplingar. Den producerar bara utdata när den får indata. </para> + +<para +>Det andra fallet producerar olika antal utdatasamplingar när den får 200 indatasamplingar. Det beror på vilken konvertering som utförs, men antalet är känt i förväg. </para> + +<para +>Det tredje fallet är ännu värre. Från utdata kan man inte ens gissa hur mycket data som skapas av 200 indatabyte (förmodligen mycket mer än 200 byte, men...). </para> + +<para +>Det sista fallet är en modul som aktiveras av sig själv, och ibland skapar data. </para> + +<para +>I &arts;s-0.3.4, hanterades bara strömmar av den första typen, och de flesta saker fungerade bra. Det här är troligen vad du behöver mest när du skriver moduler som behandlar ljud. Problemen med de andra, mer komplexa sorternas flöden, är att de är svåra att programmera, och att man inte behöver funktionerna för det mesta. Det här är orsaken vi gör detta med två olika sorters strömtyper: synkrona och asynkrona. </para> + +<para +>Synkrona strömmar har följande egenskaper: </para> + +<itemizedlist> +<listitem> +<para +>Moduler måste kunna beräkna data av vilken längd som helst, med tillräckligt mycket indata. </para> +</listitem> + +<listitem> +<para +>Alla strömmar har samma samplingsfrekvens. </para> +</listitem> + +<listitem> +<para +>Funktionen <function +>calculateBlock()</function +> anropas när tillräckligt med data är tillgängligt, och modulen kan lita på att pekarna anger data. </para> +</listitem +> + +<listitem> +<para +>Det finns ingen allokering eller avallokering att göra. </para> +</listitem> +</itemizedlist> + +<para +>Asynkrona strömmar, å andra sidan, beter sig så här: </para> + +<itemizedlist> +<listitem> +<para +>Moduler kan producera data ibland, eller med olika samplingsfrekvens, eller bara om de får indata från någon fil. De måste inte följa regeln <quote +>måste kunna hantera begäran av vilken storlek som helst</quote +>. </para> +</listitem> + +<listitem> +<para +>Asynkrona strömmar för en modul kan ha helt skilda samplingsfrekvenser. </para> +</listitem> + +<listitem> +<para +>Utgående strömmar: det finns särskilda funktioner för att allokera paket, att skicka paket och en valfri mekanism för att fråga efter data som talar om när mer data ska skapas. </para> +</listitem> + +<listitem> +<para +>Inkommande strömmar: ett anrop skickas när ett nytt paket tas emot. Man måste tala om när man är färdig med att behandla all data i det paketet, och detta får inte ske omedelbart (man kan tala om det när som helst senare, och om alla har behandlat ett paket, kommer det att frigöras/återanvändas). </para> +</listitem> +</itemizedlist> + +<para +>När strömmar deklareras, används nyckelordet <quote +>async</quote +> för att ange att strömmen ska vara asynkron. Så anta till exempel att du vill konvertera en asynkron ström av byte till en synkron ström av samplingar. Gränssnittet skulle då kunna se ut så här: </para> + +<programlisting +>interface ByteStreamToAudio : SynthModule { + async in byte stream indata; // den asynkrona indatasamplingen + + out audio stream left,right; // de synkrona utdatasamplingarna +}; +</programlisting> + +</sect2> + +<sect2 id="async-streams"> +<title +>Att använda asynkrona strömmar</title> + +<para +>Antag att du har bestämt dig för att skriva en modul som skapar asynkront ljud. Dess gränssnitt kan se ut så här: </para> + +<programlisting +>interface SomeModule : SynthModule +{ + async out byte stream outdata; +}; +</programlisting> + +<para +>Hur skickar man data? Den första metoden kallas <quote +>tryckleverans</quote +>. Med asynkrona strömmar skickar man data som paket. Det betyder att individuella paket skickas som i exemplet ovan. Den verkliga processen är: allokera ett paket, fyll det, skicka det. </para> + +<para +>Här följer det i form av kod. Först allokerar vi ett paket: </para> + +<programlisting +>DataPacket<mcopbyte> *packet = outdata.allocPacket(100); +</programlisting> + +<para +>Vi fyller det: </para> + +<programlisting +>// typkonvertera så att fgets får en (char *) pekare +char *data = (char *)packet->contents; + +// som du ser, kan du krympa paketstorleken efter allokeringen +// om du vill +if(fgets(data,100,stdin)) + packet->size = strlen(data); +else + packet->size = 0; +</programlisting> + +<para +>Nu skickar vi det: </para> + +<programlisting +>packet->send(); +</programlisting> + +<para +>Det här är mycket enkelt, men om vi vill skicka paket precis så snabbt som mottagaren kan hantera dem, behövs ett annat sätt, metoden med <quote +>dragleverans</quote +>. Man begär att skicka paket så snabbt som mottagaren är klar att behandla dem. Man börjar med en viss mängd paket som skickas. Medan mottagaren behandlar paket efter paket, börjar man fylla i dem med färsk data, och skickar dem igen. </para> + +<para +>Du startar det genom att anropa setPull. Till exempel: </para> + +<programlisting +>outdata.setPull(8, 1024); +</programlisting> + +<para +>Det här betyder att du vill skicka paket via outdata. Du vill börja med att skicka 8 paket på en gång, och när mottagaren behandlar några av dem, vill du fylla dem igen. </para> + +<para +>Därefter behöver du implementera en metod som fyller paketen, som skulle kunna se ut så här: </para> + +<programlisting +>void request_outdata(DataPacket<mcopbyte> *packet) +{ + packet->size = 1024; // ska inte vara mer än 1024 + for(int i = 0;i < 1024; i++) + packet->contents[i] = (mcopbyte)'A'; + packet->send(); +} +</programlisting> + +<para +>Det är allt. När du inte har mer data, kan du börja skicka paket med storleken noll, som stoppar dragleveranserna. </para> + +<para +>Observera att det är väsentligt att ge metoden exakt namnet <methodname +>request_<replaceable +>strömnamn</replaceable +></methodname +>. </para> + +<para +>Vi beskrev just att skicka data. Att ta emot data är mycket enklare. Antag att du har ett enkelt filter, ToLower, som helt enkelt konverterar alla bokstäver till små: </para> + +<programlisting +>interface ToLower { + async in byte stream indata; + async out byte stream utdata; +}; +</programlisting> + +<para +>Det här är verkligt enkelt att implementera. Här är hela implementationen: </para> + +<programlisting +>class ToLower_impl : public ToLower_skel { +public: + void process_indata(DataPacket<mcopbyte> *inpacket) + { + DataPacket<mcopbyte> *outpacket = outdata.allocPacket(inpacket->size); + + // omvandla till små bokstäver + char *instring = (char *)inpacket->contents; + char *outstring = (char *)outpacket->contents; + + for(int i=0;i<inpacket->size;i++) + outstring[i] = tolower(instring[i]); + + inpacket->processed(); + outpacket->send(); + } +}; + +REGISTER_IMPLEMENTATION(ToLower_impl); +</programlisting> + +<para +>Återigen är det väsentligt att ge metoden namnet <methodname +>process_<replaceable +>strömnamn</replaceable +></methodname +>. </para> + +<para +>Som du kan se, så får du ett anrop till en funktion för varje paket som anländer (<function +>process_indata</function +> i vårt fall). Du måste anropa metoden <methodname +>processed()</methodname +> för ett paket för att ange att du har behandlat det. </para> + +<para +>Här är ett implementeringstips: Om det tar lång tid att behandla data (dvs. om du måste vänta på utmatning till ljudkortet eller något sådant), anropa inte processed omedelbart, utan lagra hela datapaketet och anropa processed bara när du verkligen har behandlat paketet. På detta sätt, har avsändarna en chans att veta hur lång tid det verkligen tar att utföra arbetet. </para> + +<para +>Eftersom synkronisering inte är så trevlig med asynkrona strömmar, ska man använda synkrona strömmar så ofta det är möjligt, och asynkrona bara om det är nödvändigt. </para> + +</sect2> + +<sect2 id="default-streams"> +<title +>Förvalda strömmar</title> + +<para +>Antag att du har två objekt, till exempel en AudioProducer och en AudioConsumer. AudioProducer har en utdataström och AudioConsumer har en indataström. Varje gång du vill förbinda dem, använder du de här två strömmarna. Den första användningen av förval är att låta dig upprätta förbindelsen utan att ange portarna i det här fallet. </para> + +<para +>Antag nu att de två objekten ovan kan hantera stereo, och båda har en <quote +>vänster</quote +> och <quote +>höger</quote +> port. Du skulle fortfarande vilja kunna koppla ihop dem lika lätt som tidigare. Men hur kan förbindelsesystemet veta vilken utgång som ska kopplas till vilken ingång? Det har inget sätt att koppla ihop strömmarna korrekt. Förval används då för att ange flera strömmar med en viss ordning. På så sätt, om du ansluter ett objekt med två förvalda utdataströmmar till ett annat med två förvalda indataströmmar, behöver du inte ange portarna, och förbindelserna görs på ett riktigt sätt. </para> + +<para +>Det här är förstås inte begränsat till stereo. Vilket antal strömmar som helst kan göras förvalda om det behövs, och anslutningsfunktionen kontrollerar att antalet förval för två objekt passar ihop (med de angivna riktningarna) om du inte anger portarna som ska användas. </para> + +<para +>Syntaxen är den följande: I &IDL; kan du använda nyckelordet default i strömdeklarationen, eller på en ensam rad. Till exempel: </para> + +<programlisting +>interface TwoToOneMixer { + default in audio stream input1, input2; + out audio stream output; +}; +</programlisting> + +<para +>I det här exemplet kommer objektet att förvänta sig att dess två indataportar ska anslutas med förval. Ordningen är den som anges på raden, så ett objekt som det här: </para> + +<programlisting +>interface DualNoiseGenerator { + out audio stream bzzt, couic; + default couic, bzzt; +}; +</programlisting> + +<para +>skapar automatiskt en förbindelse från <quote +>couic</quote +> till <quote +>input1</quote +>, och <quote +>bzzt</quote +> till <quote +>input2</quote +> Observera att eftersom det bara finns en utgång för mixern, kommer den att vara förvald i det här fallet (se nedan). Syntaxen som används i brusgeneratorn är användbar för att ange en annan ordning än i deklarationen, eller för att välja bara några få portar som förval. Riktningen på portarna på den här raden slås upp av &mcopidl;, så ange dem inte. Du kan till och med blanda in- och utportar på en sådan här rad, bara ordningen spelar roll. </para> + +<para +>Det finns några regler som följs när arv används: </para> + +<itemizedlist> +<listitem> +<para +>Om en förvalslista anges i &IDL; så måste den användas. En förälders portar kan också ingå i listan, vare sig de var förval i föräldern eller inte. </para> +</listitem> + +<listitem> +<para +>Annars ärvs förälderns förval. Ordningen är förälder1 förval1, förälder1 förval2..., förälder2 förval1... Om det finns en gemensam förfader som använder två föräldragrenar, görs en hopslagning som liknar <quote +>virtual public</quote +> vid förvalets första plats i listan. </para> +</listitem> + +<listitem> +<para +>Om det fortfarande inte finns något förval och en enda ström i en viss riktning, så används den som förval för den riktningen. </para> +</listitem> +</itemizedlist> + +</sect2> + +</sect1> +<sect1 id="attribute-change-notify"> +<title +>Ändringsmeddelanden för egenskaper</title> + +<!-- TODO: This should be embedded better into the context - I mean: the + context should be written ;-). --> + +<para +>Ändringsmeddelanden för egenskaper är ett sätt att veta när en egenskap ändras. De kan i viss utsträckning jämföras med en &Qt;- eller Gtk-signal eller slot. Om du till exempel har ett grafiskt element, ett skjutreglage, som ställer in ett tal mellan 0 och 100, har du oftast ett objekt som gör något med talet (det kan till exempel kontrollera volymen på någon ljudsignal). Så du skulle vilja att så fort skjutreglaget flyttas ska objektet som ställer in volymen bli underrättat. En förbindelse mellan en sändare och mottagare. </para> + +<para +>&MCOP; hanterar detta genom att kunna ge meddelanden när egenskaper ändras. Allt som deklareras som <quote +>attribute</quote +> i &IDL; kan avge sådana ändringsmeddelanden, och ska göra det, när de än ändras. Allt som deklareras som <quote +>attribute</quote +> kan också ta emot sådana ändringsmeddelanden. Så om du till exempel har två &IDL;-gränssnitt som de här </para> + +<programlisting +>interface Slider { + attribute long min,max; + attribute long position; + }; + interface VolumeControl : Arts::StereoEffect { + attribute long volume; // 0..100 + }; +</programlisting> + +<para +>kan du förbinda dem med ändringsmeddelanden. Det fungerar med det normala flödessystemets anslutningsoperation. I det här fallet, ser C++ koden som ansluter två objekt ut så här: </para> + +<programlisting +>#include <connect.h> +using namespace Arts; +[...] +connect(slider,"position_changed",volumeControl,"volume"); +</programlisting> + +<para +>Som du kan se, erbjuder varje egenskap två olika strömmar, en för att skicka ändringsmeddelanden, som heter <function +><replaceable +>egenskapsnamn</replaceable +>_changed</function +>, och en för att ta emot ändringsmeddelanden, som heter <function +>egenskapsnamn</function +>. </para> + +<para +>Det är viktigt att veta att ändringsmeddelanden och asynkrona strömmar passar ihop. De är också nätverkstransparenta. Så du kan ansluta en flyttalsegenskaps ändringsmeddelande för en grafisk komponent till en asynkron ström för en syntesmodul som kör på en annan dator. Det här betyder förstås också att ändringsmeddelanden <emphasis +>inte är synkrona</emphasis +>, vilket betyder att det kan ta tid innan de verkligen tas emot efter du har skickat dem. </para> + +<sect2 id="sending-change-notifications"> + +<title +>Att skicka ändringsmeddelanden</title> + +<para +>När du implementerar objekt som har egenskaper, måste du skicka ändringsmeddelanden så snart en egenskap ändras. Koden för att göra detta ser ut så här: </para> + +<programlisting +>void KPoti_impl::value(float newValue) + { + if(newValue != _value) + { + _value = newValue; + value_changed(newValue); // <- skicka ändringsmeddelande + } + } +</programlisting> + +<para +>Det rekommenderas varmt att använda kod som den här för alla objekt som du implementerar, så att ändringsmeddelanden kan användas av andra. Du bör dock undvika att skicka meddelanden för ofta, så om du gör signalbehandling är det troligen bäst att hålla reda på när du skickade ditt senaste meddelande, så att du inte skickar ett för varje sampling. </para> + +</sect2> + +<sect2 id="change-notifications-apps"> +<title +>Tillämpningar för ändringsmeddelanden</title> + +<para +>Det kommer att vara särskilt användbart att använda ändringsmeddelanden tillsammans med mätare (objekt som till exempel visualiserar ljuddata), grafiska gränssnitt, styrelement och monitorer. Kod som använder det här finns i <filename class="directory" +>kdelibs/arts/tests</filename +>, och i den experimentella artsgui-implementeringen, som du hittar i <filename class="directory" +>kdemultimedia/arts/gui</filename +>. </para> + +<!-- TODO: can I markup links into the source code - if yes, how? --> + +<!-- LW: Linking into the source is problematic - we can't assume people are +reading this on a machine with the sources available, or that they aren't +reading it from a website. We're working on it! --> + +</sect2> +</sect1> + +<sect1 id="the-mcoprc-file"> + +<title +>Filen <literal role="extension" +>.mcoprc</literal +></title> + +<para +>Filen <literal role="extension" +>.mcoprc</literal +> (i varje användares hemkatalog) kan användas för att anpassa &MCOP; i viss mån. För närvarande är följande möjligt: </para> + +<variablelist> + +<varlistentry> +<term +>GlobalComm</term> +<listitem> +<para +>Namnet på ett gränssnitt som ska användas för global kommunikation. Global kommunikation används för att hitta andra objekt och hämta den hemliga kakan. Alla &MCOP; klienter/servrar som ska kunna kommunicera med varandra måste ha ett GlobalComm-objekt för att kunna dela information. För närvarande är de möjliga värdena <quote +>Arts::TmpGlobalComm</quote +> för att kommunicera via katalogen <filename class="directory" +>/tmp/mcop-<replaceable +>användarnamn</replaceable +></filename +> (som bara fungerar på den lokala datorn) och <quote +>Arts::X11GlobalComm</quote +> för att kommunicera via rotfönsteregenskaperna på X11-servern. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>TraderPath</term> + +<listitem> +<para +>Anger var handlarinformation ska hittas. Du kan ange mer än en katalog här, och separera dem med kommatecken. </para> +</listitem> + +</varlistentry> + +<varlistentry> +<term +>ExtensionPath</term> + +<listitem> +<para +>Anger från vilka kataloger utökningar (i form av delade bibliotek) laddas. Flera värden kan separeras med kommatecken. </para> +</listitem> + +</varlistentry> +</variablelist> + +<para +>Ett exempel som använder allt det ovanstående är: </para> + +<programlisting +># $HOME/.mcoprc file +GlobalComm=Arts::X11GlobalComm + +# om du är en utvecklare kan det vara bekvämt att lägga till en katalog i din +# hemkatalog till TraderPath/ExtensionPath sökvägarna för att kunna lägga +# till komponenter utan att installera dem +TraderPath="/opt/kde2/lib/mcop","/home/joe/mcopdevel/mcop" +ExtensionPath="/opt/kde2/lib","/home/joe/mcopdevel/lib" +</programlisting> + +</sect1> + +<sect1 id="mcop-for-corba-users"> +<title +>&MCOP; för <acronym +>CORBA</acronym +>-användare</title> + +<para +>Om du har använt <acronym +>CORBA</acronym +> tidigare, kommer du att märka att &MCOP; är mycket likt. I själva verket så använde &arts; <acronym +>CORBA</acronym +> innan version 0.4. </para> + +<para +>Den grundläggande idén med <acronym +>CORBA</acronym +> är likadan: man implementerar objekt (komponenter). Genom att använda funktionerna i &MCOP; är objekt inte bara tillgängliga som normala klasser från samma process (via standardmässiga C++ tekniker), utan de är också transparent tillgängliga för en fjärrserver. För att detta ska fungera, är det första du måste göra att specificera gränssnittet för dina objekt i en &IDL;-fil, precis som för <acronym +>CORBA</acronym +>-&IDL;. Det finns bara ett fåtal skillnader. </para> + +<sect2 id="corba-missing"> +<title +><acronym +>CORBA</acronym +>-funktioner som saknas i &MCOP;</title> + +<para +>I &MCOP; finns det inga <quote +>in</quote +> och <quote +>out</quote +> parametrar för metodanrop. Parametrar är alltid ingående, och returvärdet är alltid utgående, vilket betyder att gränssnittet: </para> + +<programlisting +>// CORBA idl +interface Account { + void deposit( in long amount ); + void withdraw( in long amount ); + long balance(); +}; +</programlisting> + +<para +>skrivs som </para> + +<programlisting +>// MCOP idl +interface Account { + void deposit( long amount ); + void withdraw( long amount ); + long balance(); +}; +</programlisting> + +<para +>i &MCOP;. </para> + +<para +>Det finns inget stöd för undantag. &MCOP; har inte undantag, det använder något annat för felhantering. </para> + +<para +>Det finns inga union-typer och inga typdefinitioner. Jag vet inte om det är en verklig svaghet, något man desperat behöver för att överleva. </para> + +<para +>Det finns inget stöd för att skicka gränssnitt eller objektreferenser </para> + +</sect2> + +<sect2 id="corba-different"> +<title +><acronym +>CORBA</acronym +>-funktioner som är annorlunda i &MCOP;</title> + +<para +>Du deklarerar sekvenser som <quote +>sequence<replaceable +>typ</replaceable +></quote +> i &MCOP;. Det finns inget behov av en typdefinition. Till exempel, istället för: </para> + +<programlisting +>// CORBA idl +struct Line { + long x1,y1,x2,y2; +}; +typedef sequence<Line> LineSeq; +interface Plotter { + void draw(in LineSeq lines); +}; +</programlisting> + +<para +>skulle du skriva </para> + +<programlisting +>// MCOP idl +struct Line { + long x1,y1,x2,y2; +}; +interface Plotter { + void draw(sequence<Line> lines); +}; +</programlisting> + +</sect2> + +<sect2 id="no-in-corba"> +<title +>&MCOP;-funktioner som inte finns i <acronym +>CORBA</acronym +></title> + +<para +>Du kan deklarera strömmar, som sedan behandlas av &arts; grundstomme. Strömmar deklareras på ett sätt som liknar egenskaper. Till exempel: </para> + +<programlisting +>// MCOP idl +interface Synth_ADD : SynthModule { + in audio stream signal1,signal2; + out audio stream outvalue; +}; +</programlisting> + +<para +>Det här betyder att ditt objekt kommer att acceptera två inkommande synkrona ljudströmmar som kallas signal1 och signal2. Synkron betyder att de är strömmar som levererar x samplingar per sekund (eller annan tid), så att schemaläggaren alltid garanterar att du får en balanserad mängd indata (t.ex. 200 samplingar av signal1 finns och 200 samplingar av signal2 finns). Du garanterar att om ditt objekt anropas med de här 200 samplingarna av signal1 + signal2, så kan det skapa precis 200 samplingar utdata. </para> + +</sect2> + +<sect2 id="mcop-binding"> +<title +>&MCOP;-bindningen till C++ språket</title> + +<para +>Det här skiljer sig från <acronym +>CORBA</acronym +> i huvudsak angående: </para> + +<itemizedlist> +<listitem> +<para +>Strängar använder C++ <acronym +>STL</acronym +>-klassen <classname +>string</classname +>. När de lagras i sekvenser, lagras de <quote +>enkelt</quote +>, vilket betyder att de anses vara en primitiv typ. Därför behöver de kopieras. </para> +</listitem> + +<listitem> +<para +>long är enkla long (förväntas vara 32 bitar). </para> +</listitem> + +<listitem> +<para +>Sekvenser använder C++ <acronym +>STL</acronym +>-klassen <classname +>vector</classname +>. </para> +</listitem> + +<listitem> +<para +>Strukturer härleds alla från &MCOP; klassen <classname +>Type</classname +>, och skapas av &MCOP; &IDL;-kompilatorn. När de lagras i sekvenser, lagras de inte <quote +>enkelt</quote +>, utan som pekare, eftersom annars skulle för mycket kopiering uppstå. </para> +</listitem> +</itemizedlist> +</sect2> + +<sect2 id="implementing-objects"> +<title +>Att implementera &MCOP;-objekt</title> + +<para +>Efter att ha skickat dem genom &IDL;-kompilatorn, måste du härleda från klassen <classname +>_skel</classname +>. Antag till exempel att du har definierat gränssnittet så här: </para> + +<programlisting +>// MCOP idl: hello.idl +interface Hello { + void hello(string s); + string concat(string s1, string s2); + long sum2(long a, long b); +}; +</programlisting> + +<para +>Du skickar det genom &IDL;-kompilatorn genom att anropa <userinput +><command +>mcopidl</command +> <parameter +>hello.idl</parameter +></userinput +>, som i sin tur skapar <filename +>hello.cc</filename +> och <filename +>hello.h</filename +>. För att implementera det, behöver du en C++ klass som ärver stommen: </para> + +<programlisting +>// C++ deklarationsfil - infoga hello.h någonstans +class Hello_impl : virtual public Hello_skel { +public: + void hello(const string& s); + string concat(const string& s1, const string& s2); + long sum2(long a, long b); +}; +</programlisting> + +<para +>Till sist måste du implementera metoderna som vanlig C++. </para> + +<programlisting +>// C++ implementeringsfil + +// som du ser skickas strängar som konstanta strängreferenser +void Hello_impl::hello(const string& s) +{ + printf("Hello '%s'!\n",s.c_str()); +} + +// när de är ett returvärde skickas de som "normala" strängar +string Hello_impl::concat(const string& s1, const string& s2) +{ + return s1+s2; +} + +long Hello_impl::sum2(long a, long b) +{ + return a+b; +} +</programlisting> + +<para +>När du väl har gjort detta, har du ett objekt som kan kommunicera med &MCOP;. Skapa bara ett (med de normala C++ faciliteterna för att skapa ett objekt): </para> + +<programlisting +>Hello_impl server; +</programlisting> + +<para +>Och så fort du ger någon referensen </para> + +<programlisting +>string reference = server._toString(); + printf("%s\n",reference.c_str()); +</programlisting> + +<para +>och går till &MCOP;:s väntesnurra </para> + +<programlisting +>Dispatcher::the()->run(); +</programlisting> + +<para +>kan alla komma åt objektet med </para> + +<programlisting +>// den här koden kan köra var som helst - inte nödvändigtvis i samma process +// (den kan också köra på en annan dator/arkitektur) + + Hello *h = Hello::_fromString([objektreferensen som skrevs ut ovan]); +</programlisting> + +<para +>och anropa metoder: </para> + +<programlisting +>if(h) + h->hello("test"); + else + printf("Åtkomst misslyckades?\n"); +</programlisting> + +</sect2> +</sect1> + +<sect1 id="mcop-security"> +<title +>Säkerhetshänsyn för &MCOP;</title> + +<para +>Eftersom en &MCOP;-server lyssnar på en <acronym +>TCP</acronym +>-port, kan potentiellt sett alla (om du är ansluten till Internet) försöka att ansluta till en &MCOP;-service. Därför är det viktigt att identifiera klienter. &MCOP; använder md5-auth protokollet. </para> + +<para +>Protokollet md5-auth gör följande för att försäkra att bara utvalda (pålitliga) klienter kan ansluta till en server: </para> + +<itemizedlist> +<listitem> +<para +>Det antar att du kan ge varje klient en hemlig kaka. </para> +</listitem> + +<listitem> +<para +>Varje gång en klient ansluter, verifierar den att den här klienten känner till den hemliga kakan, utan att verkligen skicka den (inte ens på en form som någon som lyssnar på nätverkstrafik kan ta reda på). </para> +</listitem> + +</itemizedlist> + +<para +>För att ge varje klient den hemliga kakan, lägger &MCOP; (normalt) den i <filename class="directory" +>mcop</filename +> katalogen (i <filename class="directory" +>/tmp/mcop-<envar +>USER</envar +>/secret-cookie</filename +>). Du kan förstås kopiera den till andra datorer. Men om du gör det, använd då en säker överföringsmekanism, som <command +>scp</command +> (från <application +>ssh</application +>). </para> + +<para +>Identifieringen av klienter använder följande steg: </para> + +<procedure> +<step> +<para +>[SERVER] skapa en ny (slumpmässig) kaka R </para> +</step> + +<step> +<para +>[SERVER] skicka den till klienten </para> +</step> + +<step> +<para +>[KLIENT] läs den "hemliga kakan" S från en fil </para> +</step> + +<step> +<para +>[KLIENT] behandla kakorna R och S för att skapa kakan M med MD5-algoritmen </para> +</step> + +<step> +<para +>[KLIENT] skicka M till servern </para> +</step> + +<step> +<para +>[SERVER] verifiera att behandling av R och S ger precis samma sak som kakan M som togs emot från klienten. Om detta stämmer har identifieringen lyckats. </para> +</step> + +</procedure> + +<para +>Den här algoritmen bör vara säker, under förutsättning att </para> + +<orderedlist> +<listitem> +<para +>De hemliga och slumpmässiga kakorna är <quote +>slumpmässiga nog</quote +> och </para> +</listitem> + +<listitem> +<para +>MD5-algoritmen inte tillåter att <quote +>originaltexten</quote +> kan avgöras, det vill säga den hemliga kakan S och den slumpmässiga kakan R (som är känd ändå), från den behandlade kakan M. </para> +</listitem> +</orderedlist> + +<para +>&MCOP;-protokollet startar varje ny förbindelse med en identifieringsprocess. Översiktligt ser den ut så här: </para> + +<procedure> + +<step> +<para +>Servern skickar meddelandet ServerHello, som beskriver de kända indentifieringsprotokollen. </para> +</step> + +<step> +<para +>Klienten skickar meddelandet ClientHello, som innehåller identifieringsinformation. </para> +</step> + +<step> +<para +>Servern skickar meddelandet AuthAccept. </para> +</step> +</procedure> + +<para +>För att se att säkerheten verkligen fungerar, bör vi titta på hur meddelanden behandlas för oidentifierade förbindelser: </para> + +<itemizedlist> +<listitem> +<para +>Innan identifieringen lyckas, tar inte servern emot andra meddelanden från anslutningen. Istället, om servern till exempel förväntar sig meddelandet <quote +>ClientHello</quote +>, och får meddelandet mcopInvocation, så kopplar den ner förbindelsen. </para> +</listitem> + +<listitem> +<para +>Om klienten inte skickar ett giltigt &MCOP;-meddelande alls (inget magiskt värde &MCOP; i meddelandehuvudet) i identifieringsfasen, utan något annat, så kopplas förbindelsen ner. </para> +</listitem> + +<listitem> +<para +>Om klienten försöker skicka ett mycket mycket stort meddelande (> 4096 byte) under identifieringsfasen, kapas meddelandestorleken till 0 byte, vilket gör att det inte accepteras som identifiering. Det här är till för att förhindra att oidentifierade klienter skickar t.ex. ett 100 Mibyte meddelande, som skulle tas emot och kunna orsaka att servern får slut på minne. </para> +</listitem> + +<listitem> +<para +>Om klienten skickar ett felaktigt ClientHello meddelande (ett där avkodningen misslyckas), så kopplas förbindelsen ner. </para> +</listitem> + +<listitem> +<para +>Om klienten inte skickar något alls, ska en tidsgräns överskridas (ännu inte implementerat). </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="mcop-protocol"> +<title +>&MCOP; protokollspecifikation</title> + +<sect2 id="mcop-protocol-intro"> +<title +>Inledning</title> + +<para +>Den har begreppsmässiga likheter med <acronym +>CORBA</acronym +>, men är avsett för att kunna utökas på alla sätt som krävs för multimediaoperationer i realtid. </para> + +<para +>Den tillhandahåller en multimediaobjektmodell, som både kan användas för kommunikation mellan komponenter i ett adressrum (en process), och mellan komponenter som finns i olika trådar, processer eller på olika värddatorer. </para> + +<para +>Totalt sett, kommer den att konstrueras för extremt hög prestanda (så att allt ska optimeras för att vara våldsamt snabbt), lämpligt för mycket kommunikationsintensiva multimediaprogram. Att till exempel skicka runt video är en av tillämpningarna för &MCOP;, där de flesta <acronym +>CORBA</acronym +>-implementeringar skulle gå på knäna. </para> + +<para +>Gränssnittsdefinitionerna kan hantera följande själv: </para> + +<itemizedlist> +<listitem> +<para +>Kontinuerliga dataflöden (som ljuddata). </para> +</listitem> + +<listitem> +<para +>Händelseflöden av data (som &MIDI;-händelser). </para> +</listitem> + +<listitem> +<para +>Riktig referensräkning. </para> +</listitem> +</itemizedlist> + +<para +>och de viktigaste <acronym +>CORBA</acronym +>-knepen, som </para> + +<itemizedlist> +<listitem> +<para +>Synkrona metodanrop. </para> +</listitem> + +<listitem> +<para +>Asynkrona metodanrop. </para> +</listitem> + +<listitem> +<para +>Konstruera användardefinierade datatyper. </para> +</listitem> + +<listitem> +<para +>Multipla arv. </para> +</listitem> + +<listitem> +<para +>Skicka objektreferenser. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="mcop-protocol-marshalling"> +<title +>&MCOP;:s meddelandekodning</title> + +<para +>Konstruktionsmål/idéer: </para> + +<itemizedlist> + +<listitem> +<para +>Kodning ska vara enkelt att implementera. </para> +</listitem> + +<listitem> +<para +>Avkodning kräver att mottagaren vet vilken typ som ska avkodas. </para> +</listitem> + +<listitem> +<para +>Mottagaren förväntas använda all information, så möjlighet att hoppa över data finns bara i protokollet såtillvida att: </para> + +<itemizedlist> +<listitem> +<para +>Om man vet att ett block av data kommer att tas emot, behöver man inte titta på varje del efter en slutmarkör. </para> +</listitem> + +<listitem> +<para +>Om man vet att en sträng kommer att tas emot, behöver man inte läsa till en noll-byte för att ta reda på dess längd vid avkodning, men, </para> +</listitem> + +<listitem> +<para +>Om man vet att en sekvens av strängar kommer att tas emot måste man titta på längden för var och en av dem för att ta reda på slutet för sekvensen, eftersom strängar har variabel längd. Men om strängarna används för någonting nyttigt, måste det göras i alla fall, så det här är ingen förlust. </para> +</listitem> +</itemizedlist> + +</listitem> + +<listitem> +<para +>Så lite extra kostnad som möjligt. </para> +</listitem> +</itemizedlist> + +<!-- TODO: Make this a table --> + +<para +>Kodningen av de olika typerna visas i tabellen nedan: </para> + +<informaltable> +<tgroup cols="3"> +<thead> +<row> +<entry +>Typ</entry> +<entry +>Kodningsprocess</entry> +<entry +>Resultat</entry> +</row> +</thead> + +<tbody> +<row> +<entry +><type +>void</type +></entry> +<entry +>typen <type +>void</type +> kodas genom att utelämna den, så ingenting skrivs till strömmen för den.</entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>long</type +></entry> +<entry +>kodas som fyra byte, med den mest signifikanta först, så att talet 10001025 (som är 0x989a81) skulle kodas som:</entry> +<entry +><literal +>0x00 0x98 0x9a 0x81</literal +></entry> +</row> + +<row> +<entry +><type +>uppräkningstyper</type +></entry> +<entry +><para +>kodas som <type +>long</type +></para +></entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>byte</type +></entry> +<entry +><para +>kodas som en enda byte, så 0x42 skulle kodas som:</para +></entry> +<entry +><literal +>0x42</literal +></entry> +</row> + +<row> +<entry +><type +>sträng</type +></entry> +<entry +><para +>kodas som en <type +>long</type +>, som innehåller längden på den efterföljande strängen, och sedan sekvensen av tecken. Strängar måste sluta med en noll-byte (som ingår i längdberäkningen).</para> +<important> +<para +>inklusive den sista 0 byten i längdräkningen!</para> +</important> +<para +><quote +>hello</quote +> skulle kodas som:</para +></entry> +<entry +><literal +>0x00 0x00 0x00 0x06 0x68 0x65 0x6c 0x6c 0x6f 0x00</literal +></entry> +</row> + +<row> +<entry +><type +>boolean</type +></entry> +<entry +><para +>kodas som en byte, som innehåller 0 om <returnvalue +>false</returnvalue +> eller 1 om <returnvalue +>true</returnvalue +>, så att det booleska värdet <returnvalue +>true</returnvalue +> kodas som:</para +></entry> +<entry +><literal +>0x01</literal +></entry> +</row> + +<row> +<entry +><type +>flyttal</type +></entry> +<entry +><para +>kodas med fyra-byte IEEE754 representationen, detaljerad dokumentation om hur IEEE fungerar finns här: <ulink url="http://twister.ou.edu/workshop.docs/common-tools/numerical_comp_guide/ncg_math.doc.html" +>http://twister.ou.edu/workshop.docs/ common-tools/ numerical_comp_guide/ ncg_math.doc.html</ulink +> och här: <ulink url="http://java.sun.com/docs/books/vmspec/2nd-edition/html/Overview.doc.html" +>http://java.sun.com/docs/books/ vmspec/ 2nd-edition/ html/ Overview.doc.html</ulink +>. Så värdet 2,15 skulle kodas som:</para +></entry> +<entry +><literal +>0x9a 0x99 0x09 0x40</literal +></entry> +</row> + +<row> +<entry +><type +>struct</type +></entry> +<entry +><para +>En struktur kodas genom att koda dess innehåll. Det krävs inga ytterligare prefix eller suffix, så att strukturen </para> +<programlisting +>struct test { + string name; // som är "hello" + long value; // som är 10001025 (0x989a81) +}; +</programlisting> +<para +>skulle kodas som:</para +></entry> +<entry> +<literallayout +>0x00 0x00 0x00 0x06 0x68 0x65 0x6c 0x6c +0x6f 0x00 0x00 0x98 0x9a 0x81 +</literallayout +></entry> +</row> + +<row> +<entry +><type +>sekvens</type +></entry> +<entry +><para +>En sekvens kodas genom att lista antalet element som följer, och sedan koda elementen ett efter ett.</para> +<para +>Så en sekvens med tre "long a", med a[0] = 0x12345678, a[1] = 0x01 och a[2] = 0x42 skulle kodas som</para +></entry> +<entry> +<literallayout +>0x00 0x00 0x00 0x03 0x12 0x34 0x56 0x78 +0x00 0x00 0x00 0x01 0x00 0x00 0x00 0x42 +</literallayout> +</entry> +</row> +</tbody> +</tgroup> +</informaltable> + +<para +>Om du behöver hänvisa till en typ, anges alla primitiva typer med namnen som finns ovan. Strukturer och uppräkningstyper får sina egna namn (som Header). Sekvenser benämns som *<replaceable +>normal typ</replaceable +>, så att en sekvens av long är <quote +>*long</quote +> och en sekvens av Header struct:ar är <quote +>*Header</quote +>. </para> + +</sect2> + +<sect2 id="mcop-protocol-messages"> +<title +>Meddelanden</title> + +<para +>Formatet på &MCOP;:s meddelandehuvud definieras av den här strukturen: </para> + +<programlisting +>struct Header { + long magic; // värdet 0x4d434f50, som kodas som MCOP + long messageLength; + long messageType; +}; +</programlisting> + +<para +>De möjliga meddelandetyperna är för närvarande </para> + +<programlisting +>mcopServerHello = 1 + mcopClientHello = 2 + mcopAuthAccept = 3 + mcopInvocation = 4 + mcopReturn = 5 + mcopOnewayInvocation = 6 +</programlisting> + +<para +>Lite information om &MCOP;:s meddelandehantering: </para> + + +<itemizedlist> +<listitem> +<para +>Varje meddelande börjar med ett huvud. </para> +</listitem> + +<listitem> +<para +>Vissa meddelandetyper ska ignoreras av servern, innan identifiering är färdig. </para> +</listitem> + +<listitem> +<para +>Efter att huvudet tagits emot, kan protokollhanteringen (anslutningen) ta emot meddelandet i sin helhet, utan att titta på innehållet. </para> +</listitem> +</itemizedlist> + +<para +>Meddelandelängden i huvudet är förstås redundant i vissa fall, vilket gör att metoden inte alltid är minimal med avseende på antal byte. </para> + +<para +>Detta ger dock en enkel (och snabb) implementering för behandling av meddelanden som inte blockerar. Med hjälp av huvudet kan meddelanden tas emot av protokollhanteringsklasser i bakgrunden (utan blockering), om det finns många anslutningar till servern kan alla behandlas parallellt. Man behöver inte titta på meddelandets innehåll för att ta emot ett meddelande (och avgöra när man är klar), bara på huvudet, så koden för detta är ganska enkel. </para> + +<para +>När ett meddelande väl finns på plats, kan det avkodas och behandlas i ett enda steg, utan att bry sig om fall där all data kanske inte tagits emot (eftersom meddelandelängden garanterar att allt är på plats). </para> + +</sect2> + +<sect2 id="mcop-protocol-invocations"> +<title +>Anrop</title> + +<para +>För att anropa en fjärrmetod, måste man skicka följande struktur i ett &MCOP;-meddelande med messageType = 1 (mcopInvocation): </para> + +<programlisting +>struct Invocation { + long objectID; + long methodID; + long requestID; +}; +</programlisting> + +<para +>därefter skickas parametrarna som en struktur, t.ex. om man anropar metoden "string concat(string s1, string s2)", skickas strukturen </para> + +<programlisting +>struct InvocationBody { + string s1; + string s2; +}; +</programlisting> + + +<para +>om metoden deklarerades som envägs, vilket betyder asynkront utan returvärde, är det allt. Annars får man ett meddelande som svar med messageType = 2 (mcopReturn). </para> + +<programlisting +>struct ReturnCode { + long requestID; + <resulttype> result; +}; +</programlisting> + + +<para +>där <resulttype> är typen för resultatet. Eftersom void-typer utelämnas vid kodning, kan man också bara ange requestID om man returnerar från en void-metod. </para> + +<para +>Så vår "string concat(string s1, string s2)" skulle ge en returkod som </para> + +<programlisting +>struct ReturnCode { + long requestID; + string result; +}; +</programlisting> + +</sect2> + +<sect2 id="mcop-protocol-inspecting"> +<title +>Inspektera gränssnitt</title> + +<para +>För att göra anrop, måste man känna till metoderna som ett objekt stöder. För att göra detta, är methodID 0, 1, 2 och 3 hårdkodade för vissa funktioner. Det vill säga </para> + +<programlisting +>long _lookupMethod(MethodDef methodDef); // metod-id alltid 0 +string _interfaceName(); // metod-id alltid 1 +InterfaceDef _queryInterface(string name); // metod-id alltid 2 +TypeDef _queryType(string name); // metod-id alltid 3 +</programlisting> + +<para +>för att läsa detta, behövs förstås också </para> + +<programlisting +>struct MethodDef { + string methodName; + string type; + long flags; // nu satt till 0 (krävs för strömmar) + sequence<ParamDef> signature; +}; + +struct ParamDef { + string name; + long typeCode; +}; +</programlisting> + +<para +>parameterfältet innehåller typkomponenter som anger typerna för parametrar. Typen för returkoden anges i typfältet för MethodDef. </para> + +<para +>För att vara strikt, är det bara metoderna <methodname +>_lookupMethod()</methodname +> och <methodname +>_interfaceName()</methodname +> som varierar från objekt till objekt, medan <methodname +>_queryInterface()</methodname +> och <methodname +>_queryType()</methodname +> alltid är likadana. </para> + +<para +>Vad är ett sådant här methodID? Om man gör ett &MCOP;-anrop, förväntas man skicka numret för metoden som anropas. Orsaken till detta är att nummer kan behandlas mycket snabbare än strängar när en &MCOP;-begäran körs. </para> + +<para +>Så hur skaffar man sig ett sådant här nummer? Om man känner till signaturen för metoden, dvs. en MethodDef som beskriver den (som innehåller namn, typ, parameternamn, parametertyper och liknande), så kan man skicka den till _lookupMethod för objektet där man vill anropa en metod. Eftersom _lookupMethod är hårdkodad till methodID 0, ska det inte vara några problem att göra detta. </para> + +<para +>Om man å andra sidan inte känner till metodens signatur, kan man ta reda på vilka metoder som stöds genom att använda _interfaceName, _queryInterface och _queryType. </para> +</sect2> + +<sect2 id="mcop-protocol-typedefs"> +<title +>Typdefinitioner</title> + +<para +>Användardefinierade datatyper beskrivs med strukturen <structname +>TypeDef</structname +>: </para> + +<programlisting +>struct TypeComponent { + string type; + string name; +}; + +struct TypeDef { + string name; + + sequence<TypeComponent> contents; +}; +</programlisting> + +</sect2> +</sect1> + +<sect1 id="why-not-dcop"> +<title +>Varför &arts; inte använder &DCOP;</title> + +<para +>Eftersom &kde; släppt <acronym +>CORBA</acronym +> helt och hållet, och istället använder &DCOP; överallt, uppstår förstås frågan varför inte &arts; också gör det. Trots allt finns &DCOP;-stöd i <classname +>KApplication</classname +>, underhålls väl, förväntas integreras utmärkt med libICE, och allt möjligt annat. </para> + +<para +>Eftersom det (möjligtvis) kommer att finnas många som frågar om det verkligen är nödvändigt att ha &MCOP; förutom &DCOP;, så finns svaret här. Missförstå mig inte, jag försöker inte säga att <quote +>&DCOP; är dåligt</quote +>. Jag försöker bara säga <quote +>&DCOP; är inte rätt lösning för &arts;</quote +> (medan det är en bra lösning för andra saker). </para> + +<para +>Först måste man förstå exakt vad &DCOP; skrevs för. Skapat på två dar under mötet &kde;-TWO, var det avsett att vara så enkelt som möjligt, ett verkligt <quote +>lättviktigt</quote +> kommunikationsprotokoll. I synnerhet utelämnade implementeringen allt som kunde innebära komplexitet, till exempel ett fullständigt koncept angående hur datatyper ska kodas. </para> + +<para +>Fastän &DCOP; inte bryr sig om vissa saker (som hur man skickar en sträng på ett nätverkstransparent sätt), måste detta göras. Så allt som inte &DCOP; gör överlämnas till &Qt; i &kde;-programmen som använder &DCOP; idag. Det här är i huvudsak typhantering (som använder &Qt;:s serialiseringsoperator). </para> + +<para +>Så &DCOP; är ett minimalt protokoll som gör det helt möjlig för &kde;-program att skicka enkla meddelanden som <quote +>öppna ett fönster som pekar på http://www.kde.org</quote +> eller <quote +>dina inställningar har ändrats</quote +>. Inne i &arts; fokuseras dock på andra saker. </para> + +<para +>Idén är att små insticksmoduler i &arts; ska kommunicera med sådana datastrukturer som <quote +>midi-händelser</quote +> och <quote +>sångpositionspekare</quote +> och <quote +>flödesgrafer</quote +>. </para> + +<para +>Detta är komplexa datatyper, som måste skickas mellan olika objekt, och hanteras som strömmar, eller parametrar. &MCOP; tillhandahåller ett typkoncept för att definiera komplexa datatyper från enklare (liknande struct:ar och fält i C++). &DCOP; bryr sig inte om typer alls, så det här problemet skulle lämnas till programmeraren, som att skriva C++ klasser för typerna, och försäkra sig om att de går att serialisera på ett riktigt sätt (till exempel stöd för &Qt;:s serialiseringsoperator). </para> + +<para +>Men på det sättet skulle de inte vara tillgängliga för något annat än direkt kodning i C++. I synnerhet skulle man inte kunna skapa ett skriptspråk som skulle kunna känna till alla typer som en insticksmodul kan göra tillgängliga, eftersom de inte skulle vara självbeskrivande. </para> + +<para +>Samma argument gäller också gränssnitt i stor utsträckning. &DCOP;-objekt gör inte sina förhållanden, arvhierarkier, etc. tillgängliga. Om man skulle skriva en objektbläddrare som skulle visa <quote +>vilka egenskaper har det här objektet</quote +>, skulle man misslyckas. </para> + + +<para +>Även om Matthias talade om för mig att man har en speciell funktion <quote +>functions</quote +> för varje objekt som informerar om vilka metoder som objektet stöder, utelämnar detta saker som egenskaper, strömmar och arvrelationer. </para> + +<para +>Det här gör att program som aRts-byggaren inte skulle fungera alls. Men kom ihåg, det var inte meningen att &DCOP; skulle vara en objektmodell (eftersom &Qt; redan har en med <application +>moc</application +> och liknande), inte heller vara något som <acronym +>CORBA</acronym +>, utan tillhandahålla kommunikation mellan program. </para> + +<para +>Orsaken att &MCOP; överhuvudtaget finns är att det måste fungera bra med strömmar mellan objekt. &arts; använder många små insticksmoduler, som förbinds med strömmar. <acronym +>CORBA</acronym +>-versionen av &arts; var tvungen att introducera en besvärande uppdelning mellan <quote +>SynthModule-objekt</quote +>, som var de interna arbetsmodulerna som skapade strömmar, och <quote +><acronym +>CORBA</acronym +>-gränssnitt</quote +>, som var något externt. </para> + +<para +>Mycket kod bekymrade sig om att åstadkomma att växelverkan mellan <quote +>SynthModule-objekt</quote +> och <quote +><acronym +>CORBA</acronym +>-gränssnittet</quote +> såg naturlig ut, men den gjorde aldrig det, eftersom <acronym +>CORBA</acronym +> inte kände till något alls om strömmar. &MCOP; gör det. Titta på koden (någonting i stil med <filename +>simplesoundserver_impl.cc</filename +>). Åtskilligt bättre! Strömmar kan deklareras i modulernas gränssnitt, och implementeras på ett sätt som ser naturligt ut. </para> + +<para +>Man kan inte förneka det. En av orsakerna att jag skrev &MCOP; var snabbhet. Här är några argument varför &MCOP; definitivt kommer att vara snabbare än &DCOP; (även utan att ange siffror). </para> + + +<para +>Ett anrop i &MCOP; kommer att ha ett huvud med sex <quote +>long</quote +>. Det vill säga: </para> + +<itemizedlist> +<listitem +><para +>magiskt värde <quote +>MCOP</quote +></para +></listitem> +<listitem +><para +>meddelandetyp (anrop)</para +></listitem> +<listitem +><para +>storlek på begäran i byte</para +></listitem> +<listitem +><para +>ID för begäran</para +></listitem> +<listitem +><para +>ID för målobjektet</para +></listitem> +<listitem +><para +>ID för målmetoden</para +></listitem> +</itemizedlist> + +<para +>Efter detta följer parametrarna. Observera att avkoda det här går extremt fort. Man kan använda tabelluppslagningar för att hitta avkodningsfunktionen för objektet och metoden, vilket betyder att komplexiteten är O(1) [det tar lika lång tid oberoende av hur många objekt som finns, och hur många funktioner som finns]. </para> + +<para +>Om det här jämförs med &DCOP;, ser du att det finns åtminstone </para> + +<itemizedlist> +<listitem +><para +>en sträng för målobjektet - någonting i stil med <quote +>myCalculator</quote +></para +></listitem +> +<listitem +><para +>en sträng som liknar <quote +>addNumber(int,int)</quote +> för att ange metoden</para +></listitem> +<listitem +><para +>ytterligare protokollinformation tillagd av libICE, och andra DCOP-specifika saker som jag inte känner till</para +></listitem> +</itemizedlist> + +<para +>De här är mycket svårare att avkoda, eftersom man måste tolka strängen, leta efter funktionen, etc. </para> + +<para +>Med &DCOP; skickas alla anrop genom en server (<application +>DCOPServer</application +>). Det betyder att hanteringen av ett synkront anrop ser ut så här: </para> + +<itemizedlist> +<listitem> +<para +>Klientprocessen skickar anrop. </para> +</listitem> + +<listitem> +<para +><application +>DCOPserver</application +> (mannen i mitten) tar emot anropet och ser efter vart det ska ta vägen, och skickar det till den <quote +>riktiga</quote +> servern. </para> +</listitem +> + +<listitem> +<para +>Serverprocessen tar emot anropet, utför begäran och skickar resultatet. </para> +</listitem> + +<listitem> +<para +><application +>DCOPserver</application +> (mannen i mitten) tar emot resultatet och ... skickar det till klienten. </para> +</listitem> + +<listitem> +<para +>Klienten avkodar svaret. </para> +</listitem> +</itemizedlist> + +<para +>I &MCOP; ser samma anrop ut så här: </para> + +<itemizedlist> +<listitem> +<para +>Klientprocessen skickar anrop. </para> +</listitem> + +<listitem> +<para +>Serverprocessen tar emot anropet, utför begäran och skickar resultatet. </para> +</listitem> + +<listitem> +<para +>Klienten avkodar svaret. </para> +</listitem> +</itemizedlist> + +<para +>Antag att båda är riktigt implementerade. &MCOP;:s icke-hierarkiska strategi bör vara snabbare med en faktor två, än &DCOP;:s man i mitten-strategi. Observera dock att det förstås fanns orsaker att välja &DCOP;-strategin, som är att om du har 20 program som kör, och varje program pratar med varje annat program, så behöver man 20 anslutningar med &DCOP;, och 200 med &MCOP;. I fallet med multimedia är det dock inte meningen att detta ska vara ett vanligt scenario. </para> + +<para +>Jag försökte jämföra &MCOP; och &DCOP;, med att göra ett anrop som adderar två tal. Jag ändrade testdcop för att åstadkomma detta. Testen var dock kanske inte precis på &DCOP;-sidan. Jag anropade metoden i samma process som gjorde anropet till &DCOP;, och jag visste inte hur man blev av med ett avlusningsmeddelande, så jag använde omdirigering av utmatningen. </para> + +<para +>Testen använde bara ett objekt och en funktion, så resultaten för &DCOP; förväntas minska med fler objekt och funktioner, medan resultaten för &MCOP; bör förbli likadana. Dessutom var inte <application +>dcopserver</application +>-processen ansluten till andra program, och det kanske är så att om många program är anslutna så minskar överföringsprestanda. </para> + +<para +>Resultatet jag fick var att medan &DCOP; fick lite mer än 2000 anrop per sekund, fick &MCOP; något mer än 8000 anrop per sekund. Det betyder en faktor 4. Jag vet att &MCOP; inte är avstämd för den maximalt möjliga hastigheten än. (Som jämförelse: <acronym +>CORBA</acronym +>, med mico-implementeringen, klarar något mellan 1000 och 1500 anrop per sekund). </para> + +<para +>Om du vill ha <quote +>riktigare</quote +> data, fundera på att skriva något litet mätprogram för &DCOP; och skicka det till mig. </para> + +<para +><acronym +>CORBA</acronym +> hade den trevliga funktionen att man kunde använda objekt som man implementerat, som <quote +>separat serverprocess</quote +>, eller som <quote +>bibliotek</quote +>. Man kunde använda samma kod för att göra det, och <acronym +>CORBA</acronym +> bestämde transparent vad som skulle göras. Med &DCOP;, är det inte riktigt meningen, och så vitt jag vet inte egentligen möjligt. </para> + +<para +>&MCOP; å andra sidan ska stöda detta från början. Så man kan köra en effekt inne i &artsd;. Men för en vågformseditor kan man välja att köra samma effekt inne i processen också. </para> + +<para +>Där &DCOP; i huvudsak är ett sätt att kommunicera mellan program, är &MCOP; också ett sätt att kommunicera inne i program. Särskilt för multimediaflöden är detta viktigt (eftersom man kan köra flera &MCOP;-objekt i parallell, för att lösa en multimediauppgift i ett program). </para> + +<para +>Fastän &MCOP; inte gör det för närvarande, är möjligheterna öppna att implementera servicekvalitetsfunktioner. Någonting i stil med att <quote +>den där &MIDI;-händelsen är verkligen riktigt viktig, jämfört med det här anropet</quote +>. Eller någonting som <quote +>måste vara där i tid</quote +>. </para> + +<para +>Å andra sidan kan strömöverföringar integreras i &MCOP;-protokollet på ett trevligt sätt, och kombineras med <acronym +>QoS</acronym +>-grejor. Under förutsättning att protokollet kan ändras, bör inte &MCOP; strömöverföringar verkligen bli långsammare än en konventionell <acronym +>TCP</acronym +>-ström, men de kommer att vara enklare och mer konsekventa att använda. </para> + +<para +>Det finns ingen anledning att basera mellanprogram för multimedia på &Qt;. Genom att bestämma sig för det, och använda allt de där trevliga &Qt;-strömmarna och andra saker, kan det lätt leda till att mellanprogram bara blir en sak för &Qt;-(eller i själva verket bara &kde;). Jag menar att om jag någonsin ser att GNOME också använder &DCOP;, eller någonting liknande, är det förstås bevisat att jag har fel. </para> + +<para +>Fastän jag vet att &DCOP; i grunden inte känner till de datatyper som det skickar, så att man skulle kunna använda &DCOP; utan &Qt;, se hur det används i daglig &kde;-användning: man skickar runt typer som <classname +>QString</classname +>, <classname +>QRect</classname +>, <classname +>QPixmap</classname +>, <classname +>QCString</classname +>, .... De här använder &Qt;:s-serialisering. Så om någon väljer att stöda &DCOP; i ett GNOME-program, måste han antingen ange att han använder <classname +>QString</classname +>,... typer (även om han inte gör det), och emulera sättet som &Qt; använder för strömmar, eller så skulle han skicka runt andra sträng-, pixmap- och rect-typer, och på så sätt ändå inte kunna fungera ihop med &kde;-program. </para> + +<para +>Nå, hur som helst var alltid &arts; avsett att fungera med eller utan &kde;, med eller utan &Qt;, med eller utan X11, och kanske till och med med eller utan &Linux; (och jag har inte ens några invändningar mot personer som anpassar det till operativsystem som inte är fria). </para> + +<para +>Min inställning är att komponenter som inte ingår i ett grafiskt gränssnitt ska skrivas oberoende av detta, för att möjliggöra att de delas mellan ett större antal utvecklare (och användare). </para> + +<para +>Jag inser att använda två <acronym +>IPC</acronym +>-protokoll kan vara obekvämt. Dessutom är båda två inte standardiserade. Av orsakerna som angivits ovan är det inte möjligt att byta till &DCOP;. Om det finns ett betydligt intresse av att hitta ett sätt att förena de två, så kan vi försöka. Vi skulle till och med kunna försöka få &MCOP; att prata <acronym +>IIOP</acronym +>, då skulle vi ha en <acronym +>CORBA</acronym +> <acronym +>ORB</acronym +> ;). </para> + +<para +>Jag pratade en del med Matthias Ettrich om framtiden med de två protokollen, och vi fann många sätt som saker kunde gå vidare. &MCOP; skulle till exempel kunna hantera meddelandekommunikationen i &DCOP;, och på så sätt föra protokollen närmare varandra. </para> + +<para +>Några möjliga lösningar skulle vara: </para> + +<itemizedlist> +<listitem> +<para +>Skriva en portal mellan &MCOP; och &DCOP; (vilket bör vara möjligt, och skulle möjliggöra samkörning). Observera att det finns en experimentell prototyp, om du skulle vilja arbeta med det. </para> +</listitem> + +<listitem> +<para +>Integrera allt &DCOP;-användare förväntar sig i &MCOP;, och försöka bara använda &MCOP; - man skulle kunna lägga till en <quote +>man i mitten</quote +> möjlighet i &MCOP; också ;) </para> +</listitem> + +<listitem> +<para +>Basera &DCOP; på &MCOP; istället för libICE, och långsamt börja integrera saker tätare tillsammans. </para> +</listitem> +</itemizedlist> + +<para +>Den sämsta möjligheten är kanske inte att använda varje protokoll för allt det som det var avsett för (det finns några stora skillnader i målen med deras konstruktion), och inte försöka slå ihop dem till ett. </para> + +</sect1> +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midi.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midi.docbook new file mode 100644 index 00000000000..f8e13ed2f60 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midi.docbook @@ -0,0 +1,524 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="midi"> +<title +>&MIDI;</title> + +<sect1 id="midi-overview"> +<title +>Översikt</title> + +<!-- what-to-say-here: aRts has three roles + * moving midi events around between applications + * abstracting the hardware + * synthesizer --> + +<para +>&MIDI;-stödet i &arts; kan göra ett antal olika saker. För det första, tillåter det <emphasis +>kommunikation</emphasis +> mellan olika delar av programvaran som producerar eller konsumerar &MIDI;-händelser. Om du till exempel har en sequencer och en samplingsenhet som båda använder &arts;, kan &arts; skicka &MIDI;-händelser från sequencern till samplingsenheten. </para> + +<para +>För det andra, kan &arts; också hjälpa program att <emphasis +>växelverka med hårdvaran</emphasis +>. Om en programvarudel (till exempel samplingen) fungerar tillsammans med &arts;, kan den dessutom ta emot &MIDI;-händelser från ett externt &MIDI;-keyboard. </para> + +<para +>Till slut, så utgör &arts; en utmärkt <emphasis +>modulär synthesizer</emphasis +>. Den är konstruerat att göra just detta. Man kan alltså bygga instrument av små moduler med aRts-byggaren, och sedan använda instrumenten för att komponera eller spela musik. Syntes betyder inte nödvändigtvis bara ren syntes, utan det finns moduler som kan användas för att spela upp samplingar. På så sätt kan &arts; vara både en samplingsenhet eller synt, och eftersom den är fullständigt modulär, är den mycket lätt att utöka, mycket lätt att experimentera med, kraftfull och flexibel. </para> +</sect1> + +<sect1 id="midi-manager"> +<title +>&MIDI;-hanteraren</title> +<!-- what-to-say-here: + * how to use artscontrol - view midimanager + * what does autorestore do? (not yet implemented - so not yet documented) --> + +<para +>Den centrala komponenten i &arts; som håller reda på vilka program som är anslutna och hur midi-händelser ska skickas mellan dem är midi-hanteraren. För att se eller påverka vad den gör, starta artscontrol. Välj sedan <menuchoice +><guilabel +>Visa</guilabel +><guilabel +>Visa midihanterare</guilabel +> </menuchoice +> i menyn. </para> + +<para +>Till vänster ser man <guilabel +>Midi-inmatning</guilabel +>. Där listas alla objekt som skapar &MIDI;-händelser, som en extern &MIDI;-port som skickar data från ett anslutet &MIDI;-keyboard, en sequencer som spelar en sång och så vidare. Till höger ser man <guilabel +>Midi-utmatning</guilabel +>. Där listas allting som konsumerar &MIDI;-händelser, som en simulerad samplingsenhet (programvara), eller den externa &MIDI;-porten som en hårdvarusamplingsenhet är ansluten till utanför din dator. Nya program, som en sequencer eller liknande, registrerar sig själva, så att listan ändras med tiden. </para> + +<para +>Du kan ansluta ingångar och utgångar om du markerar en ingång i listan till vänster och en utgång till höger, och väljer <guilabel +>Anslut</guilabel +> med knappen nedanför. <guilabel +>Koppla från</guilabel +> fungerar på samma sätt. Du ser vad som är anslutet som små linjer mellan ingångar och utgångar, mitt i fönstret. Observera att du kan ansluta en ingång till mer än en utgång (och tvärtom). </para> + +<para +>Program (som sequencern Brahms) läggs till av sig själv när de startas och tas bort från listan när de avslutas. Men du kan också lägga till nya enheter med menyn <guilabel +>Lägg till</guilabel +>. </para> + +<variablelist> +<varlistentry> +<term +><guimenuitem +>System midi port (OSS)</guimenuitem +></term> +<listitem> +<para +>Det här skapar ett nytt &arts;-objekt som kommunicerar med en extern midi-port. </para> + +<para +>Eftersom externa midi-portar både kan skicka och ta emot data, så läggs både en ingång och utgång till med det här valet. Med &Linux;, ska du antingen ha en <acronym +>OSS</acronym +>-drivrutin (eller <acronym +>OSS</acronym +>/Free, som följer med &Linux;-kärnan) eller en <acronym +>ALSA</acronym +>-drivrutin installerad för ditt ljudkort, för att det här ska fungera. Du blir tillfrågad om enhetens namn. Det här är oftast <filename class="devicefile" +>/dev/midi</filename +> eller <filename class="devicefile" +>/dev/midi00</filename +>. </para> + +<para +>Om du har mer än en &MIDI;-enhet eller en &MIDI;-återkopplingsenhet installerad, kan det dock finnas fler alternativ. För att visa information om midi-portar, starta inställningscentralen, och välj <menuchoice +><guilabel +>Information</guilabel +> <guilabel +>Ljud</guilabel +></menuchoice +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>aRts syntes midi utmatning</guimenuitem +></term> +<listitem> +<para +>Det här lägger till en ny &MIDI;-utgång med ett &arts; syntinstrument. Om du väljer menyalternativet, dyker en dialogruta upp som låter dig ange ett instrument. Du kan skapa nya instrument med aRts-byggaren. Alla <literal role="extension" +>.arts</literal +>-filer med ett namn som börjar med <filename +>instrument_</filename +> visas här. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> + +<sect1 id="brahms"> +<title +>Att använda &arts; & Brahms</title> + +<para +>I själva verket är det riktigt lätt att komma igång. Du behöver en version av Brahms som fungerar med &kde; 2.1, som finns i <literal +>kmusic</literal +> <acronym +>CVS</acronym +>-modulen. Det finns också information om hur man skaffar &brahms; på <ulink url="http://www.arts-project.org/" +>aRts hemsida</ulink +> i avsnittet om nerladdning. </para> + +<para +>När du har startat programmet, syns det i &MIDI;-hanteraren. Om du vill använda syntes, lägg helt enkelt till ett &MIDI;-instrument med <menuchoice +><guilabel +>Lägg till</guilabel +><guilabel +>aRts syntes midi utmatning</guilabel +></menuchoice +>. </para> + +<para +>Välj ett instrument (till exempel <guilabel +>organ2</guilabel +>). Anslut instrumentet med knappen <guilabel +>Anslut</guilabel +>. Därefter kan du börja komponera i &brahms;, och resultatet syntetiseras med &arts;. </para> + +<para +>Det är oftast en god ide att ha &artscontrol;-fönstret öppet, och se till att volymen inte är för hög (ljudkvaliteten blir sämre när staplarna når den övre gränsen). Nu kan du börja skriva en ny &arts; demo, och när du är klar kan du få den publicerad på aRts-project.org ;-). </para> + +<!-- TODO: how to do more than one instrument in Brahms (hm, not implemented + yet, not documented yet), how to use samples, mapping and so on. These + things need to be implemented, too. --> + +</sect1> + +<sect1 id="midisend"> +<title +>midisend</title> + +<para +><command +>midisend</command +> är ett litet program som låter dig skicka &MIDI;-händelser från skalet. Det registreras som en klient precis som alla andra program. Det enklaste sättet att använda det är att skriva <screen +><prompt +>%</prompt +> <userinput +><command +>midisend</command +> <option +>-f</option +> <parameter +><replaceable +>/dev/midi00</replaceable +></parameter +></userinput +> </screen +> som gör ungefär samma sak som att lägga till en &MIDI;-port i &artscontrol;. (Inte riktigt, därför att <command +>midisend</command +> skickar bara händelser). Skillnaden är att det är till exempel lätt att starta <command +>midisend</command +> på olika datorer (och på det sättet använda nätverkstransparens). </para> + +<para +>Det är också möjligt att låta <command +>midisend</command +> skicka data från <filename class="devicefile" +>stdin</filename +>, vilket du kan använda för att skicka data från program som inte stöder &arts;, så här: <screen +><prompt +>%</prompt +> <userinput +><command +><replaceable +>program_som_skickar_MIDI_händelser_på_standardutmatning</replaceable +></command +> | <command +>midisend</command +> <option +>-f</option +> <option +><replaceable +>-</replaceable +></option +></userinput +></screen> +<!-- TODO: document all options --> +</para> + +</sect1> + +<sect1 id="midi-creating-instruments"> +<title +>Att skapa instrument</title> + +<para +>Sättet som &arts; utför midi-syntes är följande: Det finns strukturer som har ett antal ingångar, där de hämtar frekvensen, anslagsstyrkan (volymen) och en parameter som anger om tangenten fortfarande är nertryckt. Strukturen ska nu syntetisera exakt den tonen med den volymen, och reagera på parametern pressed (där pressed = 1 betyder att användaren håller nere tangenten och pressed = 0 betyder att användaren har släppt tangenten). </para> + +<para +>När &MIDI;-händelser anländer, skapar &arts; nya strukturer för tonerna efter behov, anger parametrarna, och rensar bort dem när de är klara. </para> + +<para +>För att skapa och använda en sådan struktur, ska du göra följande: </para> + +<itemizedlist> +<listitem> +<para +>För att komma igång är det bekvämaste sättet att öppna <filename +>template_Instrument.arts</filename +> i Arts-byggaren. </para> + +<para +>Det här kan åstadkommas genom att använda <menuchoice +><guimenu +>Arkiv</guimenu +><guimenuitem +>Öppna exempel...</guimenuitem +></menuchoice +> och välja <guimenuitem +>template_Instrument</guimenuitem +> i fildialogrutan. Det här skapar en tom struktur med de nödvändiga parametrarna, som du bara behöver <quote +>fylla i</quote +>. </para> +</listitem> + +<listitem> +<para +>För att hantera parametern "pressed", är det praktiskt att använda Synth_ENVELOPE_ADSR, eller om en wav-fil med trumma spelas, spela bara upp den ändå och ignorera parametern. </para> +</listitem> + +<listitem> +<para +>Strukturen ska indikera när den inte behövs längre med utgången <quote +>done</quote +>. Om done är <returnvalue +>1</returnvalue +>, antar &arts; att strukturen kan tas bort. Praktiskt nog så tillhandahåller ADSR-enveloppen en parameter som anger när den är färdig, så du behöver bara ansluta den till done-utgången för strukturen. </para> +</listitem> + +<listitem> +<para +>Du bör döpa om din struktur till något namn som börjar med <filename +>instrument_</filename +>, som <filename +>instrument_piano.arts</filename +> - du bör spara filen med samma namn i katalogen <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +> (där aRts-byggaren normalt sparar filer). </para> +</listitem> + +<listitem> +<para +>Till sist, när du väl har sparat den, kan du använda den med &artscontrol; i &MIDI;-hanteraren.</para> +</listitem> + +<listitem> +<para +>Och din struktur ska förstås spela ljuddata som den skapar via vänster och höger utgång för strukturen, som sedan spelas med ljudhanteraren (du kan se det här i &artscontrol;), så att du till slut kan höra ljudet (eller efterbehandla det med ljudeffekter). </para> +</listitem> +</itemizedlist> + +<para +>Ett bra sätt att lära sig hur man skapar instrument är att öppna ett befintligt instrument med <menuchoice +><guilabel +>Arkiv</guilabel +><guilabel +>Öppna Exempel</guilabel +> </menuchoice +> och se hur det fungerar ;) </para> +</sect1> + +<sect1 id="mapped-instruments"> +<title +>Instrumentkartor</title> + +<para +>Instrumentkartor är instrument som beter sig olika beroende på tonhöjden, programmet, kanalen eller anslagsstyrkan. Man kan till exempel skapa ett piano med fem oktaver, och använda en sampling för varje oktav (med tonhöjden förskjuten i motsvarande mån). Det här låter mycket bättre än att bara använda en sampling. </para> + +<para +>Man kan också bygga en trumkarta, som spelar en särskild trumsampling för varje tangent. </para> + +<para +>Till sist är det mycket användbart om man kombinerar helt olika ljud i en instrumentkarta för olika program. På det här sättet kan man använda sin sequencer, externa keyboard eller en annan &MIDI;-källa för att byta mellan ljud utan att behöva manipulera &arts; under arbetets gång. </para> + +<para +>Ett bra exempel på det här är <filename +>arts_all</filename +>, som helt enkelt kombinerar alla instrument som levereras med &arts; i en karta. På så sätt behöver man bara ange att detta <quote +>instrument</quote +> ska användas en gång i &artscontrol;, och sedan kan man komponera en hel sång i en sequencer utan att överhuvudtaget bry sig om &arts;. Behövs ett annat ljud? Ändra helt enkelt programmet i sequencern, och &arts; tillhandahåller ett nytt ljud. </para> + +<para +>Att skapa sådana kartor är ganska rättframt. Man behöver bara skapa en textfil, och skriva regler som ser ut så här: </para> + +<programlisting +>ON <replaceable +>[ villkor ...]</replaceable +> DO structure=<replaceable +>någon_struktur</replaceable +>.arts +</programlisting> + +<para +>Villkoren kan vara ett eller flera av följande: </para> + +<variablelist> + +<varlistentry> +<term +><option +>pitch</option +></term> + +<listitem> +<para +>Tonhöjden som spelas. Man använder det här om man vill dela instrumentet beroende på tonhöjd. I vårt ursprungliga exempel, skulle ett piano som använder olika samplingar för olika oktaver använda det här som villkor. Man kan ange en enkel tonhöjd, som <userinput +><option +>pitch</option +>=<parameter +>62</parameter +></userinput +> eller ett intervall av tonhöjder, som <userinput +><option +>pitch</option +>=<parameter +>60</parameter +>-<parameter +>72</parameter +></userinput +>. De möjliga tonhöjderna går mellan <parameter +>0</parameter +> och <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>program</option +></term> +<listitem> +<para +>Programmet som är aktivt på kanalen som tonen spelas upp i. Oftast låter sequencern dig välja <quote +>instrument</quote +> via programinställningen. Enkla program eller intervall är tillåtna, dvs. <userinput +><option +>program</option +>=<parameter +>3</parameter +></userinput +> eller <userinput +><option +>program</option +>=<parameter +>3</parameter +>-<parameter +>6</parameter +></userinput +>. Möjliga program går mellan <parameter +>0</parameter +> och <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>channel</option +></term> +<listitem> +<para +>Kanalen som tonen skickas på. Enkla kanaler eller intervall är tillåtna, dvs. <userinput +><option +>channel</option +>=<parameter +>0</parameter +></userinput +> eller <userinput +><option +>channel</option +>=<parameter +>0</parameter +>-<parameter +>8</parameter +></userinput +>. Möjliga kanaler går mellan <parameter +>0</parameter +> och <parameter +>15</parameter +>. </para> +</listitem> + +</varlistentry> +<varlistentry> +<term +><option +>velocity</option +></term> +<listitem> +<para +>Anslagsstyrkan (volymen) som tonen har. Enkla anslagsstyrkor (vem skulle använda det?) eller intervall är tillåtna, dvs. <userinput +><option +>velocity</option +>=<parameter +>127</parameter +></userinput +> eller <userinput +><option +>velocity</option +>=<parameter +>64</parameter +>-<parameter +>127</parameter +></userinput +>. Möjliga anslagsstyrkor går mellan <parameter +>0</parameter +> och <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Ett fullständigt exempel för en karta kan vara (det här kommer från den nuvarande <filename +>instrument_arts_all.arts-map</filename +>): </para> + +<programlisting +>ON program=0 DO structure=instrument_tri.arts +ON program=1 DO structure=instrument_organ2.arts +ON program=2 DO structure=instrument_slide1.arts +ON program=3 DO structure=instrument_square.arts +ON program=4 DO structure=instrument_neworgan.arts +ON program=5 DO structure=instrument_nokind.arts +ON program=6 DO structure=instrument_full_square.arts +ON program=7 DO structure=instrument_simple_sin.arts +ON program=8 DO structure=instrument_simple_square.arts +ON program=9 DO structure=instrument_simple_tri.arts +ON program=10 DO structure=instrument_slide.arts +ON program=11 pitch=60 DO structure=instrument_deepdrum.arts +ON program=11 pitch=61 DO structure=instrument_chirpdrum.arts +</programlisting> + +<para +>Som du ser, väljs strukturen beroende på programmet. För program 11, syns en <quote +>trumkarta</quote +> (med två poster), som spelar en <quote +>deepdrum</quote +> med C-5 (tonhöjd = 60), och en <quote +>chirpdrum</quote +> med C#5 (tonhöjd = 61). </para> + +<para +>För att kartfiler automatiskt ska synas i &artscontrol; som ett alternativ bland instrumenten, måste de heta <filename +>instrument_<replaceable +>någonting</replaceable +>.arts-map</filename +> och antingen finnas i din hemkatalog i <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +>, eller i &kde;-katalogen i <filename class="directory" +>$<envar +>KDEDIR</envar +>/share/apps/artsbuilder/examples</filename +>. Strukturer som används av kartan kan antingen anges med en absolut sökväg, eller relativt till katalogen som kartfilen finns i. </para> + +<para +>Att utöka arts_all map eller till och med göra en fullständigt generell &MIDI;-karta för &arts; är en bra idé för att göra &arts; lättare att använda direkt som det är. Fundera gärna på att bidra med intressanta instrument som du skapar, så att de kan inkluderas i framtida versioner av &arts;. </para> +</sect1> + +<!-- TODO: Maybe helpful + * using an external keyboard + * loopback midi device + +<sect1 id="quick-start"> +<title +>Quick Start</title> + +</sect1> +<sect1 id="internal-details"> +<title +>More Internal Details</title> + +</sect1> + +<sect1 id="other-considerations"> +<title +>Other Considerations</title> + +</sect1> +--> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midiintro.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midiintro.docbook new file mode 100644 index 00000000000..b03d13181bd --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/midiintro.docbook @@ -0,0 +1,16 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE appendix PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<appendix id="midi-introduction"> + +<title +>Introduktion till <acronym +>MIDI</acronym +></title> + +<para +>Ännu inte skrivet. </para> + +</appendix> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/modules.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/modules.docbook new file mode 100644 index 00000000000..16f789108e6 --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/modules.docbook @@ -0,0 +1,1333 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="arts-modules"> +<title +>&arts; moduler</title> + + <sect1 id="modules-introduction"> +<title +>Inledning</title> + +<para +>Det här kapitlet beskriver alla standardmodulerna i &arts;. En av de mest kraftfulla funktionerna i &arts; är att moduler kan kopplas ihop till strukturer som implementerar nya funktioner som ljudeffekter och instrument. </para> + +<para +>Moduler delas upp i två kategorier. Syntesmoduler används för att implementera <quote +>rörmokeriet</quote +> som manipulerar multimediadataflöden för att skapa nya effekter, instrument, mixrar och program. Visuella moduler låter dig skapa ett grafiskt gränssnitt för att styra ljudstrukturer som byggs upp med syntesmodulerna. </para> + +</sect1> + +<sect1 id="synth-modules-reference"> +<title +>Referens till syntesmoduler</title> + + +<sect2 id="mcat-synth-arithmetic-mixing"> +<title +>Aritmetik + mixning</title> + + + +<sect3 id="mref-synth-add-sect"> +<title +>Synth_ADD</title> +<anchor id="mref-synth-add"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_ADD.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_ADD</phrase +></textobject> +</mediaobject> + +<para +>Den här adderar två signaler. </para> + +</sect3> + +<sect3 id="mref-synth-mul-sect"> +<title +>Synth_MUL</title> +<anchor id="mref-synth-mul"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_MUL.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_MUL</phrase +></textobject> +</mediaobject> + +<para +>Den här multiplicerar signalen med en faktor. Du kan använda det här för att skala ner (0 < faktor < 1) eller upp (faktor > 1) signaler eller invertera signaler (faktor < 0). Observera att faktorn kan vara en signal och behöver inte vara konstant (t.ex. envelopper eller flyttalssignaler). </para> + +</sect3> + +<sect3 id="mref-synth-div-sect"> +<title +>Synth_DIV</title> +<anchor id="mref-synth-div"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_DIV.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_DIV</phrase +></textobject> +</mediaobject> + +<para +>Den här dividerar signalen med en faktor. Du kan använda det här för att dividera en signal med en annan, eller ange invärde1 som 1, så får du inversen av invärde2 som utvärde. Försäkra dig om att invärde2 aldrig når 0, annars får du problem med division med noll. </para> + +</sect3> + +<sect3 id="mref-synth-multi-add-sect"> +<title +>Synth_MULTI_ADD</title> +<anchor id="mref-synth-multi-add"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_MULTI_ADD.png" + format="PNG"/></imageobject> +<textobject +><phrase +>Synth_MULTI_ADD</phrase +></textobject> +</mediaobject> + +<para +>Den här adderar ett godtyckligt antal signaler. Om du behöver summera vågformer som skapas av fyra olika oscillatorer, kan du till exempel ansluta alla deras utgångar till en Synth_MULTI_ADD-modul. Det här är effektivare än att använda tre Synth_ADD-moduler. </para> + +</sect3> + +<sect3 id="mref-synth-xfade-sect"> +<title +>Synth_XFADE</title> +<anchor id="mref-synth-xfade"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_XFADE.png" format="PNG"/> +</imageobject> +<textobject +><phrase +>Synth_XFADE</phrase +></textobject> +</mediaobject> + +<para +>Den här övertonar två signaler. Om procentingången är -1, hörs bara vänstra signalen, om den är 1, hörs bara den högra. Om den är 0, hörs båda signalerna med samma volym. </para> + +<para +>Den här gör att du kan försäkra dig om att signalen stannar inom ett väldefinierat område. Om du har två signaler som är mellan -1 och 1 innan övertoningen, kommer de att vara i samma område efteråt. </para> +</sect3> + +<sect3 id="mref-synth-autopanner-sect"> +<title +>Synth_AUTOPANNER</title> +<anchor id="mref-synth-autopanner"/> + +<para +>Motsatsen till övertoning. Den här tar en monosignal och delar den till en stereosignal. Den används för att automatiskt panorera insignalen mellan vänster och höger utgång. Det här gör mixningen mer levande. En standardtillämpning kan vara en gitarr- eller sololjud. </para> + +<para +>Anslut en <acronym +>LFO</acronym +>, till exempel en sinus eller sågtandsvåg till inlfo, och välj en frekvens mellan 0,1 och 5 Hz för att få en traditionell effekt eller ännu mer för specialeffekter (<acronym +>FX</acronym +>). </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-busses"> +<title +>Bussar</title> + +<sect3 id="mref-synth-bus-uplink-sect"> +<title +>Synth_BUS_UPLINK</title> +<anchor id="mref-synth-bus-uplink"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_BUS_UPLINK.png" + format="PNG"/> +</imageobject> +<textobject +><phrase +>Synth_BUS_UPLINK</phrase +></textobject> +</mediaobject> + +<para +>En upplänk till en buss. Ange signaler till vänster och höger, och namnet på bussen som data ska skickas till på <quote +>buss</quote +> porten. Den kombinerade signalen från alla upplänkar med det här namnet hamnar på varje nerlänk på den <quote +>bussen</quote +>. </para> +</sect3> + +<sect3 id="mref-synth-bus-downlink-sect"> +<title +>Synth_BUS_DOWNLINK</title> +<anchor id="mref-synth-bus-downlink"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_BUS_DOWNLINK.png" + format="PNG"/></imageobject> +<textobject +><phrase +>Synth_BUS_DOWNLINK</phrase +></textobject> +</mediaobject> + +<para +>Hämtar (summan av) all data som skickas på en viss buss (med namnet du anger på <quote +>buss</quote +> porten). </para> +</sect3> + +</sect2> + +<!-- TODO AFTER KDE2.1: move freeverb into delays, and rename category to + Delays & reverbs --> + +<sect2 id="mcat-synth-delays"> +<title +>Fördröjningar</title> + + + +<sect3 id="mref-synth-delay-sect"> +<title +>Synth_DELAY</title> +<anchor id="mref-synth-delay"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_DELAY.png" + format="PNG"/></imageobject +></mediaobject> + +<para +>Den här fördröjer insignalen en viss tid. Tidsangivelsen måste vara mellan 0 och maxdelay för en fördröjning mellan 0 och maxdelay sekunder. </para> + +<para +>Den här sortens fördröjning <emphasis +>kan inte användas</emphasis +> i återmatningsstrukturer. Det här beror på att det är en varierbar fördröjning. Det går att ändra längden medan den kör, och även sätta den till noll. Men eftersom den egna utgången behövs för att beräkna nästa sampling i en återmatningsstruktur, kan en fördröjning med ett värde som kan gå ner till noll under syntes leda till en låsningssituation. </para> + +<para +>Använd CDELAY:er i sådana situationer, eller kombinera en kort konstant fördröjning (av 0,001 sekunder) med en variabel fördröjning. </para> + +<para +>Man kan också kombinera en CDELAY och en DELAY för att åstadkomma en fördröjning med variabel längd i en återkoppling. Försäkra dig bara om att du har med en CDELAY. </para> + +</sect3> + +<sect3 id="mref-synth-cdelay-sect"> +<title +>Synth_CDELAY</title> +<anchor id="mref-synth-cdelay"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_CDELAY.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_CDELAY</phrase +></textobject> +</mediaobject> + +<para +>Den här fördröjer insignalen en viss tid. Tidsangivelsen måste vara större än 0 för en fördröjning av 0 sekunder eller mer. Fördröjningen är konstant under beräkningen, vilket betyder att den inte kan ändras. </para> + +<para +>Det här sparar beräkningstid eftersom ingen interpolation görs, och är användbart för rekursiva strukturer. Se beskrivningen ovan (Synth_DELAY). </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-envelopes"> +<title +>Envelopper</title> + + + +<sect3 id="mref-synth-envelope-adsr-sect"> +<title +>Synth_ENVELOPE_ADSR</title> +<anchor id="mref-synth-envelope-adsr"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_ENVELOPE_ADSR.png" + format="PNG"/></imageobject> +<textobject +><phrase +>Synth_ENVELOPE_ADSR</phrase +></textobject> +</mediaobject> + +<para +>Den här är ett klassiskt <acronym +>ADSR</acronym +>-envelopp, som betyder att du anger: </para> + +<variablelist> +<varlistentry> +<term +>active</term> +<listitem> +<para +>Om användaren håller nere tangenten just nu. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>Insignalen. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>attack</term> +<listitem> +<para +>Tiden som ska förflyta mellan användaren trycker på tangenten och signalen når sin maximala amplitud (i sekunder). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>decay</term> +<listitem> +<para +>Tiden som ska förflyta mellan signalen nått sin maximala amplitud och signalen går tillbaka till någon konstant nivå (i sekunder). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>sustain</term> +<listitem> +<para +>Den konstanta nivån som hålls för signalen efteråt, till användaren släpper tangenten. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>release</term> +<listitem> +<para +>Tiden som ska förflyta efter användaren har släppt tangenten till signalen går ner till noll (i sekunder). </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Du får den behandlade signalen som utvärde. När <acronym +>ASDR</acronym +>-enveloppen är klar, sätter den done till 1. Du kan använda det här för att tillhandahålla utgången <quote +>done</quote +> för ett instrument (som gör att instrumentstrukturen tas bort av &MIDI;-reläobjektet när ljudet väl har upphört). </para> + +</sect3> + +<sect3 id="mref-synth-pscale-sect"> +<title +>Synth_PSCALE</title> +<anchor id="mref-synth-pscale"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_PSCALE.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_PSCALE</phrase +></textobject> +</mediaobject> + +<para +>Modulen Synth_PSCALE anpassar ljudflödet som skickas genom den från volymen 0 (tyst) till 1 (ursprunglig volym) tillbaka till 0 (tyst), enligt positionen (hämta positionen från en Synth_SEQUENCE). Positionen där toppen ska vara kan anges som top. </para> + +<para +>Att till exempel sätta top till 0,1 betyder att efter 10 % av tonen har spelats, har volymen nått maximalt värde, och börjar sedan avta. </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-effects"> +<title +>Effekter</title> + +<sect3 id="mref-synth-freeverb-sect"> +<title +>Synth_FREEVERB</title> +<anchor id="mref-synth-freeverb"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_FREEVERB.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_FREEVERB</phrase +></textobject> +</mediaobject> + +<para +>Det här är en efterklangseffekt. I den nuvarande implementeringen är det tänkt att skicka en stereosignal genom modulen, och den lägger till efterklangseffekten i signalen. </para> + +<note> +<para +>Det här betyder att den också kan användas inne i en StereoEffectStack. </para> +</note> + +<para +>Insignalen ska anslutas till (inleft, inright), och utsignalen blir (outleft, outright). </para> + +<para +>Parametrarna som du kan ställa in är: </para> + +<variablelist> +<varlistentry> +<term +>roomsize</term> +<listitem> +<para +>Storleken på rummet som efterklangseffekten simulerar (område: 0 .. 1, där 1 är det största möjliga rummet). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>damp</term> +<listitem> +<para +>Det här anger ett filter som gör att det simulerade rummet absorberar höga frekvenser (område 0 .. 1, där 1 betyder absorbera höga frekvenser i stor utsträckning). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>wet</term> +<listitem> +<para +>Storleken på efterklangsignalen (dvs. den del av signalen som ska ändras av filtret, och orsaka ett <quote +>vått</quote +> ljud, dvs. ett <quote +>efterklangsljud</quote +>). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>dry</term> +<listitem> +<para +>Storleken på ren signal som skickas igenom, som orsakar ett eko (eller kombinerad fördröjning) istället för en efterklangseffekt (område: 0 .. 1). </para> +<!-- TODO: do some measurements to show that this documentation -is- correct, +I am not sure if it is echo, or really pure (non-delayed), or multiple delay +or whatever --> +</listitem> +</varlistentry> + +<varlistentry> +<term +>width</term> +<listitem> +<para +>Storleken på utökad stereoeffekt som efterklangsalgoritmen lägger till i efterklangseffekten, för att göra efterklangsljudet bredare i stereoljudbilden (område 0 .. 1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mode</term> +<listitem> +<para +>[ATT GÖRA: Jag tror att om mode är 1, behåller efterklangen den nuvarande ljudbilden för ljudet, medan 0 är normal behandling] </para> +</listitem> +</varlistentry> +</variablelist> + +</sect3> + +<sect3 id="mref-synth-tremolo-sect"> +<title +>Synth_TREMOLO</title> +<anchor id="mref-synth-tremolo"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_TREMOLO.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_TREMOLO</phrase +></textobject> +</mediaobject> + +<para +>Tremolomodulen modulerar amplituden enligt en <acronym +>LFO</acronym +>-vågform. Traditionellt använder man en sinusvåg, men varför begränsa sig? Vad man får är en mycket intensiv effekt som skär igenom de flesta arrangemang på grund av sitt stora dynamiska omfång. Tremoloeffekten är fortfarande en favoriteffekt bland gitarrister, även om den inte är så populär som på 1960-talet. </para> + +<para +>[ATT GÖRA: för närvarande implementeras detta som invalue + abs(inlfo) - kanske skulle det vara vettigare att implementera det som invalue * (1+inlfo*depth), där depth skulle vara en parameter mellan 0 .. 1 - det här bestäms efter &kde;2.1. Om du har en kommentar, skicka e-post till &arts; e-postlista ;). ] </para> + +</sect3> +<sect3 id="mref-synth-fx-cflanger-sect"> +<title +>Synth_FX_CFLANGER</title> +<anchor id="mref-synth-fx-cflanger"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_FX_CFLANGER.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_FX_CFLANGER</phrase +></textobject> +</mediaobject> + +<para +>En fläns är en tidsvariabel fördröjningseffekt. För att göra utveckling av komplexa flänseffekter enklare, tillhandahålls den här modulen som innehåller kärnan av en enkanals flänsenhet. </para> + +<para +>Den har följande portar:</para> + +<variablelist> +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>Signalen som du vill behandla. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>lfo</term> +<listitem> +<para +>Helst en sinusvåg som modulerar fördröjningstiden inne i flänsen (-1 .. 1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mintime</term> +<listitem> +<para +>Minimala värdet för tiden inne i flänsen i millisekunder. Föreslagna värden: försök med något nära 1 ms. Använd helst värden < 1000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>maxtime</term> +<listitem> +<para +>Maximala värdet för tiden inne i flänsen i millisekunder. Föreslagna värden: försök med något nära 5 ms. Använd helst värden < 1000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>outvalue</term> +<listitem> +<para +>Utsignalen. Det är viktigt att du blandar den här med originalsignalen (innan flänsen) för att få den önskade effekten. </para> +</listitem> +</varlistentry> +</variablelist> + +<tip> +<para +>Du kan använda den här som en grund för köreffekter. </para> +</tip> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-filters"> +<title +>Filter</title> + +<sect3 id="mref-synth-pitch-shift-sect"> +<title +>Synth_PITCH_SHIFT</title> +<anchor id="mref-synth-pitch-shift"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_PITCH_SHIFT.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_PITCH_SHIFT</phrase +></textobject> +</mediaobject> + +<para +>Den här tonhöjdsförändrande effekten ändrar frekvensen på insignalen utan att påverka hastigheten. En tillämpning av detta är att till exempel ändra tonhöjden på din röst medan du spelar in (och spelar upp) den i realtid. </para> + +<para +>Parametern <emphasis +>speed</emphasis +> är den relativa hastigheten som signalen spelas upp med. Så att med hastigheten två blir ljudet dubbelt så högt (dvs. en infrekvens på 440 Hz ger en utfrekvens på 880 Hz). </para> + +<para +>Parametern <emphasis +>frequency</emphasis +> används internt för att ändra mellan olika kornighet i signalen. Den är anpassningsbar, och beroende på valet kommer tonhöjdsförändringen låta mer eller mindre realistisk vid en viss användning. Ett bra värde att börja med är någonting i stil med 5 eller 10. </para> + +</sect3> + +<sect3 id="mref-synth-shelve-cutoff-sect"> +<title +>Synth_SHELVE_CUTOFF</title> +<anchor id="mref-synth-shelve-cutoff"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_SHELVE_CUTOFF.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_SHELVE_CUTOFF</phrase +></textobject> +</mediaobject> + +<para +>Filtrerar bort alla frekvenser över klippningsfrekvensen. </para> + +</sect3> + +<sect3 id="mref-synth-brickwall-limiter-sect"> +<title +>Synth_BRICKWALL_LIMITER</title> +<anchor id="mref-synth-brickwall-limiter"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_BRICKWALL_LIMITER.png" + format="PNG"/></imageobject> +<textobject +><phrase +>Synth_BRICKWALL_LIMITER</phrase +></textobject> +</mediaobject> + +<para +>Den här modulen klipper en signal så att den passar i området [-1;1]. Den gör ingenting för att begränsa distorsionen som uppstår när en stark signal klipps av. Man kan använda det här som en ljudeffekt (till exempel för att skapa en något avklippt sinusvåg). Det är dock oftast en god idé att låta signalen gå genom ett lågpassfilter efteråt om du gör detta, för att få ljudet att låta mindre skärande. </para> +</sect3> + +<sect3 id="mref-synth-std-equalizer-sect"> +<title +>Synth_STD_EQUALIZER</title> +<anchor id="mref-synth-std-equalizer"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_STD_EQUALIZER.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_STD_EQUALIZER</phrase +></textobject> +</mediaobject> + +<para +>Den här är ett trevligt byggblock för en parametriserbar tonkontroll. Dess parametrar är: </para> + +<variablelist> +<varlistentry> +<term +>Invärde, utvärde</term> +<listitem> +<para +>Signalen som filtreras av tonkontrollen. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>low</term> +<listitem> +<para +>Hur låga frekvenser ska ändras. Värdet anges i dB, medan 0 betyder att låga frekvenser inte ska ändras, skulle -6 betyda att de dämpas med 6 dB, och +6 betyder öka dem med 6 dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mid</term> +<listitem> +<para +>Hur mittfrekvenser ska ändras av tonkontrollen i dB (se low). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>high</term> +<listitem> +<para +>Hur höga frekvenser ska ändras av tonkontrollen i dB (se low). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>frekvens</term> +<listitem> +<para +>Det här är mittfrekvensen för tonkontrollen i Hz, mittfrekvensen befinner sig omkring detta spektrum, med de låga och höga frekvenserna nedanför och ovanför. Observera att frekvensen inte kan vara högre än halva samplingsfrekvensen, oftast är den 22050 Hz, och inte lägre än 1 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>q</term> +<listitem> +<para +>Det här påverkar hur brett mittspektrat är. Det måste vara ett positivt tal > 0. Värdet ett är rimligt, högre värden på q betyder ett smalare spektrum av mittfrekvenser. Lägre värden än ett betyder ett bredare spektrum. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect3> + +<sect3 id="mref-synth-rc-sect"> +<title +>Synth_RC</title> +<anchor id="mref-synth-rc"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_RC.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_RC</phrase +></textobject> +</mediaobject> + +<para +>Ett dämpat resonansfilter som filtrerar alla frekvenser omkring något högsta värde. Det finns inget användbart sätt att ange en mittfrekvens (som inte skulle klippas), eftersom indata är två underliga konstanter f och b. Koden är mycket gammal, från synthesizerns tidigaste dagar, och kommer troligen att bytas ut mot ett nytt filter som har en frekvens och ett resonansvärde som parametrar. </para> + +<para +>Försök med något som liknar b=5, f=5 or b=10, f=10 or b=15, f=15 i alla fall. </para> + +</sect3> + +<sect3 id="mref-synth-moog-vcf-sect"> +<title +>Synth_MOOG_VCF</title> +<anchor id="mref-synth-moog-vcf"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_MOOG_VCF.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_MOOG_VCF</phrase +></textobject> +</mediaobject> + +<para +>Filtrerar bort alla frekvenser ovanför klippningsfrekvensen (det är ett 24 dB fyrpoligt filter, som filtrerar 24 dB per oktav ovanför klippningsfrekvensen), men tillhandahåller en ytterligare parameter för att anpassa filtrets resonans, där 0 betyder ingen resonans och 4 betyder självsvängning. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-midi-sequencing"> +<title +>Midi + sekvensiering</title> + +<sect3 id="mref-synth-midi-test-sect"> +<title +>Synth_MIDI_TEST</title> +<anchor id="mref-synth-midi-test"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_MIDI_TEST.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_MIDI_TEST</phrase +></textobject> +</mediaobject> + +<para +>Den här modulen laddar en instrumentstruktur från en fil, och registrerar sig som en midi-utgång med &arts; &MIDI;-hanterare. Toner som skickas till den här utgången gör att instrumentröster skapas. </para> + +<note> +<para +>Du kan ställa in något sådant här på ett bekvämare sätt i &artscontrol; istället för manuellt i aRts-byggaren. </para> +</note> + +</sect3> + +<sect3 id="mref-synth-sequence-sect"> +<title +>Synth_SEQUENCE</title> +<anchor id="mref-synth-sequence"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_SEQUENCE.png" +format="PNG"/></imageobject +></mediaobject> + +<para +>Spelar en sekvens av toner om och om igen. Tonerna anges i spårnotation, och separeras av semikolon. Ett exempel är <literal +>A-3;C-4;E-4;C-4;</literal +>. Hastigheten anges som sekunder per ton, så om du vill ange 120 slag per minut, anger du troligen 0,5 sekunder/ton, som 60 sekunder/0,5 sekunder per ton = 120 slag per minut. </para> + +<para +>Du kan ge varje ton en längd i förhållande till hastigheten genom att använda ett kolon efter tonen följt av längden. <literal +>A-3:2;C-4:0.5;D-4:0.5;E-4;</literal +> visar detta. Som du kan se, tenderar midi-tonsättningsprogram att ge mer bekvämlighet ;) </para> + +<para +>Synth_SEQUENCE ger ytterligare information om positionen för tonen som spelas just nu, där 0 betyder precis påbörjad och 1 betyder avslutad. Den här informationen kan man använda med Synth_PSCALE (se nedan). </para> +</sect3> + +<sect3 id="mref-synth-sequence-freq-sect"> +<title +>Synth_SEQUENCE_FREQ</title> +<anchor id="mref-synth-sequence-freq"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_SEQUENCE_FREQ.png" +format="PNG"/></imageobject +></mediaobject> + +<para +>Den här modulen fungerar precis som Synth_SEQUENCE, med den enda skillnaden att du inte skriver in notnamn utan frekvenser. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-samples"> +<title +>Samplingar</title> + +<sect3 id="mref-synth-play-wav-sect"> +<title +>Synth_PLAY_WAV</title> +<anchor id="mref-synth-play-wav"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_PLAY_WAV.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_PLAY_WAV</phrase +></textobject> +</mediaobject> + +<para +>Den här spelar en <literal role="extension" +>wav</literal +>-fil. Den är bara tillgänglig om du har libaudiofile på datorn. Vågformsfilen spelas så fort modulen skapas. </para> + +<para +>Den stannar så fort den är klar, och done sätts till 1. Hastighetsparametern kan användas för att spela upp filen snabbare eller långsammare, där 1.0 är den normala (inspelade) hastigheten. </para> +<!-- TODO: KDE2.2: check that this really works together in instruments with +the done parameter things ;) --> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-soundio"> +<title +>Ljud-I/O</title> + +<sect3 id="mref-synth-play-sect"> +<title +>Synth_PLAY</title> +<anchor id="mref-synth-play"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_PLAY.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_PLAY</phrase +></textobject> +</mediaobject> + +<important> +<para +>Normalt behöver man inte den här modulen, om man inte skriver självständiga program. Inne i &artsd;, finns det redan en Synth_PLAY modul, och att skapa en till fungerar inte. </para> +</important> + +<para +>Modulen Synth_PLAY-matar ut ljudsignalen till ljudkortet. Vänster och höger kanal ska innehålla <emphasis +>normaliserad</emphasis +> indata för kanalerna. Om indata inte är mellan -1 och 1, får man klippning. </para> + +<para +>Som redan har nämnts, får det bara finnas en Synth_PLAY modul, eftersom den direkt kommer åt ljudkortet. Använd bussar för att blanda ihop mer än ett ljudflöde innan uppspelning. Använd modulen Synth_AMAN_PLAY för att få något som liknar en utmatning inne i &artsd;. </para> + +<para +>Observera att Synth_PLAY också kontrollerar tidbasen för hela strukturen. Det här betyder: ingen Synth_PLAY = ingen källa för tidbas = inget ljud. Så det behövs (exakt) ett Synth_PLAY objekt. </para> + +</sect3> + +<sect3 id="mref-synth-record-sect"> +<title +>Synth_RECORD</title> +<anchor id="mref-synth-record"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_RECORD.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_RECORD</phrase +></textobject> +</mediaobject> + +<important> +<para +>Normalt behöver man inte den här modulen, om man inte skriver självständiga program. Inne i artsd, finns det redan en Synth_RECORD modul, och att skapa en till fungerar inte. </para> +</important> + +<para +>Modulen Synth_RECORD spelar in en signal från ljudkortet. Vänster och höger kanal innehåller indata för kanalerna (mellan -1 och 1). </para> + +<para +>Som redan har nämnts, får det bara finnas en Synth_RECORD modul, eftersom den direkt kommer åt ljudkortet. Använd bussar för att använda det inspelade ljudflödet på mer än ett ställe. Använd modulen Synth_AMAN_RECORD för att få något som liknar en ingång inne i artsd. För att det här ska fungera måste &artsd; köra <emphasis +>med full duplex aktiverad</emphasis +>. </para> +</sect3> + +<sect3 id="mref-synth-aman-play-sect"> +<title +>Synth_AMAN_PLAY</title> +<anchor id="mref-synth-aman-play"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_AMAN_PLAY.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_AMAN_PLAY</phrase +></textobject> +</mediaobject> + +<para +>Modulen Synth_AMAN_PLAY-matar ut ljudsignalen. Det är bra (men inte nödvändigt) att utdata är en normaliserad signal (mellan -1 och 1). </para> + +<para +>Den här modulen använder ljudhanteraren för att ange var signalen spelas upp. Ljudhanteraren kan styras genom &artscontrol;. För att göra det mer intuitivt att använda, är det bra att namnge signalen som spelas upp. Det kan åstadkommas genom att ange <emphasis +>title</emphasis +>. En annan funktion i ljudhanteraren är att kunna komma ihåg var en signal spelades upp sist. För att kunna göra det här måste den kunna skilja på signaler. Därför ska man ange något unikt värde för <emphasis +>autoRestoreID</emphasis +> också. </para> +</sect3> + +<sect3 id="mref-synth-aman-record-sect"> +<title +>Synth_AMAN_RECORD</title> +<anchor id="mref-synth-aman-record"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_AMAN_RECORD.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_AMAN_RECORD</phrase +></textobject> +</mediaobject> + +<para +>Modulen Synth_AMAN_RECORD-spelar in en ljudsignal från en extern källa (dvs linje in/mikrofon) inne i &artsd;. Utdata kommer att vara en normaliserad signal (mellan -1 och 1). </para> + +<para +>Den här modulen använder ljudhanteraren för att ange var signalen spelas upp. Ljudhanteraren kan styras genom artscontrol. För att göra det mer intuitivt att använda, är det bra att namnge signalen som spelas upp. Det kan åstadkommas genom att ange <emphasis +>title</emphasis +>. En annan funktion i ljudhanteraren är att kunna komma ihåg var en signal spelades in sist. För att kunna göra det här måste den kunna skilja på signaler. Därför ska man ange något unikt värde för <emphasis +>autoRestoreID</emphasis +> också. </para> +</sect3> + +<sect3 id="mref-synth-capture-sect"> +<title +>Synth_CAPTURE</title> +<anchor id="mref-synth-capture"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_CAPTURE.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_CAPTURE</phrase +></textobject> +</mediaobject> + +<para +>Modulen Synth_CAPTURE skriver en ljudsignal till en vågformsfil på hårddisken. Filen heter alltid <filename +>/tmp/mcop-<replaceable +>användarnamn</replaceable +>/capture.wav</filename +> </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-tests"> +<title +>Tester</title> + +<sect3 id="mref-synth-nil-sect"> +<title +>Synth_NIL</title> +<anchor id="mref-synth-nil"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_NIL.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_NIL</phrase +></textobject> +</mediaobject> + +<para +>Den här gör ingenting. Den är mycket användbar i testsituationer. </para> + +</sect3> + +<sect3 id="mref-synth-debug-sect"> +<title +>Synth_DEBUG</title> +<anchor id="mref-synth-debug"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_DEBUG.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_DEBUG</phrase +></textobject> +</mediaobject> + +<para +>Man kan använda den här för avlusning. Den skriver ut värdet för signalen invalue med regelbundna intervall (cirka 1 sekund), tillsammans med kommentaren som angivits. På det här sättet kan man ta reda på om vissa signaler förblir inom vissa områden, eller om de finns överhuvudtaget. </para> +</sect3> + +<sect3 id="mref-synth-midi-debug-sect"> +<title +>Synth_MIDI_DEBUG</title> +<anchor id="mref-synth-midi-debug"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_MIDI_DEBUG.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_MIDI_DEBUG</phrase +></textobject> +</mediaobject> + +<para +>Man kan använda den här för att avlusa hur &MIDI;-händelser verkligen kommer in i &arts;. </para> + +<para +>När en MIDI_DEBUG kör, skriver &artsserver; ut rader som: </para> + +<screen +><computeroutput +>201 100753.837585 on 0 42 127</computeroutput +></screen> + +<screen +><computeroutput +>202 101323.128355 off 0 42</computeroutput +></screen> + +<para +>Den första raden talar om att 100753 ms (dvs. 100 sekunder) efter MIDI_DEBUG startade, kom en &MIDI;-händelse "on" på kanal 0. Den här midi-händelsen hade anslagsstyrkan (volymen) 127, den högsta möjliga. Nästa rad visar midi-händelsen när tangenten släpps. [ATT GÖRA: det här fungerar inte för närvarande, få det att fungera, och gör det via &MIDI;-hanteraren]. </para> +</sect3> + +<sect3 id="mref-synth-data-sect"> +<title +>Synth_DATA</title> +<anchor id="mref-synth-data"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_DATA.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_DATA</phrase +></textobject> +</mediaobject> + +<para +>Det här skapar en signal med ett konstant värde. </para> +<!-- TODO: this doesn't really belong in test, does it? --> +</sect3> +</sect2> + +<sect2 id="mcat-synth-osc-mod"> +<title +>Oscillation & Modulation</title> + +<sect3 id="mref-synth-frequency-sect"> +<title +>Synth_FREQUENCY</title> +<anchor id="mref-synth-frequency"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_FREQUENCY.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_FREQUENCY</phrase +></textobject> +</mediaobject> + +<para +>Oscillatorer i &arts; kräver inte en frekvens som indata, utan istället en position i vågformen. Positionen ska vara mellan 0 och 1, som i ett standardobjekt Synth_WAVE_SIN översätts till området 0 .. 2*Pi. För att skapa oscillerande värden från en frekvens, används en Synth_FREQUENCY modul. </para> +</sect3> + +<sect3 id="mref-synth-fm-source-sect"> +<title +>Synth_FM_SOURCE</title> +<anchor id="mref-synth-fm-source"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_FM_SOURCE.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_FM_SOURCE</phrase +></textobject> +</mediaobject> + +<para +>Den här används för frekvensmodulering. Ange frekvensen med ingången frequency och anslut en annan signal till moduleringsingången. Ställ därefter in modlevel till någonting, säg 0,3. Frekvensen moduleras sedan med moduleringen. Prova det. Fungerar bra om man lägger till en återkoppling, vilket betyder att man tar en kombination av den fördröjda utsignalen från Synth_FM_SOURCE (man måste skicka det till en oscillator eftersom den bara fungerar som Synth_FREQUENCY) och någon annan signal för att få bra resultat. </para> + +<para +>Fungerar bra tillsammans med Synth_WAVE_SIN oscillatorer. </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-waveforms"> +<title +>Vågformer</title> + +<sect3 id="mref-synth-wave-sin-sect"> +<title +>Synth_WAVE_SIN</title> +<anchor id="mref-synth-wave-sin"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_WAVE_SIN.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_WAVE_SIN</phrase +></textobject> +</mediaobject> + +<para +>Sinusoscillator. Ange en pos signal från Synth_FREQUENCY eller Synth_FM_SOURCE som insignal, och få en sinusvåg som utsignal. Signalen pos anger positionen i vågformen, området 0 .. 1 omvandlas till 0 .. 2*Pi internt. </para> + +</sect3> + +<sect3 id="mref-synth-wave-tri-sect"> +<title +>Synth_WAVE_TRI</title> +<anchor id="mref-synth-wave-tri"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_WAVE_TRI.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_WAVE_TRI</phrase +></textobject> +</mediaobject> + +<para +>Triangelvågsoscillator. Ange en pos signal från Synth_FREQUENCY eller Synth_FM_SOURCE som insignal, och få en triangelvåg som utsignal. Signalen pos anger positionen i vågformen, området 0 .. 1 omvandlas till 0 .. 2*Pi internt. Var försiktig. Insignalen <emphasis +>måste</emphasis +> vara i området 0 .. 1 för att utsignalen ska ge bra resultat. </para> +</sect3> + +<sect3 id="mref-synth-noise-sect"> +<title +>Synth_NOISE</title> +<anchor id="mref-synth-noise"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_NOISE.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_NOISE</phrase +></textobject> +</mediaobject> + +<para +>Brusgenerator. Den här skapar en slumpmässig signal mellan -1 och 1. </para> + +</sect3> + +<sect3 id="mref-synth-wave-square-sect"> +<title +>Synth_WAVE_SQUARE</title> +<anchor id="mref-synth-wave-square"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_WAVE_SQUARE.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_WAVE_SQUARE</phrase +></textobject> +</mediaobject> + +<para +>Fyrkantvågsoscillator. Ange en pos signal från Synth_FREQUENCY eller Synth_FM_SOURCE som insignal, och få en fyrkantvåg som utsignal. Signalen pos anger positionen i vågformen, området 0 .. 1 omvandlas till 0 .. 2*Pi internt. Var försiktig. Insignalen <emphasis +>måste</emphasis +> vara i området 0 .. 1 för att utsignalen ska ge bra resultat. </para> +</sect3> + +<sect3 id="mref-synth-wave-softsaw-sect"> +<title +>Synth_WAVE_SOFTSAW</title> +<anchor id="mref-synth-wave-softsaw"/> + +<mediaobject +><imageobject +><imagedata +fileref="images/Synth_WAVE_SOFTSAW.png" format="PNG"/></imageobject> +<textobject +><phrase +>Synth_WAVE_SOFTSAW</phrase +></textobject> +</mediaobject> + +<para +>Mjuk sågtandsvåg, som liknar Synth_WAVE_TRI oscillatorn till utseende. Ange en pos signal från Synth_FREQUENCY eller Synth_FM_SOURCE som insignal, och få en mjuk sågtandsvåg som utsignal. Signalen pos anger positionen i vågformen, området 0 .. 1 omvandlas till 0 .. 2*Pi internt. Var försiktig. Insignalen <emphasis +>måste</emphasis +> vara i området 0 .. 1 för att utsignalen ska ge bra resultat. </para> +</sect3> + +<sect3 id="mref-synth-wave-pulse-sect"> +<title +>Synth_WAVE_PULSE</title> +<anchor id="mref-synth-wave-pulse"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_WAVE_PULSE.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_WAVE_PULSE</phrase +></textobject> +</mediaobject> + +<para +>Pulsoscillator. Andemeningen med den här modulens liknar den rektangulära oscillatorn (Synth_WAVE_RECT), men den tillhandahåller ett anpassningsbart upp/ner-förhållande, genom parametern <emphasis +>dutycycle</emphasis +>. Ange en pos signal från Synth_FREQUENCY eller Synth_FM_SOURCE som insignal, och få en pulsvåg som utsignal. Signalen pos anger positionen i vågformen, området 0 .. 1 omvandlas till 0 .. 2*Pi internt. Var försiktig. Insignalen <emphasis +>måste</emphasis +> vara i området 0 .. 1 för att utsignalen ska ge bra resultat. </para> +</sect3> +</sect2> +<sect2 id="mcat-synth-misc"> +<title +>Diverse</title> + +<sect3 id="mref-synth-compressor-sect"> +<title +>Synth_COMPRESSOR</title> +<anchor id="mref-synth-compressor"/> + +<mediaobject> +<imageobject +><imagedata fileref="images/Synth_COMPRESSOR.png" + format="PNG"/></imageobject +></mediaobject> + +<para +>Den här modulen reducerar det dynamiska omfånget hos en signal. Reduktion är till exempel användbart för att kompensera för de stora variationer i ljudstyrka när någon pratar i en mikrofon. </para> + +<para +>Så fort indatanivån överstiger en viss nivå (tröskeln) så reduceras signalen. Den multiplicerar helt enkelt allt ovanför tröskeln med ratio, som ska vara ett värde mellan 0 och 1. Till sist multipliceras hela signalen med utdatafaktorn. </para> + +<para +>Argumenten attack och release fördröjer starten och slutet på reduktionen. Använd det här om du till exempel fortfarande vill höra den starka början av en bastrumma. Argumenten anges i millisekunder, och en attack eller release på 0 ms är möjlig, men kan resultera i ett visst brus. </para> + +</sect3> +</sect2> +</sect1> + +<sect1 id="visual-modules-reference"> +<title +>Referens till visuella moduler</title> + +<para +>ATT GÖRA när visuella moduler är "färdigare". </para> +</sect1> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/porting.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/porting.docbook new file mode 100644 index 00000000000..4cec99f2c2b --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/porting.docbook @@ -0,0 +1,50 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="porting"> +<title +>Ändra program för att passa &arts;</title> + +<sect1 id="using-artsdsp"> +<title +>Att använda &artsdsp;</title> + +<para +>Verktyget &artsdsp;, <link linkend="artsdsp" +>tidigare beskrivet</link +>, låter de flesta äldre ljudprogram som pratar direkt med ljudenheter fungera riktigt med &arts;. Program som är skrivna för att använda Enlightenment Sound Daemon (<application +>esd</application +>) fungerar också i de flesta fall genom att köra <application +>esd</application +> med &artsdsp;. </para> + +<para +>Det här ger en bra lösning på kort sikt för att ändra befintliga program för &kde;. Det här låter dock inte programmet direkt dra nytta av hela &arts; kraftfulla funktioner, som att använda moduler och andra multimediatyper än digitalljud. Om programmet gör mer än att bara helt enkelt spela ljudfiler, är det oftast vettigt att lägga till inbyggt stöd för &arts; i programmet. </para> + +<para +>Att använda &arts; betyder också att programmet inte behöver göra så mycket arbete - det kan dra nytta av funktioner i &arts; för att hantera saker som kodning för olika mediaformat och kontroll av ljudhårdvara. </para> + +</sect1> + +<sect1 id="adding-native-arts-support"> +<title +>Lägga till inbyggt stöd för &arts;</title> + +<para +>När du använder &arts;, finns det ett antal olika <link linkend="arts-apis" +>programmeringsgränssnitt</link +> (<acronym +>API</acronym +>) att välja bland. Beslutet om vilket som ska användas beror på ett antal olika faktorer, bland annat vilket sorts medietyp som används (ljud, &MIDI;, ljud-CD, etc.), de funktioner som krävs av gränssnittet, och om programmet är skrivet i C++. I de flesta fall bör valet vara ganska klart baserat på de nödvändiga funktionerna. </para> + +<para +>För flyttbarhet mellan plattformar kan inte program som måste kunna köra i andra miljöer än &kde; förlita sig på att &arts; är tillgängligt. Att använda en insticksprogramparadigm är ett bra sätt att stödja olika multimediamiljöer. Att göra ett insticksprogram-<acronym +>API</acronym +> öppet och dokumenterat (särskilt för program utan tillgång till källkod) har också fördelen att någon annan än programutvecklaren kan implementera insticksprogram till &arts;. </para> + +</sect1> + +</chapter> + diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/references.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/references.docbook new file mode 100644 index 00000000000..b41e3531d4f --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/references.docbook @@ -0,0 +1,61 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="references"> +<title +>Referenser</title> + +<variablelist> + +<varlistentry> +<term +><ulink +url="http://multimedia.kde.org" +>http://multimedia.kde.org</ulink +></term> +<listitem> +<para +>Det här är den huvudsakliga webbplatsen för &kde;-relaterad multimediainformation. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><ulink +url="http://www.arts-project.org" +>http://www.arts-project.org</ulink +></term> +<listitem> +<para +>Det här är &arts;-projektets hemsida. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>&kde; 2.0 Development</term> +<listitem> +<para +>Kapitel 14 i den här utgivna boken täcker multimedia, inklusive &arts;. Den är tillgänglig i tryck eller på nätet med anteckningar på <ulink url="http://www.andamooka.org/" +>http://www.andamooka.org</ulink +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term> +<ulink +url="http://sound.condorow.net" +>http://sound.condorow.net</ulink +></term> +<listitem> +<para +>Den här platsen har en uttömmande lista på ljud- och &MIDI;-program för &Linux;. </para> +</listitem> +</varlistentry> + +</variablelist> + +</chapter> diff --git a/tde-i18n-sv/docs/kdemultimedia/artsbuilder/tools.docbook b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/tools.docbook new file mode 100644 index 00000000000..9ce4c2ed33c --- /dev/null +++ b/tde-i18n-sv/docs/kdemultimedia/artsbuilder/tools.docbook @@ -0,0 +1,997 @@ +<!-- +<?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> + +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="arts-tools"> +<title +>&arts;-verktyg</title> + +<para +>Ett antal verktyg levereras tillsammans med &arts; för att styra och anpassa dess beteende. Du behöver känna till de flesta av de här verktygen lite grand för att kunna använda &arts; på ett effektivt sätt. Det här avsnittet beskriver vart och en av verktygen och deras kommandoväljare. </para> + +<sect1 id="kde-control-center"> +<title +>Inställningscentralen</title> + +<para +>När man kör &arts; med &kde;, tillhandahåller inställningscentralen en grupp med inställningar i kategorin <guilabel +>Ljud</guilabel +>. Vissa av de här används av &arts;. Man kan också binda ljud till olika fönsterhanterings- och &kde;-händelser med dialogrutan <menuchoice +><guilabel +>Ljud</guilabel +><guilabel +>Systemunderrättelser</guilabel +></menuchoice +>. Se handboken för inställningscentralen för mer information om hur dialogrutans inställningar används. </para> + +</sect1> + +<sect1 id="artsd"> +<title +>&artsd;</title> + +<para +>Tillgången till ljudhårdvaran kontrolleras av &artsd;, ljudservern för &arts;. Det här tillåter att flera program samtidigt skickar en begäran till servern, där de kan blandas och spelas upp. Utan en central ljudserver skulle ett enstaka program som använder en ljudenhet förhindra andra program från att använda den. </para> + +<para +>För att använda &arts; ska det finnas en och endast en kopia av &artsd; som kör. Den startas typiskt när &kde; startas om detta är aktiverat i inställningscentralens <guilabel +>Ljudserver</guilabel +> modul. </para> + +<para +>Programmet accepterar följande väljare:</para> + +<!-- LW: FIX THIS --> + +<cmdsynopsis +><command +>artsd</command +> <group choice="opt" +> <option +>-n</option +> <option +>-p</option +> <option +>-N</option +> <option +>-W <replaceable +>n</replaceable +></option +> </group +> <group choice="opt" +> <option +>-a <replaceable +>audiomethod</replaceable +></option +> <option +>-r <replaceable +>sampling rate</replaceable +></option +> <option +>-b <replaceable +>bits</replaceable +></option +> <option +>-d</option +> <option +>-D <replaceable +>devicename</replaceable +></option +> <option +>-F <replaceable +>fragments</replaceable +></option +> <option +>-S <replaceable +>size</replaceable +></option +> <option +>-s <replaceable +>seconds</replaceable +></option +> <option +>-m <replaceable +>appName</replaceable +></option +> </group +> <group choice="opt" +> <option +>-h</option +> <option +>-A</option +> <option +>-v</option +> <option +>-l <replaceable +>level</replaceable +></option +> </group +> </cmdsynopsis> + +<variablelist +><varlistentry> +<term +><option +>-r <replaceable +>sampling rate</replaceable +></option +></term> +<listitem> +<para +>Ställ in samplingsfrekvens som ska användas.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Visa kommandoanvändning.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-n</option +></term> +<listitem> +<para +>Aktivera nätverkstransparens.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-p <replaceable +>port</replaceable +></option> +</term> +<listitem> +<para +>Ange <acronym +>TCP</acronym +>-port som ska användas (förutsätter <option +>-n</option +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-u</option +></term> +<listitem> +<para +>Öppen, ingen identifiering (farligt).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-d</option +></term> +<listitem> +<para +>Aktivera full duplex.</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-D <replaceable +>devicename</replaceable +></option +></term> +<listitem> +<para +>Ange ljudenhet (vanligtvis <filename +>/dev/dsp</filename +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-F <replaceable +>fragments</replaceable +></option +></term> +<listitem> +<para +>Ange antal fragment.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-S <replaceable +>size</replaceable +></option +></term> +<listitem> +<para +>Ange fragmentstorlek i byte.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-s <replaceable +>seconds</replaceable +></option +></term> +<listitem> +<para +>Ställ in fördröjningen innan vänteläget aktiveras i sekunder. Värdet noll stänger av vänteläget.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m <replaceable +>appName</replaceable +></option +></term> +<listitem> +<para +>Ange namnet på ett program som används för att visa fel, varningar och informationsmeddelanden. Om du kör KDE kan du använda verktyget <application +>artsmessage</application +> för det här.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-N</option +></term> +<listitem> +<para +>Öka storleken av nätverksbuffrarna till ett värde som är lämpligt för att köra med ett 10 Mbps lokalt nätverk. Det här är samma som att använda väljaren -w 5 (se nedan). </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-w <replaceable +>n</replaceable +></option +></term> +<listitem> +<para +>När <application +>artsd</application +> körs via en nätverksanslutning till en annan värddator vill man ofta använda en stor buffer för att undvika pauser. aRts föreslår en minimal bufferstorlek för program. Utan det här alternativet baseras den förvalda storleken på fragmentstorleken * antalet fragment. Med det här alternativet kan man öka storleken från den förvalda med en faktor <replaceable +>n</replaceable +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-l <replaceable +>level</replaceable +></option +></term> +<listitem> +<para +>Ställ in informationsnivå: 3 (tyst), 2 (varningar), 1 (info), 0 (avlusning).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +></term> +<listitem> +<para +>Visa versionsnivå.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>I de flesta fall är det nog att bara köra &artsd;. </para> +</sect1> + +<sect1 id="artswrapper"> +<title +>&artswrapper;</title> + +<para +>För att ge bra realtidsegenskaper körs &artsd; oftast som en realtidsprocess (på plattformar där realtidsprioriteter stöds). Det här kräver <systemitem class="username" +>root</systemitem +>-behörighet, så för att minimera säkerhetspåverkan, kan &artsd; startas med det lilla omgärdande programmet &artswrapper; som helt enkelt byter till realtidsprioritet (medan det kör som <systemitem class="username" +>root</systemitem +>) och sedan startar &artsd; som en annan användare än <systemitem class="username" +>root</systemitem +>. </para> + +<para +>Om du gör &artswrapper; SUID <systemitem class="username" +>root</systemitem +>, kommer det troligen förbättra kvaliteten på ljudåtergivningen genom att reducera uppehåll i musiken. Dock ökar det också risken att ett fel i koden, eller en användare med uppsåt att skada kan krascha eller skada datorn på något sätt. Dessutom, att prioritera hög ljudkvalitet på fleranvändardatorer kan orsaka försämrad prestanda för användare som försöker använda datorn på ett <quote +>produktivt</quote +> sätt.</para> + +</sect1> + +<sect1 id="artsshell"> +<title +>&artsshell;</title> + +<para +>Kommandot &artsshell; är avsett som ett verktyg för att utföra diverse funktioner som hör ihop med ljudservern. Förmodligen kommer verktyget att utökas med nya kommandon i framtiden (se kommentarerna i källkoden för några idéer). </para> + +<para +>Kommandot accepterar följande format: </para> + +<!-- LW: FIX THIS --> + +<cmdsynopsis +><command +>artsshell</command +> <group +> <arg +>suspend</arg +><arg +>status</arg +> <arg +>terminate</arg +> <arg +>autosuspend <replaceable +>secs</replaceable +></arg +> <arg +>networkbuffers <replaceable +>n</replaceable +></arg +> <arg +>volume [<replaceable +>volume</replaceable +>]</arg +> <arg +>stereoeffect <replaceable +>options</replaceable +></arg +> </group +> <group +> <option +>-h</option +> <option +>-q</option +> </group +> </cmdsynopsis> + +<para +>artsshell [väljare] <replaceable +>kommando</replaceable +> [<replaceable +>kommandoalternativ</replaceable +>] </para> + +<para +>Följande väljare stöds: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-q</option +></term> +<listitem> +<para +>Undertryck all utmatning.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Visa kommandoanvändning.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Följande kommandon stöds:</para> + +<variablelist> + +<varlistentry> +<term +><option +>suspend</option +></term> +<listitem> +<para +>Ange att ljudservern ska gå till vänteläget. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>status</option +></term> +<listitem> +<para +>Visa statusinformation för ljudservern.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>terminate</option +></term> +<listitem> +<para +>Avsluta ljudservern. Det här kan förvirra och/eller krascha alla program som för närvarande använder den. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>autosuspend</option +> <parameter +>secs</parameter +></term> +<listitem> +<para +>Ställ in fördröjningen för aktivering av vänteläget till det angivna antalet sekunder. Ljudservern går till vänteläget om den är inaktiv så länge. Värdet noll stänger av vänteläget. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>networkbuffers</option +> <parameter +>n</parameter +></term> +<listitem> +<para +>Ställer in storleken på nätverksbuffrarna till en faktor <parameter +>n</parameter +> gånger den förvalda storleken. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>volume</option +> [<replaceable +>volume</replaceable +>]</term> +<listitem> +<para +>Ställer in volymskalning för ljudserverns utmatning av ljud. Parametern <replaceable +>volume</replaceable +> är ett flyttal. Utan parameter visas nuvarande volym. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect list</option +></term> +<listitem> +<para +>Visa alla tillgängliga stereoeffektmodulerna.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect insert [top|bottom]</option +> <replaceable +>namn</replaceable +></term> +<listitem> +<para +>Infoga en stereoeffekt i stereoeffektstacken. Returnerar en identifierare som senare kan användas för att ta bort den. Effekten kan installeras längst upp eller längs ner (normalvärdet).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect remove</option +> <replaceable +>id</replaceable +></term> +<listitem> +<para +>Tar bort stereoeffekten med identifieraren <replaceable +>id</replaceable +> från effektstacken.</para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsplay"> +<title +><application +>artsplay</application +></title> + +<para +>Programmet <application +>artsplay</application +> är ett enkelt verktyg för att spela en ljudfil. Det accepterar en enda parameter som motsvarar namnet på ljudfilen som skickas till ljudservern för att spelas. Ljudfilen kan vara vilken vanlig ljudfiltyp som helst, såsom <literal role="extension" +>wav</literal +> eller <literal role="extension" +>au</literal +>. Det här verktyget är bra för att prova om ljudservern fungerar. Genom att köra två kommandon parallellt eller i snabb följd kan man demonstrera hur ljudservern blandar mer än en ljudkälla.</para> + +</sect1> + +<sect1 id="artsdsp"> +<title +><application +>artsdsp</application +></title> + +<para +>Ljudservern hanterar bara program som stöder &arts;. Många gamla program vill komma åt ljudenheten direkt. Kommandot &artsdsp; tillhandahåller en interimlösning som låter de flesta av dessa program köra oförändrade. </para> + +<para +>När ett program körs med &artsdsp; fångas alla försök att komma åt ljudenheten <filename class="devicefile" +>/dev/dsp</filename +> och omvandlas till anrop till &arts; programmeringsgränssnitt. Även om enhetsemuleringen inte är perfekt, så fungerar de flesta program på det här sättet, fastän med en viss försämring i prestanda och latenstid. </para> + +<para +>Kommandot &artsdsp; följer formatet: </para> + +<!-- LW: FIX THIS --> +<para +>artsdsp [<replaceable +>väljare</replaceable +>] <replaceable +>program väljare</replaceable +> </para> + +<para +>Följande väljare känns igen: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-h</option +>, <option +>--help</option +></term> +<listitem> +<para +>Visa kortfattad hjälp.</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-n</option +> <option +>--name</option +> = <replaceable +>namn</replaceable +></term> +<listitem> +<para +>Använd <replaceable +>namn</replaceable +> för att identifiera en spelare för <command +>artsd</command +>.</para> + +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m</option +> <option +>--mmap</option +></term> +<listitem> +<para +>Emulera minnesmappning (t.ex för <application +>Quake</application +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +> <option +>--verbose</option +></term> +<listitem> +<para +>Visa väljare.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Ett typiskt anrop är: </para> + +<para> +<userinput +><command +>artsdsp</command +> <option +>-v</option +> <option +>-m</option +> <parameter +>realplay <replaceable +>song.mp3</replaceable +></parameter +></userinput> +</para> + +<para +>Vissa program fungerar bättre med väljaren <option +>--mmap</option +>. Ljudenhetens alla funktioner är inte fullständigt emulerade, men de flesta program bör fungera. Om du hittar ett som inte gör det, skicka in en detaljerad felrapport så kan utvecklarna fixa det. Återigen, kom ihåg att det här är en intermediär lösning och något av en ful snabbfix. Den bästa lösningen är att lägga till inbyggt stöd för &arts; i programmen. Om ditt favoritljudprogram inte har stöd för &arts;, be utvecklaren att tillhandahålla det. </para> + +</sect1> + +<sect1 id="artscat"> +<title +><application +>artscat</application +></title> + +<para +>Det här är ett enkelt verktyg för att skicka råljuddata till ljudservern. Man måste ange dataformatet (samplingsfrekvens, samplingsstorlek och antal kanaler). Det här är troligen inte ett verktyg som man behöver använda ofta, men det kan vara bekvämt för provändamål. Kommandosyntaxen är: </para> + +<!-- LW: FIX THIS --> + +<para +>artscat [ <replaceable +>väljare</replaceable +> ] [ <replaceable +>filnamn</replaceable +> ] </para> + +<para +>Om inget filnamn anges läser programmet från standardinmatningen. Följande väljare stöds: </para> + +<variablelist> +<varlistentry> +<term +><option +>-r</option +> <parameter +>samplingsfrekvens</parameter +></term> +<listitem> +<para +>Ställ in samplingsfrekvens som används. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-b</option +> <parameter +>bitar</parameter +></term> +<listitem> +<para +>Ställ in samplingsstorlek som används (8 eller 16). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-c</option +> <parameter +>kanaler</parameter +></term> +<listitem> +<para +>Välj antal kanaler (1 eller 2). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Visa kommandoanvändning och avsluta. </para> +</listitem> +</varlistentry> + +</variablelist> +</sect1> + +<sect1 id="artscontrol"> +<title +>&artscontrol;</title> + +<para +>Det här är ett grafiskt verktyg för att utföra ett antal uppgifter som hör ihop med ljudservern. Det förvalda fönstret visar två volymnivåvisare och ett skjutreglage för att ställa in den generella uppspelningsvolymen. Från menyn <guimenu +>Visa</guimenu +> kan du välja andra funktioner: </para> + +<variablelist> + +<varlistentry> +<term +><guimenuitem +>FFT-mätare</guimenuitem +></term> +<listitem> +<para +>Öppnar ett fönster som visar en skärm med en realtidsspektrumanalysator. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Ljudhanterare</guimenuitem +></term> +<listitem> +<para +>Visar aktiva ljudkällor och låter dig ansluta dem till alla tillgängliga bussar. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>aRts status</guimenuitem +></term> +<listitem> +<para +>Visar om ljudservern kör och om realtidsschemaläggning används. Anger när servern kommer att gå till vänteläget och låter dig gå till vänteläget omedelbart. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Midihanterare</guimenuitem +></term> +<listitem> +<para +>Visar aktiva &MIDI; in- och utgångar och låter dig göra förbindelser [ATT GÖRA: fungerar det här ännu? Behöver mera detaljer]. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>FreeVerb</guimenuitem +></term> +<listitem> +<para +>Ansluter en FreeVerb efterklangseffekt till stacken av &arts; utmatningseffekter och låter dig kontrollera ljudeffektinställningarna grafiskt. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Leds liknande volymvisning</guimenuitem +></term> +<listitem> +<para +>Ändrar volymindikeringen i huvudfönstret att använda ett visningsformat med färgade lysdioder istället för staplar. </para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsc-config"> +<title +><application +>artsc-config</application +></title> + +<para +>Det här verktyget är till för att hjälpa utvecklare som använder C-programmeringsgränssnittet i &arts;. Det matar ut de riktiga kompilator- och länkarväljare som behövs när man kompilerar och länkar med &arts;. Det är tänkt att användas i make-filer för att hjälpa till med flyttbarhet. Kommandot accepterar tre väljare: </para> + +<variablelist> +<varlistentry> +<term +><option +>--cflags</option +></term> +<listitem> +<para +>Visar kompilatorväljare som behövs när man kompilerar med &arts; C-programmeringsgränssnitt. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>--libs</option +></term> +<listitem> +<para +>Visar länkarväljare som behövs när man länkar med &arts; C-programmeringsgränssnitt. </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><acronym +>---version</acronym +></term> +<listitem> +<para +>Visar versionen av kommandot <command +>artsc-config</command +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Typisk utmatning från kommandot visas nedan:</para> + +<screen width="40" +><prompt +>%</prompt +> <userinput +><command +>artsc-config</command +> <option +>--cflags</option +></userinput> +<computeroutput +>-I/usr/local/kde2/include/artsc</computeroutput> +<prompt +>%</prompt +> <userinput +><command +>artsc-config</command +> <option +>--libs</option +></userinput> +<computeroutput +>-L/usr/local/kde2/lib -ldl -lartsc -DPIC -fPIC -lpthread</computeroutput> +<prompt +>%</prompt +> <userinput +><command +>artsc-config</command +> <option +>--version</option +></userinput> +<computeroutput +>0.9.5</computeroutput +> +</screen> + +<para +>Man ska kunna använda det här verktyget i en make-fil med en regel som: </para> + +<programlisting +>artsc: artsc.c + gcc `artsc-config --cflags` -o artsc artsc.c `artsc-config --libs` +</programlisting> + +</sect1> + +<sect1 id="mcopidl"> +<title +>&mcopidl;</title> + +<para +>Kommandot &mcopidl; är &IDL;-fil kompilatorn för &MCOP;, multimedia-kommunikationsprotokollet som används av &arts;. Gränssnitt i &arts; definieras med &IDL;, ett språkoberoende gränssnittsdefinitionsspråk. Verktyget &mcopidl; accepterar en &IDL;-fil som indata och skapar C++ deklarations- och källkodsfiler för en klass som implementerar gränssnittet. Kommandot accepterar följande syntax: </para> + +<!-- LW: FIX THIS --> + +<para +>mcopidl [ <replaceable +>väljare</replaceable +> ] <replaceable +>filnamn</replaceable +> </para> + +<para +>Giltiga väljare är:</para> +<variablelist> +<varlistentry> +<term +><option +>-I</option +> <parameter +>katalog</parameter +></term> +<listitem> +<para +>Sök i <parameter +>katalog</parameter +> efter deklarationsfiler. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-e</option +> <parameter +>namn</parameter +></term> +<listitem> +<para +>Hoppa över en struct, gränssnitt eller uppräkningstyp <parameter +>namn</parameter +> vid kodgenerering. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-t</option +></term> +<listitem> +<para +>Skapa också <literal role="extension" +>.mcoptype</literal +>/<literal role="extension" +>.mcopclass</literal +> filer som innehåller typinformation för &IDL;-filen. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Mer information om &MCOP; och &IDL; finns i avsnittet <link linkend="interfaces" +>Gränssnitt och &IDL;</link +>. </para> + +</sect1> + +</chapter> |
