diff options
Diffstat (limited to 'tde-i18n-es/docs/tdemultimedia/artsbuilder')
65 files changed, 11364 insertions, 0 deletions
diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/Makefile.am b/tde-i18n-es/docs/tdemultimedia/artsbuilder/Makefile.am new file mode 100644 index 00000000000..2d733d1b104 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = es +SUBDIRS = $(AUTODIRS) +KDE_DOCS = AUTO +KDE_MANS = AUTO diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/Makefile.in b/tde-i18n-es/docs/tdemultimedia/artsbuilder/Makefile.in new file mode 100644 index 00000000000..1361fa34d99 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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/tdemultimedia/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@ +tdeinitdir = @tdeinitdir@ +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 = es +#>- 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/tdemultimedia/artsbuilder/Makefile'; \ +#>- cd $(top_srcdir) && \ +#>- $(AUTOMAKE) --gnu docs/tdemultimedia/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/tdemultimedia/artsbuilder/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdemultimedia/artsbuilder/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdemultimedia/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/tdemultimedia/artsbuilder/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdemultimedia/artsbuilder/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdemultimedia/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-es/docs/tdemultimedia/artsbuilder/apis.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/apis.docbook new file mode 100644 index 00000000000..7200c99fb52 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/apis.docbook @@ -0,0 +1,434 @@ +<!-- <?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 +>Interfaces de programación de aplicaciones (APIs) de &arts;</title> + +<sect1 id="api-overview"> +<title +>Introducción</title> +<para +>aRts no es sólo un conjunto de software, también proporciona una serie de APIs para propósitos variados. En esta sección trataré de describir de una forma resumida lo que se supone que hacen esas APIs, y cómo interaccionan. </para> + +<para +>Hay que hacer una importante distinción: la mayoría de las APIs son <emphasis +>independientes del lenguaje y la localización</emphasis +> ya que están especificadas como <emphasis +>mcopidl</emphasis +>. Es decir, se pueden utilizar los servicios que ofrecen desde cualquier lenguaje, implementarlas en cualquier lenguaje, y no será necesario tener en cuenta si se trata de objetos locales o remotos. Esta es una lista de las primeras: </para> + + +<variablelist> +<varlistentry> +<term +>core.idl</term> + <listitem +><para +>Definiciones básicas que forman el núcleo de la funcionalidad MCOP, como el propio protocolo, definiciones del objeto, el intercambiador, el sistema de flujo, etc. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsflow.idl</term> + + <listitem +><para +>Aquí está contenido el sistema de transmisión que se utilizará para conectar transmisiones de audio, la definición de <emphasis +>Arts::SynthModule</emphasis +> que es la base de cualquier interfaz que tenga transmisiones y finalmente algunos objetos de audio útiles. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>kmedia2.idl</term> + + + <listitem +><para +>Aquí se define un objeto que puede reproducir un medio, <emphasis +>Arts::PlayObject</emphasis +>. Los reproductores de medios como noatun de KDE serán capaces de reproducir cualquier medio para el que se encuentre un objeto PlayObject. Así que cobra sentido implementar objetos PlayObject para varios formatos (como mp3, video mpeg, midi, wav, ...) en esa base, y, de hecho, ya hay muchos. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>soundserver.idl</term> + + <listitem +><para +>Aquí se define un interfaz para el servidor de sonido global del sistema. El interfaz se llama <emphasis +>Arts::SoundServer</emphasis +>, que implementa funcionalidades como aceptar transmisiones desde la red, reproducir muestras, crear objetos de aRts propios, etc. La transparencia de red está implícita debido al uso de MCOP (como para todo lo demás). </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsbuilder.idl</term> + <listitem +><para +>Este módulo define la funcionalidad básica de los gráficos de flujo, es decir, la combinación de objetos sencillos en otro más complejos, definiendo una gráfica de ellos. Define los interfaces básicos <emphasis +>Arts::StructureDesc</emphasis +>, <emphasis +>Arts::ModuleDesc</emphasis +> y <emphasis +>Arts::PortDesc</emphasis +> que contienen una descripción de una estructura, un módulo y un puerto. También hay un modo de obtener una «red viviente de objetos» de estas conexiones y descripciones de valor, utilizando una fábrica. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmidi.idl</term> + + <listitem +><para +>Este módulo define la funcionalidad MIDI básica, como objetos que producen eventos MIDI, lo que es un evento MIDI, un <emphasis +>Arts::MidiManager</emphasis +> para conectar los productores y consumidores de eventos MIDI, etc. Como siempre, la transparencia de red está implicada. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmodules.idl</term> + <listitem +><para +>Aquí hay varios filtros adicionales, osciladores, efectos, retardos, etc. así como todo lo requerido para poder realizar procesamiento de señal y construir instrumentos complejos a partir de estos elementos básicos. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsgui.idl</term> + + <listitem +><para +>Se encarga de los objetos visuales. Define el tipo básico <emphasis +> Arts::Widget</emphasis +> del que se derivan todos los módulos del entorno gráfico. Ésto proporciona independencia del conjunto de herramientas, edición visual del entorno gráfico y entornos gráficos serializables. Además, al tener los elementos del entorno gráfico atributos normales, sus valores puede estar conectados directamente a algunos módulos de procesamiento de señal. (Por ejemplo, el valor de un control al corte de un filtro). Como siempre: transparencia de red. </para +></listitem> + +</varlistentry> + +</variablelist> +<para +>Donde es posible, el propio aRts está implementado usando IDL. Por otro lado, hay algunas APIs <emphasis +>específicas del lenguaje</emphasis +> que utilizan C o C++. Lo más correcto es utilizar interfaces IDL donde se pueda, y las otras APIs donde sea necesario. Esta es una lista de APIs específicas del lenguaje: </para> + +<variablelist> + +<varlistentry> +<term +>KNotify, KAudioPlayer (incluido en libtdecore)</term> + + <listitem +><para +>Estas son APIs convenientes para los casos más sencillos y comunes, donde sólo se quiere reproducir una muestra. Las APIs están en C++, optimizado para Qt/KDE, y son lo más sencillas posible. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsc</term> + <listitem +><para +>Interfaz de C para el servidor de sonido. Muy útil para portar aplicaciones antiguas. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libmcop</term> + + <listitem +><para +>Toda la magia de MCOP se produce aquí. La biblioteca contiene los elementos básicos necesarios que debe conocer para escribir una aplicación MCOP sencilla, el repartidor, temporizadores, administración de entrada/salida, pero también los elementos internos que hacen que funcione el propio protocolo MCOP. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsflow</term> + <listitem +><para +>Además de la implementación de artsflow.idl, incluye algunas utilidades como la conversión del ratio de muestreo. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libqiomanager</term> + + <listitem +><para +>Integración de MCOP en el bucle de eventos de Qt, cuando escriba aplicaciones Qt utilizando MCOP. </para +></listitem> + +</varlistentry> + +</variablelist> + + + +</sect1> +<sect1 id="knotify"> +<title +>knotify</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="kaudioplayer"> +<title +>kaudioplayer</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="libkmid"> +<title +>libkmid</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="kmedia2"> +<title +>kmedia2</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="soundserver"> +<title +>servidor de sonido</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="artsflow"> +<title +>artsflow</title> +<para +>Pendiente de escribir. </para> +</sect1> + +<sect1 id="capi"> +<title +><acronym +>API</acronym +> de C</title> + +<sect2 id="capiintro"> +<title +>Introducción</title> + +<para +>El <acronym +>API</acronym +> de C de &arts; se diseñó para facilitar la escritura y adaptación de aplicaciones en C al servidor de sonido &arts;. Proporciona funcionalidad de flujos (envío de suceciones de muestras a <application +>artsd</application +>), ya sea exclusivas o no. En la mayoría de las aplicaciones, basta con eliminar unas pocas llamadas al sistema que realizan la comunicación con el dispositivo de audio y sustituirlas por las llamadas a &arts; correspondientes.</para> + +<para +>Yo he realizado dos adaptaciones como demostración del concepto: <application +>mpg123</application +> y <application +>quake</application +>. Los parches se puede obtener <ulink url="http://space.twc.de/~stefan/kde/download/artsc-patches.tar.gz" +>aquí</ulink +>. Usted mismo puede enviar sus propios parches al mantenedor de &arts; o de otros paquetes de software para facilitar el uso de &arts; en su código.</para> + +</sect2> + +<sect2 id="capiwalkthru"> +<title +>Un vistazo rápido</title> + +<para +>Enviar audio al servidor de sonido a través de la <acronym +>API</acronym +> es muy sencillo:</para> +<procedure> +<step +><para +>Incluya el archivo de cabecera utilizando <userinput +>#include <artsc.h></userinput +>.</para +></step> +<step +><para +>Inicialice la <acronym +>API</acronym +> con <function +>arts_init()</function +>.</para +></step> +<step +><para +>Construya una transmisión de muestras con <function +>arts_play_stream()</function +>.</para +></step> +<step +><para +>Configure los parámetros específicos con <function +>arts_stream_set()</function +>.</para +></step> +<step +><para +>Escriba los datos de las muestras en la transmisión con <function +>arts_write()</function +>.</para +></step> +<step +><para +>Cierre la transmisión con <function +>arts_close_stream()</function +>.</para +></step> +<step +><para +>Libere la <acronym +>API</acronym +> con <function +>arts_free()</function +>.</para +></step> +</procedure> + +<para +>Este ejemplo es un pequeño programa que ilustra el funcionamiento:</para> + +<programlisting +>#include <stdio.h> +#include <artsc.h> +int main() +{ + arts_stream_t canal; + char datos[8192]; + int bytes; + int error; + + error = arts_init(); + if (error < 0) + { + fprintf(stderr, "error en arts_init: %s\n", arts_error_text(error)); + return 1; + } + + stream = arts_play_stream(44100, 16, 2, "probar_arts"); + + while((bytes = fread(datos, 1, 8192, stdin)) > 0) + { + error = arts_write(canal, datos, bytes); + if(error < 0) + { + fprintf(stderr, "error en arts_write: %s\n", arts_error_text(error)); + return 1; + } + } + + arts_close_stream(canal); + arts_free(); + + return 0; +} +</programlisting> +</sect2> + +<sect2 id="capiartscconfig"> +<title +>Compilación y enlace: <application +>artsc-config</application +></title> + +<para +>Para compilar y enlazar de un forma sencilla los programas que utilicen la <acronym +>API</acronym +> para C de &arts;, se proporciona la utilidad <application +>artsc-config</application +> que sabe qué bibliotecas son necesarias para el enlace y dónde se encuentran los archivos de inclusión. Se ejecuta utilizando</para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--libs</option +></userinput +> +</screen> + +<para +>para determinar las bibliotecas, y </para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--cflags</option +></userinput +> +</screen> + +<para +>para establecer parámetros de compilación de C adicionales. El ejemplo anterior se compilaría con la línea de órdenes:</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 +>Referencia de la biblioteca</title> + +<para +>[POR HACER: generar la documentación de artsc.h utilizando kdoc] </para> + +</sect2> + +</sect1> +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/arts-structure.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/arts-structure.png Binary files differnew file mode 100644 index 00000000000..41cfadb0d85 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/arts-structure.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/artsbuilder.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/artsbuilder.docbook new file mode 100644 index 00000000000..e2842fe5a39 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/artsbuilder.docbook @@ -0,0 +1,901 @@ +<chapter id="artsbuilder"> +<title +>&arts-builder;</title> + +<sect1 id="overview"> +<title +>Introducción</title> + +<para +>En primer lugar, al tratar de ejecutar &arts-builder;, también se debe estar ejecutando el servidor de sonido (&artsd;). Normalmente, si utiliza &kde; 2.1, esto se hace automáticamente. Sino, puede configurar en &kcontrol; que el servidor de sonido se inicie de forma automática en <menuchoice +><guilabel +>Sonidos y multimedia</guilabel +><guilabel +>Sistema de sonido</guilabel +></menuchoice +>. </para> + +<para +>Al ejecutar &arts;, siempre se ejecutan pequeños módulos. &arts-builder; es una herramienta para la creación de nuevas estructuras de pequeños módulos conectados. Lo único que debe hacer es colocar los módulos en la rejilla. Para hacerlo, elíjalos en el menú <guimenu +>Módulos</guimenu +>, y después pulse en cualquier lugar del espacio verde y gris. </para> + +<para +>Los módulos tienen normalmente puertos (por los que fluyen las señales de audio hacia adentro o hacia afuera). Para conectar dos puertos, pinche en el primero, que provocará que se ponga de color naranja, y después pinche en el segundo. Sólo puede conectar un puerto de entrada (en la parte superior de un módulo) con un puerto de salida (en la parte inferior de un módulo). Si desea asignar un valor fijo a un puerto (o desconectarlo), hágalo mediante una doble pulsación del ratón sobre el mismo. </para> + +</sect1> + +<sect1 id="artsbuilder-tutorial"> +<title +>Tutorial</title> + +<sect2 id="step-1"> +<title +>Paso 1</title> + +<para +>Inicie &arts-builder;. </para> + +<para +>Necesita un módulo Synth_AMAN_PLAY para oír la salida que está creando. Así que cree un módulo Synth_AMAN_PLAY seleccionando <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntesis</guisubmenu +> <guisubmenu +>Synth_AMAN_PLAY</guisubmenu +></menuchoice +> y pulsando en un espacio vacío del módulo. Póngalo por debajo más o menos de la quinta línea, ya que añadiremos alguna otra cosa por encima. </para> + +<para +>El módulo tendrá un parámetro <parameter +>title</parameter +> (el puerto situado más a la izquierda), y <parameter +>autoRestoreID</parameter +> (al lado del puerto situado más a la izquierda) para su localización. Para rellenarlos, haga una doble pulsación en esos puertos, seleccione un valor constante y teclee <userinput +>tutorial</userinput +> en la casilla de edición. Pulse <guibutton +>Aceptar</guibutton +> para aplicar los cambios. </para> + +<para +>Seleccione <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Ejecutar estructura</guimenuitem +> </menuchoice +>. No oirá absolutamente nada. El módulo de reproducción necesita la entrada de información. Cuando ya haya escuchado un poco el silencio, pinche en <guibutton +>Aceptar</guibutton +> y vaya al paso 2. </para> +</sect2> + +<sect2 id="step-2"> +<title +>Paso 2</title> + +<para +>Cree un módulo Synth_WAVE_SIN (desde <menuchoice +> <guimenu +>Módulos</guimenu +> <guimenuitem +>Síntesis</guimenuitem +> <guimenuitem +>Formas de onda</guimenuitem +></menuchoice +>) y colóquelo encima del módulo Synth_AMAN_PLAY (deje una línea en blanco en el medio). </para> + +<para +>Como ve, se produce una salida, pero requiere un <guilabel +>pos</guilabel +> como entrada. En primer lugar enviemos la salida a los altavoces. Pinche en el puerto <guilabel +>out</guilabel +> de Synth_WAVE_SIN y después en el puerto <guilabel +>left</guilabel +> de Synth_AMAN_PLAY. Voila, se han conectado los dos módulos. </para> + +<para +>Los osciloscopios de &arts; no requieren una frecuencia como entrada, pero sí una posición en la onda. La posición debe estar entre 0 y 1, lo que coloca al objeto estándar Synth_WAVE_SIN en el rango 0..2*pi. Para generar valores oscilantes a partir de una frecuencia, se utilizan los módulos Synth_FREQUENCY. </para> + +<para +>Cree un módulo Synth_FREQUENCY (desde <menuchoice +> <guimenu +>Módulos</guimenu +> <guimenu +>Síntesis</guimenu +> <guimenu +>Oscilación y modulación</guimenu +> </menuchoice +>) y conecte su salida «pos» a la entrada «pos» del módulo Synth_WAVE_SIN. Dele al puerto de frecuencia del generador de frecuencias un valor constante de 440. </para> + + +<para +>Seleccione <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Ejecutar estructura</guimenuitem +></menuchoice +>. Escuchará una onda sinusoidal de 440 Hz en uno de sus altavoces. Cuando ya la haya escuchado, pinche en <guibutton +>Aceptar</guibutton +> y vaya al paso 3. </para> + +</sect2> + +<sect2 id="step-3"> +<title +>Paso 3</title> + +<para +>De acuerdo, sería mejor escuchar la onda en ambos altavoces. Conecte también el puerto derecho de Synth_PLAY al valor de salida de Synth_WAVE_SIN. </para> + +<para +>Cree un objeto Synth_SEQUENCE (desde <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntesis</guisubmenu +><guisubmenu +>Midi + Secuenciado</guisubmenu +></menuchoice +>). Debería estar en la parte superior de la pantalla. Si necesita más espacio, puede mover los otros módulos seleccionándolos (para seleccionar varios módulos utilice la tecla &Shift;) y arrastrándolos a otro lugar. </para> + +<para +>Ahora conecte la salida de frecuencia de Synth_SEQUENCE a la entrada de frecuencia del módulo Synth_FREQUENCY. Después especifique un valor constante de 0,13 como velocidad de la secuencia (la velocidad es el puerto más a la izquierda). </para> + +<para +>Ahora vaya al puerto más a la derecha (secuencia) de Synth_SEQUENCE e introduzca como valor constante <userinput +>A-3;C-4;E-4;C-4;</userinput +> esto especifica una secuencia. Hay más información en el capítulo Referencia de los módulos. </para> + +<note> +<para +>Synth_SEQUENCE realmente <emphasis +>necesita</emphasis +> una secuencia y la velocidad. Sin eso es probable que se produzcan errores. </para> +</note> + +<para +>Seleccione <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Ejecutar estructura</guimenuitem +></menuchoice +>. Escuchará la reproducción de una bonita secuencia. Cuando ya la haya disfrutado, pulse <guibutton +>Aceptar</guibutton +> y vaya al paso 4. </para> +</sect2> + +<sect2 id="step-4"> +<title +>Paso 4</title> + +<para +>Cree un módulo Synth_PSCALE (en <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntesis</guisubmenu +> <guisubmenu +>Envoltorios</guisubmenu +> </menuchoice +>). Desconecte el valor de salida de la onda sinusoidal mediante una doble pulsación del ratón y eligiendo <guilabel +>no conectado</guilabel +>. Conecte: </para> + +<orderedlist +><listitem> +<para +>El valor de salida de SIN con el valor de entrada de PSCALE.</para> +</listitem> +<listitem> +<para +>El valor de salida de PSCALE con el izquierdo de AMAN_PLAY.</para> +</listitem> +<listitem> +<para +>El valor de salida de PSCALE con el derecho de AMAN_PLAY.</para> +</listitem> +<listitem> +<para +>El pos de SEQUENCE con el pos de PSCALE.</para> +</listitem> +</orderedlist> + +<para +>Por último, establezca el límite de PSCALE en algún valor, por ejemplo 0,1. </para> + +<para +>Cómo funciona: el módulo Synth_SEQUENCE proporciona información adicional sobre la posición de la nota que se está reproduciendo en ese momento, de tal forma que 0 significa que acaba de comenzar y 1 que ha finalizado. El módulo Synth_PSCALE escala el transmisión de sonido que pasa por él desde un volumen 0 (silencio) hasta 1 (volumen original) y nuevamente a 0 (silencio), de acuerdo con la posición. La posición en la que se produce el pico de audio se puede dar como pos. 0,1 significa que después de que se haya reproducido el 10% de la nota, el volumen alcanzará el máximo, y comenzará a descender en ese punto. </para> + + +<para +>Seleccione <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Ejecutar estructura</guimenuitem +></menuchoice +>. Escuchará la reproducción de una bonita secuencia. Cuando ya la haya disfrutado, pulse <guibutton +>Aceptar</guibutton +> y vaya al paso 5. </para> + +</sect2> + +<sect2 id="step-5-starting-to-beam-data-around"> +<title +>Paso 5: Comenzando a emitir datos ;)</title> + +<para +>Inicie otro &arts-builder;.</para> + +<para +>Ponga un Synth_AMAN_PLAY en él, déle un nombre adecuado. Ponga un Synth_AMAN_DOWNLINK en él y:</para> + +<orderedlist> +<listitem> +<para +>Establezca el bus Synth_BUS_DOWNLINK a audio (es solo un nombre, llámelo 'pepe' si lo desea). </para> +</listitem> +<listitem> +<para +>Conecte el izquierdo de Synth_BUS_DOWNLINK al izquierdo de Synth_AMAN_PLAY. </para> +</listitem> +<listitem> +<para +>Conecte el derecho de Synth_BUS_DOWNLINK al derecho de Synth_AMAN_PLAY. </para> +</listitem> +</orderedlist> + +<para +>Empiece ejecutando la estructura. Como esperaba, no escuchará nada, ... no todavía. </para> + +<para +>Vuelva a la estructura que contiene el módulo Synth_WAVE_SIN y reemplace el módulo Synth_AMAN_PLAY por un Synth_BUS_UPLINK, y déle el nombre 'audio' (o 'pepe' si lo desea). Para borrar módulos selecciónelos y escoja en el menú <menuchoice +><guimenu +>Editar</guimenu +> <guimenuitem +>Eliminar</guimenuitem +></menuchoice +> (o pulse la tecla <keycap +>Supr</keycap +>). </para> + +<para +>Pulse <menuchoice +><guimenu +>Archivo</guimenu +><guilabel +>Ejecutar estructura</guilabel +></menuchoice +>. Escuchará la secuencia con notas escaladas, transportadas a través el bus. </para> + +<para +>Si desea averiguar por qué algo como ésto puede llegar a ser útil, pulse <guibutton +>Aceptar</guibutton +> (en el &arts-builder; que esté ejecutando el bloque Synth_SEQUENCE, puede dejar los otros que se estén ejecutando) y vaya al paso 6. </para> +</sect2> + +<sect2 id="step-6-beaming-for-advanced-users"> +<title +>Paso 6: para usuarios avanzados</title> + +<para +>Elija <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Renombrar</guimenuitem +> </menuchoice +> estructura del menú de artsbuilder que contiene el bloque Synth_SEQUENCE, y llámelo tutorial. Pulse <guibutton +>Aceptar</guibutton +>. </para> + +<para +>Seleccione <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Guardar</guimenuitem +> </menuchoice +>. </para> + +<para +>Inicie otro &arts-builder; y elija <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Cargar</guimenuitem +> </menuchoice +>, y cargue el tutorial de nuevo. </para> + +<para +>Ahora puede seleccionar <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Ejecutar estructura</guimenuitem +></menuchoice +> en ambos &arts-builder;s obteniendo esa estructura. Escuchará dos veces la misma cosa. Dependiendo del momento en el que empiece sonará mejor o peor. </para> + +<para +>Otra cosa que puede ser útil hacer en este momento es: inicie &noatun;, y reproduzca algún <literal role="extension" +>mp3</literal +>. Inicie &artscontrol;. Vaya a <menuchoice +><guimenu +>Ver</guimenu +><guimenuitem +>Ver gestor de audio</guimenuitem +></menuchoice +>. Lo que verá será &noatun; y su estructura de reproducción «tutorial» reproduciendo algo. Lo mejor que puede hacer es: doble pulsación en &noatun;. Obtendrá una lista de los buses disponibles. ¿Lo ve? Puede asignar &noatun; para enviar la salida a través de el bus de audio que su estructura de reproducción proporciona. </para> +</sect2> + +<sect2 id="step-7-midi-synthesis"> +<title +>Step 7: Síntesis de midi</title> + +<para +>Finalmente, ahora debería ser capaz de transformar su onda sinusoidal en un instrumento real. Ésto sólo tiene sentido si tiene algo que le ayude a enviar eventos &MIDI; a &arts;. Describiré aquí como puede usar algún teclado externo, pero un bus midi enterado de la secuencia como &brahms; funcionará mejor. </para> + +<para +>En primer lugar, limpie su escritorio de tal modo que solo tenga un &arts-builder; con la estructura de onda sinusoidal corriendo (no ejecutándose). Entonces, vaya tres veces a <menuchoice +><guimenu +>Puertos</guimenu +><guisubmenu +>Crear señal de audio de entrada</guisubmenu +></menuchoice +>, y tres veces a <menuchoice +><guimenu +>Puertos</guimenu +> <guisubmenu +>Crear señal de audio de salida</guisubmenu +></menuchoice +>. Coloque los puertos en algún sitio. </para> + +<para +>Vaya a <menuchoice +><guimenu +>Puertos</guimenu +><guilabel +>Cambiar posiciones/nombres</guilabel +></menuchoice +> y renombre los puertos a frecuencia, velocidad, pulsado, izquierdo, derecho y hecho. </para> + +<para +>Finalmente, puede borrar el módulo Synth_SEQUENCE, y conectar el puerto de entrada frecuencia de la estructura al puerto frecuencia de Synth_FREQUENCY. Pero..., ¿qué hacemos con pos?</para +> <para +>No existe esto, porque no hay algoritmo en el mundo que le permita predecir cuando el usuario va a soltar la nota que acaba de pulsar en el teclado midi. Por lo que es mejor tener un parámetro 'pulsado' en su lugar que indique si el usuario aún mantiene la tecla pulsada. (pulsado = 1: la tecla aún está pulsada, pulsado = 0: tecla suelta). </para> + +<para +>Ésto significa que el objeto Synth_PSCALE también debe ser sustituído. Introduzca un Synth_ENVELOPE_ADSR en su lugar (desde <menuchoice +><guimenu +>Módulos</guimenu +><guisubmenu +>Síntesis</guisubmenu +> <guisubmenu +>Envoltorios</guisubmenu +></menuchoice +>). Conecte: </para> + +<orderedlist> +<listitem> +<para +>La estructura de entrada 'pulsada' al 'activo' del ADSR.</para> +</listitem> +<listitem> +<para +>El valor de salida de SIN al valor de entrada de ADSR.</para> +</listitem> +<listitem> +<para +>El valor de salida de ADSR a la salida izquierda de la estructura.</para> +</listitem +><listitem> +<para +>El valor de salida de ADSR a la salida derecha de la estructura.</para> +</listitem> +</orderedlist> + +<para +>Establezca los parámetros ataque a 0.1; desintegrar a 0.2, mantener a 0.7, liberar a 0.1. </para> + +<para +>Otra cosa en la que deberá pensar es que la estructura instrumental debería saber de alguna forma cuándo está preparada para reproducir y limpiar, ya que de otra forma podría no parar nunca aunque se haya liberado la nota. Afortunadamente, el envoltorio ADSR sabe cuándo se debe parar, escalando la señal a cero un momento después de que se haya liberado la nota. </para> + +<para +>Esto se indica asignando 1 a la salida. Por tanto, conecte ésto a la salida de la estructura. La estructura se eliminará tan pronto como suba a 1. </para> + +<para +>Renombre su estructura como tutorial_de_instrumentos (desde <menuchoice +><guimenu +> Archivo</guimenu +><guimenuitem +>Renombrar estructura</guimenuitem +></menuchoice +>) Entonces, guárdela usando guardar como (el nombre predeterminado debería ser ahora tutorial_de_instrumentos).</para +><para +>Inicie artscontrol y vaya a <menuchoice +><guimenu +>Ver</guimenu +><guimenuitem +>Administrador midi</guimenuitem +></menuchoice +>, y escoja <menuchoice +><guimenu +>Añadir</guimenu +><guimenuitem +>Salida midi de síntesis de aRTs</guimenuitem +></menuchoice +>. Finalmente, debería ser capaz de seleccionar su instrumento (tutorial) aquí. </para> + +<para +>Abra una terminal y teclee <userinput +><command +>midisend</command +></userinput +> . Verá cómo <command +>midisend</command +> y el instrumento se escuchan ahora en el administrador &MIDI; de &arts;. Después de seleccionar ambos y pulsar <guibutton +>conectar</guibutton +>, habremos terminado. Tome su teclado y empiece a reproducir (por supuesto debe estar conectado a su ordenador). </para> +</sect2> + +<sect2 id="suggestions"> +<title +>Sugerencias</title> + +<para +>Ahora tendría que ser capaz de trabajar con &arts;. Aquí hay unos pocos consejos que intentarán mejorar sus estructuras: </para> + +<itemizedlist> +<listitem> +<para +>Intente usar otros elementos diferentes de una onda SIN. Cuando introduce una onda TRI, podrá pensar que el sonido no es demasiado bueno. Pero intente enlazar un filtro SHELVE_CUTOFF después de la onda TRI para cortar las frecuencias superiores a una dada (intente algo como 1.000 Hz, o mejor, dos veces la frecuencia de entrada, o la frecuencia de entrada+200Hz o algo así). </para> +</listitem> +<listitem> +<para +>Intente usar más de un oscilador. Synth_XFADE puede usarse para cruzar (mezclar) dos señales y Synth_ADD para añadirlas. </para> +</listitem> +<listitem> +<para +>Intente establecer las frecuencias de los osciladores a valores ligeramente distintos, ya que ésto produce mejores oscilaciones. </para> +</listitem> +<listitem> +<para +>Experimente con mas de un envoltorio. </para> +</listitem> +<listitem> +<para +>Intente sintetizar instrumentos con salidas izquierda y derecha diferentes. </para> +</listitem> +<listitem> +<para +>Intente posprocesar la señal después de que salga del bus el enlace descendente. Puede, por ejemplo, mezclar una versión retrasada de la señal con la original para obtener un efecto de eco. </para> +</listitem> +<listitem> +<para +>Intente utilizar la configuración de la velocidad (es la fuerza con la que se pulsará la nota, podríamos decir que es el volumen). El efecto especial se produce siempre que no sólo se modifique el volumen de la señal resultante, sino también el sonido del instrumento (por ejemplo, el corte de frecuencia). </para> +</listitem> +<listitem> +<para +>...</para> +</listitem> +</itemizedlist> + +<para +>Si ha creado algo realmente bueno, por favor, considere la opción de enviarlo a la página web de &arts;. O para inclusiones en la siguiente versión. </para> +</sect2> + +</sect1> + +<sect1 id="artsbuilder-examples"> +<title +>Ejemplos</title> + +<para +>&arts-builder; viene con bastantes ejemplos, que pueden ser abiertos a través de <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Abrir Ejemplo...</guimenuitem +></menuchoice +> Algunos de ellos están en la carpeta, y otros (que por alguna razón no funcionan en la versión actual) están abandonados en la carpeta todo. </para> +<para +>Los ejemplos están divididos en varias categorías: </para> + +<itemizedlist> +<listitem> +<para +>Ejemplos autónomos ilustrando cómo usar cada uno de los los módulos built-in de arts (llamados <filename +>example_*.arts</filename +>). Éstos envían normalmente alguna salida a la tarjeta de sonido. </para> +</listitem> + +<listitem> +<para +>Instrumentos creados desde módulos de arts de niveles más bajos (llamados <filename +>instrument_*.arts</filename +>). Éstos siguen una convención estándar para los puertos de entrada y salida, por lo que pueden ser usados por el administrador &MIDI; en &artscontrol;. </para> +</listitem> + +<listitem> +<para +>Plantillas para crear nuevos módulos (llamados <filename +>template_*.arts</filename +>). </para> +</listitem> + +<listitem> +<para +>Efectos que pueden usarse como bloques reutilizables (llamados <filename +>effect_*.arts</filename +>) [incluídos en «todo»] </para> +</listitem> + +<listitem> +<para +>Elementos mezcladores para crear mezcladores, incluyendo controles gráficos (llamados <filename +>mixer_element_*.arts</filename +>). [incluídos en «todo»] </para> +</listitem> + +<listitem> +<para +>Varios módulos que no se ajustan a ninguna de las categorías anteriores. </para> +</listitem> +</itemizedlist> + +<variablelist> +<title +>Descripción detallada de cada módulo:</title> +<varlistentry> +<term +><filename +>example_stereo_beep.arts</filename +></term> +<listitem> +<para +>Genera un tono de onda sinusoidal a 440Hz en el canal izquierdo y un tono de onda sinusoidal a 880Hz en el canal derecho y lo envía a la salida de la tarjeta de sonido. Se referencia en la documentación de &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sine.arts</filename +></term> +<listitem> +<para +>Genera una onda sinusoidal a 440Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pulse.arts</filename +></term> +<listitem> +<para +>Genera una onda pulso de 440 Hz con una función cíclica del 20%. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_softsaw.arts</filename +></term> +<listitem> +<para +>Genera una onda de diente de sierra a 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_square.arts</filename +></term> +<listitem> +<para +>Genera una onda cuadrada a 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tri.arts</filename +></term> +<listitem> +<para +>Genera una onda triangular a 440 Hz </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_noise.arts</filename +></term> +<listitem> +<para +>Genera ruido blanco. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_dtmf1.arts</filename +></term> +<listitem> +<para +>Genera un tono dual al producir ondas sinusoidales a 697 y 1.209 Hz, escalándolas por 0.5 y añadiéndolas juntas. Éste es el tono DMTF para el dígito «1» en un teclado de teléfono. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_atan_saturate.arts</filename +></term> +<listitem> +<para +>Ejecuta una onda triangular a través del filtro se saturación arcotangente. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_autopanner.arts</filename +></term> +<listitem> +<para +>Utiliza un desplazamiento automático para moldear una onda sinusoidal de 400 Hz desplazándola entre los altavoces izquierdo y derecho a una tasa de 2 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_brickwall.arts</filename +></term> +<listitem> +<para +>Escala una onda sinusoidal por un factor 5 y la pasa a través de un limitador de pendiente alta. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_bus.arts</filename +></term> +<listitem> +<para +>Enlaces descendentes a un bus llamado «Bus» y enlaces ascendentes al bus «salida_tarjeta_sonido» con los canales izquierdo y derecho reservados. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_cdelay.arts</filename +></term> +<listitem> +<para +>Enlaces descendentes a un bus llamado «Retraso», enlaces ascendentes al canal derecho con un retardo de 0,5 segundos, y el canal derecho sin cambios. Puede utilizar &artscontrol; para conectar el efecto a un reproductor de sonido y observar el resultado. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_delay.arts</filename +></term> +<listitem> +<para +>Es lo mismo que <filename +>example_cdelay.arts</filename +> pero usando el efecto retardo. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_capture_wav.arts</filename +></term> +<listitem> +<para +>Ésto usa Synth_CAPTURE_WAV para guardar una onda sinusoidal a 400Hz en un archivo wav. Ejecute el módulo durante unos segundos y luego examine el archivo creado en <filename class="directory" +>/tmp</filename +>. Puede reproducir el archivo con un reproductor como <application +>kaiman</application +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_data.arts</filename +></term> +<listitem> +<para +>Usa el módulo Data para generar un flujo constante de valor «3» y lo envía a un módulo de depuración para mostrarlo periódicamente. También contiene un módulo Nil, ilustrando cómo puede usarse para no hacer nada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_adsr.arts</filename +></term> +<listitem> +<para +>Muestra como crear un único instrumento de sonido usando el módulo Envoltorio Adsr, iniciado repetidamente por una onda cuadrada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_fm.arts</filename +></term> +<listitem> +<para +>Usa el módulo FM Source para generar una onda sinusoidal a 440 Hz que es una frecuencia modulada a un ratio de 5 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_freeverb.arts</filename +></term> +<listitem> +<para +>Conecta el efecto freeverb desde un bus de enlace descendente a un bus enlace de salida. Puede usar artscontrol para conectar el efecto a un reproductor de sonido y observar el resultado. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_flanger.arts</filename +></term> +<listitem> +<para +>Implementa un único efecto metálico (aunque parece que no funciona todavía). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_moog.arts</filename +></term> +<listitem> +<para +>Esta estructura combina los dos canales de un bus en otro, lo pasa a través del filtro Moog VCF, y lo envía fuera a través del bus salida_tarjeta_sonido. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pitch_shift.arts</filename +></term> +<listitem> +<para +>La estructura pasa el canal izquierdo de los datos de la tarjeta de sonido a través del efecto modificador del tono. Ajuste el parámetro velocidad para variar el efecto. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_rc.arts</filename +></term> +<listitem> +<para +>La estructura pasa un generador de ruido blanco a través de un filtro RC y la da salida a través de la tarjeta de sonido. Observando la pantalla FFT scope en artscontrol puede ver cómo cambia respecto a una onda de ruido sin filtro. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sequence.arts</filename +></term> +<listitem> +<para +>Muestra el módulo Secuencia reproduciendo una secuencia de notas. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_shelve_cutoff.arts</filename +></term> +<listitem> +<para +>Esta estructura pasa un ruido blanco a través del filtro de descenso de corte y lo da salida a través de la tarjeta de sonido. Observando la pantalla FFT scope en artscontrol puede ver cómo cambia respecto a una onda de ruido sin filtro. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_equalizer.arts</filename +></term> +<listitem> +<para +>Muestra el módulo Std_Equalizer. Aumenta las frecuencias altas y bajas en 6 dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tremolo.arts</filename +></term> +<listitem> +<para +>Muestra el efecto Trémolo. Modula los canales izquierdo y derecho usando un trémolo a 10Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_xfade.arts</filename +></term> +<listitem> +<para +>Este ejemplo mezcla ondas sinusoidales de 440 y 880 Hz usando un fundido cruzado. Ajuste el valor del porcentaje de entrada del fundido cruzado desde -1 a 1 para controlar la mezcla de las dos señales. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pscale.arts</filename +></term> +<listitem> +<para +>Ilustra el módulo Pscale (no estoy seguro si éste es un ejemplo significativo). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_play_wav.arts</filename +></term> +<listitem> +<para +>Ilustra el módulo reproducción de onda. Necesitará introducir la ruta completa a un archivo <literal role="extension" +>.wav</literal +> en el parámetro de nombre de archivo. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>example_multi_add.arts</term> +<listitem> +<para +>Muestra el módulo de añadido múltiple, que acepta cualquier número de entradas. Suma tres módulos de datos que producen de entrada 1, 2 y 3, y muestra el resultado 6. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/detail.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/detail.docbook new file mode 100644 index 00000000000..a2c121be936 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/detail.docbook @@ -0,0 +1,1337 @@ +<!-- <?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; en detalle</title> + +<sect1 id="architecture"> +<title +>Arquitectura</title> + +<mediaobject> +<imageobject> +<imagedata fileref="arts-structure.png" format="PNG"/> +</imageobject> +<textobject +><phrase +>La estructura de &arts;.</phrase +></textobject> +</mediaobject> +</sect1> + +<sect1 id="modules-ports"> +<title +>Módulos y puertos</title> + +<para +>La idea de &arts; es que la síntesis se puede hacer a través del uso de pequeños módulos, que sólo hacen una cosa y que, se pueden combinar en estructuras complejas. Los pequeños módulos normalmente tiene entradas, por donde pueden recibir señales o parámetros, y salidas, por donde producen señales. </para> + +<para +>Un módulo (Synth_ADD), por ejemplo, puede coger dos señales en la entrada y juntarlas. El resultado es la señal de salida. Los lugares por los que los módulos envían y reciben señales se denominan puertos. </para> + +</sect1> + +<sect1 id="structures"> +<title +>Estructuras</title> + +<para +>Una estructura es una combinación de módulos conectados, algunos de los cuales pueden tener parámetros codificados directamente en sus puertos de entrada, otros pueden estrar conectados, y otros puede que no estén conectados en absoluto. </para> + +<para +>Lo que se puede hacer con &arts-builder; es describir estructuras. Usted describe qué módulos desea que estén conectados con otros módulos. Cuando haya terminado, puede guardar la descripción de la estructura en un archivo, o decirle a &arts; que genere la estructura que usted ha descrito (Ejecutar). </para> + +<para +>Lo más probable es que se oiga un sonido, si todo está hecho correctamente. </para> +</sect1> + +<!-- TODO + +<sect1 id="streams"> +<title +>Streams</title> + +</sect1> + +--> + +<sect1 id="latency"> +<title +>Latencia</title> + +<sect2 id="what-islatency"> +<title +>¿Qué es la latencia?</title> + +<para +>Suponga que tiene una aplicación llamada «ratónpling» (que hace que suene un «pling» cada vez que pulse un botón del ratón). La latencia es el tiempo que transcurre desde que su dedo pulsa el botón del ratón hasta que escucha el sonido. La latencia en este caso se compone a sí misma a partir de otras latencias, que pueden tener diferentes causas. </para> + +</sect2> + +<sect2 id="latenbcy-simple"> +<title +>Latencia en aplicaciones sencillas</title> + +<para +>En esta sencilla aplicacióm, la latencia se produce en estos lugares: </para> + +<itemizedlist> + +<listitem> +<para +>El tiempo transcurrido desde que el núcleo ha comunicado al servidor X11 que se ha pulsado un botón del ratón. </para> +</listitem> + +<listitem> +<para +>El tiempo desde que el servidor X11 notifica a su aplicación que se ha pulsado un botón del ratón. </para> +</listitem> + +<listitem> +<para +>El tiempo desde que la aplicación ratónpling decide que ese botón se merece un pling. </para> +</listitem> + +<listitem> +<para +>El tiempo que tarda la aplicación ratónpling en decirle al servidor de sonido que debe reproducir un pling. </para> +</listitem> + +<listitem> +<para +>El tiempo que tarda el pling (que el servidor de sonido mezcla con otras salidas al mismo tiempo) en pasar por la memoria de intercambio de datos, hasta que llega a la posición en la que la tarjeta de sonido lo reproduce. </para> +</listitem> + +<listitem> +<para +>El tiempo que tarda el pling en llegar desde los altavoces hasta sus oidos. </para> +</listitem> +</itemizedlist> + +<para +>Los tres primeros puntos son latencias externas a &arts;. Son interesantes, pero fuera del objetivo de este documento. En cualquier caso, tenga en cuenta que existen, así que aunque haya optimizado todo lo demás, puede que no siempre obtenga exactamente el resultado calculado. </para> + +<para +>Decirle al servidor que reproduzca algo normalmente implica una simple llamada a &MCOP;. Existe un punto de referencia que confirma esto, en el propio servidor con conexiones al dominio unix, diciéndole al servidor que reproduzca algo alrededor de 9.000 veces por segundo con la implementación actual. Espero que la mayor parte de esto sea utilizado por el núcleo del sistema, cambiando de una aplicación a otra. Por supuesto, este valor cambia con el tipo exacto de parámetros. Si transfiere una imagen completa con una llamada, se volverá tan lento como si sólo transfiriera un valor. El código devuelto por el mismo es true. Sin embargo, para las cadenas habituales (como el nombre de un archivo <literal role="extension" +>wav</literal +> que se vaya a reproducir) no debería haber problema. </para> + +<para +>Ésto significa que podemos aproximarnos a ese momento en 1/9.000 segundos, eso es inferior a 0,15 milisegundos. Como veremos esto no es relevante. </para> + +<para +>Lo siguiente es el tiempo entre que el servidor comienza a reproducir y la tarjeta de sonido hace algo. El servidor necesita llenar la memoria de intercambio, por ello cuando otras aplicaciones se ejecutan, como su servidor X11 o la aplicación «ratónpling» se perderá información que no se oirá. La forma en que se hace ésto bajo &Linux; es a través de una serie de fragmentos de un tamaño. El servidor recargará los fragmentos y la tarjeta de sonido los reproducirá. </para> + +<para +>Así que supongamos que hay tres fragmentos. El servidor rellena el primero, la tarjeta de sonido comienza a reproducir. El servidor rellena el segundo. El servidor rellena el tercero. El servidor ha terminado, la otras aplicaciones ya pueden volver a hacer cosas. </para> + +<para +>Una vez que la tarjeta de sonido ha terminado con el primer fragmento, comienza a reproducir el segundo y el servidor comienza a rellenar el primero. Y así contínuamente. </para> + +<para +>La latencia máxima que se puede tener con todo esto es (número de fragmentos)*(tamaño de cada fragmento)/(ratio de muestreo * (tamaño de cada muestra)). Suponga que tomamos sonido estéreo de 44kHz, y 7 fragmentos de 1.024 bytes (el tamaño predeterminado de aRts), tendremos 40 milisegundos. </para> + +<para +>Estos valores pueden ser ajustados de acuerdo a sus necesidades. Sin embargo, el uso de <acronym +>CPU</acronym +> aumenta con menores latencias, ya que el servidor de sonido necesita rellenar la memoria intermedia más a menudo y en partes más pequeñas. Es también casi imposible alcanzar buenos valores si no se le da al servidor de sonido prioridad en tiempo real, ya que de otra manera obtendrá separaciones. </para> + +<para +>Sin embargo, es realista hacer algo similar con 3 fragmentos de 256 bytes cada uno, que podrían hacer este valor 4,4 ms. Con 4,4 ms de retardo de la inactividad de utilización de la <acronym +>CPU</acronym +> por parte de &arts; será de alrededor del 7,5%. Con 40 ms de retardo, sería de alrededor del 3% (en un PII-350, y este valor puede depender de su tarjeta de sonido, versión del núcleo, etc.). </para> + +<para +>Después está el tiempo que tarda el sonido pling en llegar desde los altavoces hasta sus oidos. Suponga que la distancia con los altavoces es de 2 metros. El sonido viaja a una velocidad de 330 metros por segundo. Así que serán aproximadamente 6 milisegundos. </para> + +</sect2> + +<sect2 id="latency-streaming"> +<title +>La latencia en las aplicaciones de transmisión</title> + +<para +>Las aplicaciones de transmisión son aquellas que producen sonido por sí mismas. Piense en un juego, que da salida a una transmisión constante de muestras, y que debe ser adaptado para funcionar por medio de &arts;. Por ejemplo: al pulsar una tecla, la figura de la pantalla salta, y se reproduce un sonido tipo boing. </para> + +<para +>En primer lugar, necesita saber cómo realiza &arts; la transmisión. Es muy similar a la E/S de la tarjeta de sonido. El juego envía algunos paquetes con secuencias al servidor de sonido. Digamos tres paquetes. Tan pronto como el servidor de sonido termina con el primero, envía una confirmación al juego conforme el paquete está realizado. </para> + +<para +>El juego genera otro paquete de sonido y lo envía al servidor. Mientras tanto el servidor comienza a consumir el segundo paquete de sonido, y así contínuamente. En este caso la latencia es similar a la del caso sencillo: </para> + +<itemizedlist> +<listitem> +<para +>El tiempo hasta que el núcleo informa al servidor X11 de que se ha pulsado una tecla. </para> +</listitem> + +<listitem> +<para +>El tiempo hasta que el servidor X11 notifica al juego que se ha pulsado una tecla. </para> +</listitem> + +<listitem> +<para +>El tiempo hasta que el juego decide que esa tecla se merece un boing. </para> +</listitem> + +<listitem> +<para +>El tiempo hasta que el paquete de sonido en el que el juego pone el sonido boing llega hasta el servidor de sonido. </para> +</listitem> + +<listitem> +<para +>El tiempo que tarda el boing (que el servidor de sonido inicia mezclado simultáneamente con otra salida) en ir desde la memoria intermedia de datos, hasta que alcanza la posición en la que se reproducirá por la tarjeta de sonido. </para> +</listitem> + +<listitem> +<para +>El tiempo que tarda el sonido boing en llegar desde los altavoces hasta sus oidos. </para> +</listitem> + +</itemizedlist> + +<para +>Las latencias externas, como en el caso anterior, no son el objeto de este documento. </para> + +<para +>Obviamente, la latencia de la transmisión depende del tiempo en que todos los paquetes usados para el flujo tardan en reproducirse una vez. Ésto es (número de paquetes)*(tamaño de cada paquete)/(ratio de muestreo * (tamaño de cada secuencia)). </para> + +<para +>Como puede ver es la misma fórmula que se aplica a los fragmentos. Sin embargo, para los juegos, no da la sensión de que ni siquiera haya un pequeño retardo. Una configuración realista para juegos podría ser 2.048 bytes por paquete, utilizando 3 paquetes. La latencia resultante será de 35 ms. </para> + +<para +>Se basa en lo siguiente: se asume que el juego renderiza 25 imágenes por segundo (para la pantalla). Es probable que asuma que no desee diferencias entre la salida de sonido y una imagen. Por lo que un retraso de 1/25 para el flujo es aceptable, que al cambio son unos 40 ms. </para> + +<para +>La mayor parte de la gente tampoco ejecutará sus juegos con prioridad en tiempo real, y el peligro de saltos en el sonido no debe ser descuidado. Un flujo con 3 paquetes de 256 bytes es posible (yo lo intenté) - pero causa un gran uso de <acronym +>CPU</acronym +> para la transmisión. </para> + +<para +>En las latencias del lado del servidor, éstas se puede calcular exactamente igual que en el caso anterior. </para> + +</sect2> + +<sect2 id="cpu-usage"> +<title +>Algunas consideraciones sobre el uso de la <acronym +>CPU</acronym +></title> + +<para +>Existen muchos factores que influyen en el uso de la <acronym +>CPU</acronym +> en un escenario complejo con aplicaciones de flujo y de otros tipos, extensiones en el servidor etc. Por nombrar alguno: </para> + +<itemizedlist> +<listitem> +<para +>Uso de la <acronym +>CPU</acronym +> sin procesar para efectuar los cálculos necesarios. </para> +</listitem> + +<listitem> +<para +>Planificación interna del uso del sistema de &arts; - Cómo decide &arts; con qué módulo cargar qué. </para> +</listitem> + +<listitem> +<para +>Uso del sistema en la conversión de entero a flotante. </para> +</listitem> + +<listitem> +<para +>Uso del sistema en el protocolo &MCOP;0. </para> +</listitem> + +<listitem> +<para +>Núcleo: cambiar proceso/contexto. </para> +</listitem> + +<listitem> +<para +>Núcleo: uso del sistema de comunicación. </para> +</listitem> +</itemizedlist> + +<para +>Si reproduce dos transferencias, necesitará hacer añadidos a los cálculos de uso de la <acronym +>CPU</acronym +>. Si aplica un filtro, éste puede implicar algunos cálculos. Veamos un ejemplo simplificado, añadir dos transferencias implica quizá cuatro ciclos de <acronym +>CPU</acronym +> adicionales, lo que en un procesador de 350Mhz, sería un 44.100*2*4/350.000.000 = 0,1% de uso de la <acronym +>CPU</acronym +>. </para> + +<para +>Planificación interna de &arts;: &arts; necesita decidir qué extensión debe calcular qué y cuándo. Esto lleva tiempo. Haga un análisis si está interesado en ésto. Generalmente se puede decir: menor tiempo real utiliza (&ie;, grandes bloques que se pueden calcular a la vez) menor uso del sistema para planificación. Para calcular bloques de 128 muestras a la vez (utilizando tamaños de fragmento de 512 bytes) la utilización del uso del sistema para planificación no consume mucho. </para> + +<para +>Uso del sistema en la conversión de entero a flotante: &arts; utiliza internamente como formato de datos los números de coma flotante. Son sencillos de manejar y en los procesadores recientes no son tan lentos como las operaciones con enteros. Sin embargo, si existen clientes que reproducen datos que no están en coma flotante (como un juego que deba reproducir una salida de sonido a través de &arts;), necesitará conversión. Lo mismo se aplica si desea reproducir sonidos en su tarjeta de sonido. Las tarjetas de sonido trabajan con enteros, por tanto, necesitará convertirlos. </para> + +<para +>Veamos los números para un Celeron, aprox. ticks por muestra, con -O2 +egcs 2.91.66 (tomado por Eugene Smith <email +>[email protected]</email +>). Por supuesto esto depende en gran medida del procesador: </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 +>Lo que significa 1% de uso de <acronym +>CPU</acronym +> para la conversión y 5% para la interpolación en este procesador a 350 MHz. </para> + +<para +>Uso del sistema por el protocolo &MCOP;: &MCOP; hace, por lo general, 9.000 llamadas por segundo. La mayor parte de las cuales no son debidos a &MCOP;, estando relacionadas con las dos situaciones que se describen a continuación. Sin embargo, esto nos proporciona una base para calcular el coste de la transferencia. </para> + +<para +>Cada paquete de datos transferidos se puede considerar una llamada &MCOP;. Por supuesto, los paquetes grandes serán más lentos que 9.000 paquetes, pero ésta es la idea. </para> + +<para +>Supongamos que usa paquetes de 1.024 bytes. Así que, para transferir un flujo a 44kHz estéreo, necesitará transferir 44.100*4/1.024 = 172 paquetes por segundo. Supongamos que pueda con un uso del 100% de cpu transferir 9.000 paquetes, entonces obtendrá un (172*100)/9.000 = 2% de uso de <acronym +>CPU</acronym +> para hacer un flujo con paquetes de 1.024 bytes. </para> + +<para +>Ésto es una aproximación. Sin embargo, muestra que debería mejorar (si puede proporcionarlo para la latencia), para utilizar, por ejemplo, paquetes de 4.096 bytes. Podemos escribir una fórmula compacta, calculando el tamaño del paquete que provocaría la utilización del 100% de la <acronym +>CPU</acronym +> como 44.100*4/9.000 = 19,6 muestras, consiguiendo así la siguiente fórmula: </para> + +<para +>Uso de la <acronym +>CPU</acronym +> por la transferencia en porcentaje = 1.960/(tamaño de paquete). </para> + +<para +>Esto nos da un 0,5% de uso de <acronym +>CPU</acronym +> cuando se hace una transmisión con paquetes de 4.096 bytes. </para> + +<para +>Cambio del proceso del núcleo/contexto: forma parte del uso del sistema por parte del protocolo &MCOP;. El cambio entre dos procesos lleva su tiempo. Existe un nuevo mapeado de memoria, la caché ya no es válida (si hay un experto en núcleos leyendo ésto - déjeme indicarle cuáles son las causas). Esto significa: lleva tiempo. </para> + +<para +>No estoy seguro de cuantos cambios de contexto puede hacer &Linux; por segundo, pero no es un número infinito. Por ello, supongo que una parte del uso del sistema por parte del protocolo &MCOP; se debe al cambio de contexto. En los comienzos de &MCOP;, comprobé el uso de la misma comunicación dentro de un proceso, e iba mucho más rápido (cuatro veces más rápido o más). </para> + +<para +>Núcleo: uso del sistema de comunicación: Forma parte del uso del sistema por parte del protocolo &MCOP;. Transferir datos entre procesos se suele hacer a través de conexiones. Esto es conveniente, pues los métodos select() se pueden utilizar para determinar cuando ha llegado un mensaje. También se puede combinar fácilmente con otras fuentes de E/S como E/S de audio, servidor X11 o cualquier otra. </para> + +<para +>Sin embargo, estas llamadas de lectura y escritura cuestan ciertos ciclos de procesador. Para pequeñas llamadas (como transferir un evento midi) esto no será probablemente un problema, pero para grandes llamadas (como transferir una imagen de vídeo de muchos megabytes) puede ser claramente un problema. </para> + +<para +>Añadir el uso de memoria compartida a &MCOP; donde se necesite es probablemente la mejor solución. Sin embargo, debe hacerse transparente para el programador de la aplicación. </para> + +<para +>Tome un analizador o haga pruebas para averiguar como influyen las transferencias de audio en la memoria compartida no utilizada. Sin embargo, no todo es malo, ya que la transferencia de audio (reproducción de mp3) se puede hacer con un uso de <acronym +>CPU</acronym +> del 6% por parte de &artsd; y <application +>artscat</application +> (y 5% para el decodificador mp3). Sin embargo, esto incluye todos los cálculos necesarios del uso del sistema de conexión, así se podría decir que quizá sería posible ahorrar hasta un 1% del uso de la memoria compartida. </para> + +</sect2> + +<sect2 id="hard-numbers"> +<title +>Hagamos números</title> + +<para +>Están hechos con la versión actual en desarrollo. Deseaba probar casos reales extremos, que no son los que las aplicaciones deberían utilizar en el día a día. </para> + +<para +>Escribí una aplicación llamada streamsound que envía transferencias de datos a &arts;. Aquí la vemos ejecutándose con prioridad de tiempo real (sin problemas), y una pequeña extensión de servidor (escalado de volumen y recorte): </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 +>Cada una de ellas es una transferencia con 3 fragmentos de 1.024 bytes (18 ms). Hay tres clientes ejecutándose simultáneamente. Se que ésto parece un poco excesivo, pero me dije: toma un analizador y busca el coste de tiempo, y si quiere, mejórelo. </para> + +<para +>Sin embargo, no pensé en utilizar la transferencia de forma realista o que tuviera sentido. Para llevarlo aún más al extremo, intenté averiguar cual sería el estado latente más bajo posible. Resultado: puede hacer transferencia sin interrupciones con una aplicación cliente, si utiliza 2 fragmentos de 128 bytes entre aRts y la tarjeta de sonido, y entre la aplicación cliente y aRts. Esto significa que obtendrá una latencia total máxima de 128*4/44.100*4 = 3 ms, de los que 1,5 ms se deben a la E/S de la tarjeta de sonido y los 1,5 ms restantes están motivados por la comunicación con &arts;. Ambas aplicaciones necesitan tiempo real de ejecución. </para> + +<para +>Pero esto consume una enorme cantidad de <acronym +>CPU</acronym +>. Este ejemplo consume alrededor del 45% de mi P-II/350. A esto hay que sumarle el movimiento de las ventanas en su X11 o los accesos de E/S al disco. Todas estas son funciones del núcleo. El problema es que programar dos o más aplicaciones con prioridad de tiempo real consume cantidades enormes, y más todavía si se producen comunicaciones, notificaciones entre ellas, &etc;. </para> + +<para +>Finalmente, un ejemplo más cercano a la vida real. Es &arts; con artsd y un artscat (un cliente de transmisiones) ejecutando 16 fragmentos de 4.096 bytes. </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 +>Buses</title> + +<para +>Los buses son conexiones construídas dinámicamente que transfieren sonido. Básicamente, existen unos enlaces ascendentes y otros descendentes. Todas las señales de los enlaces ascendentes se añaden y envían a los enlaces descendentes. </para> + +<para +>Los buses están actualmente implementados para operar en estéreo, por tanto, solo podrá transferir datos en estéreo a través de los buses. Si desea utilizar datos en mono, bueno, tranfiéralos sobre un canal y deje el otro a cero. Todo lo que necesita hacer es crear uno o más objetos Synth_BUS_UPLINK y decirles el nombre del bus, en el que deberían hablar (⪚ «audio» o «batería»). </para> + +<para +>Entonces, necesitará crear uno o más objetos Synth_BUS_DOWNLINK, e indicar el nombre del bus («audio» o «batería» ... si coinciden los datos pasarán), y los datos combinados saldrán otra vez. </para> + +<para +>Los enlaces ascendentes y descendentes pueden estar en diferentes estructuras, puede incluso tener diferentes &arts-builder;s ejecutándose, e iniciar un enlace ascendente en uno y recibir los datos desde el otro con un enlace descendente. </para> + +<para +>Lo bueno de los buses es que son totalmente dinámicos. Los clientes pueden conectarse y desconectarse al vuelo. No debería haber ruidos o chasquidos mientras esto sucede. </para> + +<para +>Por supuesto, no debe desconectar un cliente mientras se reproduce un señal, ya que probablemente no tendrá un nivel cero cuando se desconecte el bus, y entonces chasqueará. </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 +>Negociación</title> + +<para +>&arts;/&MCOP; está fuertemente dividido en pequeños componentes. Ésto hace las cosas muy flexibles, de forma que pueda extender el sistema fácilmente añadiendo nuevos componentes, que implementen nuevos efectos, formatos de archivo, osciladores, elementos de gui, ... Como casi todo es un componente, casi todo puede ser extendido fácilmente, sin cambiar las fuentes existentes. Los nuevos componentes puede cargarse dinámicamente de forma simple para mejorar aplicaciones ya existentes. </para> + +<para +>Sin embargo, para realizar este trabajo, se requieren dos cosas: </para> + +<itemizedlist> + +<listitem> +<para +>Los componentes deben anunciarse a sí mismos - deben describir qué es lo que ofrecen, para que las aplicaciones sean capaces de usarlos. </para> +</listitem> + +<listitem> +<para +>Las aplicaciones deben buscar activamente componentes que pueden usar, en lugar de usar siempre lo mismo para la misma tarea. </para> +</listitem> + +</itemizedlist> + +<para +>La combinación de ésto: componentes que dicen «aquí estoy, soy genial, úsame» , y aplicaciones (o si prefiere, otros componentes) que salen y buscan qué componentes pueden usar para llevar a cabo una tarea, se llama negociación. </para> + +<para +>En &arts;, los componentes se describen a sí mismos especificando valores que pueden «soportar» para distintas propiedades. Una propiedad típica para un componente cargador de archivos puede ser la extensión de los archivos que puede procesar. Los valores típicos pueden ser <literal role="extension" +>wav</literal +>, <literal role="extension" +>aiff</literal +> o <literal role="extension" +>mp3</literal +>. </para> + +<para +>De hecho, todos los componentes pueden ofrecer muchos valores diferentes para una propiedad. Por lo que un simple componente puede ofrecer leer tanto archivos, <literal role="extension" +>wav</literal +> como <literal role="extension" +>aiff</literal +>, especificando que soportan estos valores para la propiedad «Extensión». </para> + +<para +>Para hacer esto, cada componente tiene que colocar un archivo <literal role="extension" +>.mcopclass</literal +> en el sitio correcto, que contenga las propiedades que soporta. En nuestro ejemplo, podría parecerse a esto (y estaría instalado en <filename +><replaceable +>componentdir</replaceable +> /Arts/WavPlayObject.mcopclass</filename +>): </para> + +<programlisting +>Interface=Arts::WavPlayObject,Arts::PlayObject,Arts::SynthModule,Arts::Object +Author="Stefan Westerfeld <[email protected]>" +URL="http://www.arts-project.org" +Extension=wav,aiff +MimeType=audio/x-wav,audio/x-aiff +</programlisting> + +<para +>Es importante que el nombre del archivo <literal role="extension" +>.mcopclass</literal +> indique qué interfaz del componente se llamará. La negociación no busca contenidos, si el archivo (como aquí) se llama <filename +>Arts/WavPlayObject.mcopclass</filename +>, la interfaz del componente se llamará <interfacename +>Arts::WavPlayObject</interfacename +> (mapa de los módulos de las carpetas). </para> + +<para +>Para buscar componentes, existen dos interfaces (que están definidas en <filename +>core.idl</filename +>, de forma que los pueda tener en cada aplicación), llamados <interfacename +>Arts::TraderQuery</interfacename +> y <interfacename +>Arts::TraderOffer</interfacename +>. Usted podrá «ir de compras» de componentes de una forma similar a: </para> + +<orderedlist> +<listitem> +<para +>Cree un objeto solicitud: </para> +<programlisting +>Arts::TraderQuery query; +</programlisting> +</listitem> + +<listitem> +<para +>Especifique lo que desea. Como puede ver arriba, los componentes se describen a sí mismos usando propiedades, para las que ofrecen ciertos valores. Por lo que para precisar lo que desea se seleccionan los componentes que soportan cierto valor para una propiedad. Ésto se hace usando el método de soporte de un TraderQuery: </para> + +<programlisting +>query.supports("Interface","Arts::PlayObject"); + query.supports("Extension","wav"); +</programlisting> +</listitem> + +<listitem> +<para +>Finalmente, realice la petición usando el método de solicitud. Entonces, obtendrá (con esperanza) algunas ofertas: </para> + +<programlisting +>vector<Arts::TraderOffer> *offers = query.query(); +</programlisting> +</listitem> + +<listitem> +<para +>Ahora puede examinar lo que encontró. Es importante el método interfaceName de TraderOffer, que le dice el nombre del componente que cumple la solicitud. Puede también encontrar más propiedades mediante getProperty. El código siguiente simplemente recorrerá todos los componentes, escribirá sus nombres de interfaz (que pueden usarse para la creación), y borrará los resultados de la solicitud otra vez: </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 +>Para que este tipo de servicio de negociación sea práctico, es importante que de alguna manera se acuerde el tipo de propiedades que se deberían definir. Es esencial que más o menos todos los componentes en un determinado área utilicen el mismo conjunto de propiedades que los describan (y el mismo conjunto de valores aplicables), de modo que las aplicaciones (u otros componentes) puedan encontrarlos. </para> + +<para +>Author (tipo string, opcional): Puede usarse para dar a conocer al mundo que usted escribió algo. Puede escribir lo que quiera aquí, y por supuesto su dirección de correo electrónico. </para> + +<para +>Buildable (tipo lógico, recomendado): Indica si el componente es utilizable con las herramientas <acronym +>RAD</acronym +> (como &arts-builder;) que utiliza componentes asignándoles propiedades y conectando puertos. Es recomendable fijar este valor a true para casi cualquier proceso de señal del componente (como filtros, efectos, osciladores, ...), y para todo lo demás que pueda ser utilizado en <acronym +>RAD</acronym +>, pero no para los elementos internos, como por ejemplo, <interfacename +>Arts::InterfaceRepo</interfacename +>. </para> + +<para +>Extension (tipo string, usar cuando sea necesario): Todo lo que trate con archivos debe considerar usarlo. Debe poner la forma en minúsculas de la extensión de archivo sin el «.», por lo que algo como <userinput +>wav</userinput +> debe valer. </para> + +<para +>Interface (tipo string, requerido): Debe incluir una lista completa de las interfaces (útiles) que sus componentes soportan, probablemente incluyendo <interfacename +>Arts::Object</interfacename +> y si se puede aplicar <interfacename +>Arts::SynthModule</interfacename +>. </para> + +<para +>Language (tipo string, recomendado). Si desea que su componente se cargue dinámicamente, necesita especificar el lenguaje aquí. Actualmente, el único valor permitido es <userinput +>C++</userinput +>, lo que significa que el componente se escribió usando la <acronym +>API</acronym +> normal de C++. Si hace eso, necesitará también asignar un valor a la propiedad «Library». </para> + +<para +>Library (tipo string, usar cuando sea necesario): Los componentes escritos en C++ pueden cargarse dinámicamente. Para hacerlo, necesita compilarlos en un módulo cargable dinámicamente de bibiloteca de herramientas (<literal role="extension" +>.la</literal +>). Aquí puede especificar el nombre del archivo <literal role ="extension" +>.la</literal +> que contiene su componente. Recuerde usar REGISTER_IMPLEMENTATION (como siempre). </para> + +<para +>MimeType (tipo string, usar cuando sea necesario): Todo aquello que trate con archivos debería utilizarlo. Debe poner en minúsculas la forma del tipo mime estándar, por ejemplo <userinput +>audio/x-wav</userinput +>. </para> + +<para +>&URL; (tipo string, opcional): Si quiere dar a conocer a la gente dónde puede encontrar una nueva versión del componente (o una página o algo así), puede hacerlo aquí. Debe ser una &URL; &HTTP; o &FTP; estándar. </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 +>Espacios de nombres en &arts;</title> + +<sect2 id="namespaces-intro"> +<title +>Introducción</title> + +<para +>Cada declaración de un espacio de nombres se corresponde con la declaración de un «módulo» en la &IDL; de &MCOP;. </para> + +<programlisting +>// idl mcop + +module M { + interface A + { + } +}; + +interface B; +</programlisting> + +<para +>En este caso, el código C++ generado por el trozo &IDL; debería ser algo similar a esto: </para> + +<programlisting +>// cabecera C++ + +namespace M { + /* declaración de A_base/A_skel/A_stub y similares */ + class A { // Clase del interfaz de referencia + /* [...] */ + }; +} + +/* declaración de B_base/B_skel/B_stub y similares */ +class B { + /* [...] */ +}; +</programlisting> + +<para +>Por tanto, para referenciar en su código C++ las clases del ejemplo anterior, debería escribir <classname +>M::A</classname +>, pero solo B. Sin embargo, puede, por supuesto, utilizar «using M» en algunos lugares - como con cualquier espacio de nombres en C++. </para> + +</sect2> + +<sect2 id="namespaces-how"> +<title +>Cómo usa &arts; los espacios de nombres</title> + +<para +>Hay un espacio de nombres global llamado «Arts», que todos los programas y librerías que pertenecen a &arts; usan para poner sus declaraciones. Ésto significa, que cuando se escrible código C++ que depende de &arts;, normalmente se deberán prefijar todas las clases que use con <classname +>Arts::</classname +>, como aquí: </para> + +<programlisting +>int main(int argc, char **argv) +{ + Arts::Dispatcher repartidor; + Arts::SimpleSoundServer servidor(Arts::Reference("global:Arts_SimpleSoundServer")); + + servidor.play("/var/foo/archivo.wav"); +</programlisting> + +<para +>La otra alternativa es escribirlo utilizando using, como en: </para> + +<programlisting +>using namespace Arts; + +int main(int argc, char **argv) +{ + Dispatcher repartidor; + SimpleSoundServer servidor(Reference("global:Arts_SimpleSoundServer")); + + server.play("/var/foo/archivo.wav"); + [...] +</programlisting> + +<para +>En los archivos &IDL;, no necesitará hacer una elección concreta. Si está escribiendo código perteneciente al propio &arts;, debería colocarlo en el módulo &arts;. </para> + +<programlisting +>// Archivo IDL para código aRts: +#include <artsflow.idl> +module Arts { // lo pone dentro del espacio de nombres de Arts + interface Synth_TWEAK : SynthModule + { + in audio stream entrada; + out audio stream salida; + attribute float factorAjuste; + }; +}; +</programlisting> + +<para +>Si escribe código que no pertenece a &arts;, no debe ponerlo en el espacio de nombres de «Arts». Sin embargo, puede hacer un espacio de nombres propio si lo desea. En cualquier caso, tendrá que prefijar las clases que use de &arts;. </para> + +<programlisting +>// Archivo IDL para el código que no pertenece a aRts: +#include <artsflow.idl> + +// lo escrito sin declaración de módulo, entonces las clases generadas no utilizarán +// un espacio de nombres: +interface Synth_TWEAK2 : Arts::SynthModule +{ + in audio stream entrada; + out audio stream salida; + attribute float factorAjuste; +}; + +// sin embargo, también puede elegir su propio espacio de nombres, si lo desea, así si +// escribe una aplicación «Radio», podrá, por ejemplo, hacer algo parecido a: +module Radio { + struct Emisora { + string nombre; + float frecuencia; + }; + + interface Sintonizador : Arts::SynthModule { + attribute Emisora emisora; // no necesita el prefijo Emisora por pertenecer al mismo módulo + out audio stream izquierdo, derecho; + }; +}; +</programlisting> + +</sect2> + +<sect2 id="namespaces-implementation"> +<title +>Detalles internos: Cómo funciona la implementación</title> + +<para +>Algunas veces, en los interfaces, modelos, firmas de métodos y similares, &MCOP; necesita referirse a los nombre de los tipos o interfaces. Éstos se representan como cadenas en las estructuras de datos comunes de &MCOP;, mientras que el nombre del espacio es siempre una representación completa en el estilo C++. Ésto significa que las cadenas podrían contener «M::A» y «B», siguiendo el ejemplo anterior. </para> + +<para +>Tenga en cuenta que esto se aplica dentro del texto &IDL; incluso sino se dieron los calificadores del espacio de nombres, desde el contexto se aclara que el interfaz del espacio de nombres <interfacename +>A</interfacename +> se utilizará dentro. </para> + +</sect2> +</sect1> + +<sect1 id="threads"> +<title +>Hilos en &arts;</title> + +<sect2 id="threads-basics"> +<title +>Básico</title> + +<para +>Usar hilos no es posible en todas las plataformas. Por eso &arts; se escribió originalmente sin hacer uso de los hilos. Para casi todos los problemas, por cada solución con hilos al problema, existe una solución sin hilos que hace lo mismo. </para> + +<para +>Por ejemplo, en lugar de colocar la salida de audio en un hilo separado, y hacer que lo bloquee, &arts; utiliza salida de audio no bloqueante, y sabe cuando escribir el siguiente bloque de datos utilizando <function +>select()</function +>. </para> + +<para +>Sin embargo, &arts; (en las versiones más recientes) al menos provee soporte para aquellos que desean implementar sus objetos usando hilos. Por ejemplo, si ya ha hecho el código para un reproductor <literal role="extension" +>mp3</literal +>, y el código espera que el decodificador <literal role="extension" +>mp3</literal +> se ejecute en un hilo distinto, normalmente lo más fácil es mantener este diseño. </para> + +<para +>La implementación &arts;/&MCOP; se construye compartiendo el estado entre objetos separados de formas obvias y no tan obvias. Una pequeña lista de los estados compartidos incluye: </para> + +<itemizedlist> +<listitem +><para +>El objeto Dispatcher que establece la comunicación con &MCOP;. </para> +</listitem> + +<listitem> +<para +>La cuenta de referencia (Referencias inteligentes). </para> +</listitem> + +<listitem> +<para +>El IOManager (administrador de E/S) que crea el contador y los relojes fd. </para> +</listitem> + +<listitem> +<para +>El administrador de objetos que crea los objetos y carga las extensiones dinámicamente. </para> +</listitem> + +<listitem> +<para +>El sistema de transmisión que llama a los bloques de cálculo cuando sea necesario. </para> +</listitem> +</itemizedlist> + +<para +>No se espera utilizar los objetos anteriores concurrentemente (&ie;, llamados desde hilos diferentes al mismo tiempo). Generalmente existen dos formas para resolver esto: </para> + +<itemizedlist> +<listitem> +<para +>Haciendo que las llamadas a este objeto desde cualquier función realicen un bloqueo antes de utilizarlo. </para> +</listitem> + +<listitem> +<para +>Haciendo que estos objetos utilicen hilos seguros y/o creen instancias para cada uno de los hilos. </para> +</listitem> +</itemizedlist> + +<para +>&arts; sigue una primera aproximación: necesitará un bloqueo siempre que se comunique con estos objetos. Una segunda aproximación es más complicada. Está disponible en <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 +>, pero en este punto, será más adecuada una aproximación mínima y provocará menos problemas con aplicaciones existentes. </para> + +</sect2> +<sect2 id="threads-locking"> +<title +>¿Cúando/cómo efectuar el bloqueo?</title> + +<para +>Puede crear/liberar el bloqueo con dos funciones: </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 +>Generalmente, no necesitará hacer un bloqueo (y no debería intentar hacerlo), si ya estaba hecho. Una lista de condiciones cuando éste es el caso es: </para> + +<itemizedlist> +<listitem> +<para +>Recibe una llamada desde el IOManager (contador o fd). </para> +</listitem> + +<listitem> +<para +>Obtiene una llamada de una petición &MCOP;. </para> +</listitem> + +<listitem> +<para +>Recibe una llamada del administrador de notificaciones. </para> +</listitem> + +<listitem> +<para +>Recibe una llamada del sistema de transmisión (bloque de cálculo). </para> +</listitem> +</itemizedlist> + +<para +>Existen algunas excepciones a las funciones, que únicamente podrá llamar en el hilo principal, y por esta razón nunca necesitará bloquear una llamada a estas. </para> + +<itemizedlist> +<listitem> +<para +>Constructor/destructor de Dispatcher/IOManager. </para> +</listitem> + +<listitem> +<para +><methodname +>Dispatcher::run()</methodname +> / <methodname +>IOManager::run()</methodname +> </para> +</listitem> + +<listitem> +<para +><methodname +>IOManager::processOneEvent()</methodname +></para> +</listitem> +</itemizedlist> + +<para +>Para todo con lo que se relacione de alguna manera con &arts;, necesitará hacer un bloqueo, y eliminarlo nuevamente cuando haya terminado. Siempre. Veamos un ejemplo simple: </para> + +<programlisting +>class HiloTiempoSuspendido : Arts::Thread { +public: + void run() { + /* + * necesitará este bloqueo porque: + * - construir una referencia necesita un bloqueo (como global: irá + * al administrador de objetos, que puede cambiar el objeto GlobalComm + * para buscar dónde conectarse) + * - asignar una referencia inteligente necesita un bloqueo + * - construir un objeto desde una referencia necesita un bloqueo (porque + * podría necesitar conectarse a un servidor) + */ + Arts::Dispatcher::lock(); + Arts::SoundServer servidor = Arts::Reference("global:Arts_SoundServer"); + Arts::Dispatcher::unlock(); + + for(;;) { /* + * necesitaría hacer un bloqueo aquí porque + * - deshacer una referencia a una referencia inteligente precisa un bloqueo (porque se crea + * cuando hace falta) + * - hacer una llamada MCOP necesita un bloqueo + */ + Arts::Dispatcher::lock(); + long segundos = servidor.secondsUntilSuspend(); + Arts::Dispatcher::unlock(); + + printf("segundos hasta suspender = %d" segundos); + sleep(1); + } + } +} +</programlisting> + + +</sect2> + +<sect2 id="threads-classes"> +<title +>Clases relacionadas con hilos</title> + +<para +>Están disponibles las siguientes clases relacionadas con hilos: </para> + +<itemizedlist> +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Thread.html" +><classname +> Arts::Thread</classname +></ulink +> - que encapsula un hilo. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Mutex.html" +> <classname +>Arts::Mutex</classname +></ulink +> - que encapsula un mutex (exclusión mútua). </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__ThreadCondition.html" +> <classname +>Arts::ThreadCondition</classname +></ulink +> - que provee soporte para despertar hilos que están esperando a que alguna condición se haga verdadera. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__SystemThreads.html" +><classname +>Arts::SystemThreads</classname +></ulink +> - que encapsula la capa de hilos del sistema operativo (ofrece algunas funciones útiles para los programadores de aplicaciones). </para> +</listitem> +</itemizedlist> + +<para +>Consulte los enlaces para ver la documentación. </para> + +</sect2> +</sect1> + +<sect1 id="references-errors"> +<title +>Manejo de referencias y errores</title> + +<para +>Las referencias de &MCOP; son uno de los conceptos centrales de la programación de &MCOP;. Esta sección intentará describir como se usan exactamente las referencias, y especialmente intentará también cubrir casos de fallo (caídas del servidor). </para> + +<sect2 id="references-properties"> +<title +>Propiedades básicas de las referencias</title> + +<itemizedlist> +<listitem> +<para +>Una referencia &MCOP; no es un objeto, pero sí una referencia a un objeto. Entonces, aunque la siguiente declaración <programlisting> + Arts::Synth_PLAY p; +</programlisting +> parece la definición de un objeto, solamente declara la referencia a un objeto. Si es programador de C++, podría pensar también en Synth_PLAY, * un tipo de puntero a un objeto Synth_PLAY. También significaría que p puede ser lo mismo que un puntero NULL. </para> +</listitem> + +<listitem> +<para +>Puede crear una referencia NULL asignándola explícitamente: </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); +</programlisting> +</listitem> + +<listitem> +<para +>Hacer llamadas a una referencia NULL le permite hacer un volcado de memoria. </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); + string s = p.toString(); +</programlisting> +<para +>Hagamos un volcado de memoria. Comparar ésto con un puntero, es esencialmente lo mismo que <programlisting> + QWindow* w = 0; + w->show(); +</programlisting +> que cualquier programador de C++ podría evitar. </para> +</listitem> + +<listitem> +<para +>Los objetos sin inicializar intentan crearse cuando se utilizan la primera vez. </para> + +<programlisting +>Arts::Synth_PLAY p; + string s = p.toString(); +</programlisting> +<para +>Es algo diferente a deshacer una referencia a un puntero NULL. No le dijo al objeto lo que es, e intenta utilizarlo. La suposición aquí es que quiere crear una nueva instancia local de un objeto Arts::Synth_PLAY. Por supuesto, puede ser que quisiera obtener algo más (como crear el objeto en alguna parte, o utilizar un objeto remoto existente). Sin embargo, es una forma rápida de crear objetos. Este tipo de creación no funcionará una vez que haya realizado una asignación (como una referencia nula). </para> + +<para +>El equivalente código C++ sería <programlisting> + QWidget* w; + w->show(); +</programlisting +> que, obviamente, en C++ provocará fallos de segmentación. Aquí esto es diferente. Esta creación es especialmente delicada puesto que puede que no exista necesariamente una implementación para su interfaz. </para> + +<para +>Por ejemplo, considere algo abstracto como Arts::PlayObject. Existen algunos PlayObjets concretos como aquellos que reproducen mp3 o wav, pero <programlisting> + Arts::PlayObject po; + po.play(); +</programlisting +> ciertamente fallará. El problema es que, aunque se intente crear el objeto PlayObject cuando sea necesario, fallará debido a elementos similares a Arts:WavPlayObject. Por ello utilice este tipo de creación de objetos cuando esté seguro de que la implementación existe. </para> +</listitem> + +<listitem> +<para +>Las referencias pueden apuntar al mismo objeto </para> + +<programlisting +>Arts::SimpleSoundServer s = Arts::Reference("global:Arts_SimpleSoundServer"); + Arts::SimpleSoundServer s2 = s; +</programlisting> + +<para +>crea dos referencias apuntando al mismo objeto. No copia ningún valor, y tampoco crea dos objetos. </para> +</listitem> + +<listitem> +<para +>Todos los objetos están referenciados, por eso, una vez que un objeto deje de estar referenciado, se borrará. No hay forma explícita de borrar un objeto, sin embargo, puede utilizar algo similar a esto <programlisting> + Arts::Synth_PLAY p; + p.start(); + [...] + p = Arts::Synth_PLAY::null(); +</programlisting +> para hacer que el objeto Synth_PLAY se elimine al final. No debería ser necesario utilizar new y delete junto con las referencias. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="references-failure"> +<title +>El caso del fallo</title> + +<para +>Las referencias pueden apuntar a objetos remotos, y el servidor que contiene estos objetos puede caer. ¿Qué sucede entonces? </para> + +<itemizedlist> + +<listitem> +<para +>Un cuelgue no cambia cuando una referencia es nula. Esto significa que si <function +>foo.isNull()</function +> vale <returnvalue +>verdadero</returnvalue +> antes de que el servidor se caiga entonces también valdrá <returnvalue +>verdadero</returnvalue +> después de la caída (que está limpio). Esto también significa que si <function +>foo.isNull()</function +> vale <returnvalue +>falso</returnvalue +> antes de la caída del servidor (foo está referenciado a un objeto) entonces valdrá <returnvalue +>falso</returnvalue +> después de que el servidor se haya caído. </para> +</listitem> + +<listitem> +<para +>La llamada de métodos en una referencia válida para que sea segura supone que el servidor contiene el objeto 'calculadora' caído. Aún haciendo llamadas válidas del estilo: <programlisting> + int k = calculadora.restar(i,j) +</programlisting +> Obviamente 'restar' tiene que devolver algo, pero no podrá ya que el objeto remoto ya no existe. En este caso (k == 0) sería verdadero. Generalmente, las operaciones intentan devolver algo «neutral» como resultado, como 0,0, una referencia nula para objetos o una cadena vacía, cuando el objeto ya no exista. </para> +</listitem> + +<listitem> +<para +>La comprobación <function +>error()</function +> averigua si todo funcionó correctamente. </para> + +<para +>En el caso anterior, <programlisting> + int k = calculadora.restar(i,j) + if(k.error()) { + printf("k no es i-j!\n"); + } +</programlisting +> imprimiría <computeroutput +>k no es i-j</computeroutput +> si la llamada remota no funcionase. En otro caso <varname +>k</varname +> tomaría el valor real de la operación 'restar' devuelta por el objeto remoto (si el servidor no se ha caído). Sin embargo, para métodos que hacen cosas como borrar un archivo, no estaría seguro de si lo habría hecho. Por supuesto, lo habría hecho si <function +>.error()</function +> vale <returnvalue +>falso</returnvalue +>. Sin embargo, si <function +>.error()</function +> vale <returnvalue +>verdadero</returnvalue +>, existen dos posibilidades: </para> + +<itemizedlist> +<listitem> +<para +>El archivo se borró y el servidor cayó justo despues de borrarse, pero antes de transmitir el resultado. </para> +</listitem> + +<listitem> +<para +>El servidor cayó antes de poder borrar el archivo. </para> +</listitem> +</itemizedlist> +</listitem> + +<listitem> +<para +>Utilizar llamadas jerarquizadas es peligroso en programas resistentes a las caídas. </para> + +<para +>Usar cosas como <programlisting> + window.titlebar().setTitle("foo"); +</programlisting +> no es una buena idea. Suponga que sabe que una ventana contiene una referencia válida a Window. Suponga que sabe que <function +>window.titlebar()</function +> devolverá una referencia a Titlebar porque el objeto Window está implementado apropiadamente. Sin embargo, la declaración anterior sigue sin ser segura. </para> + +<para +>Lo que podría suceder es que el servidor que contenga el objeto Window se caiga. Entonces, a pesar de que la implementación esté bien hecha, obtendrá una referencia null como resultado de la operación window.titlebar(). Y por supuesto, llamar a setTitle en esta referencia null también producirá un cuelgue. </para> + +<para +>Una variante segura de ésto sería <programlisting> + Titlebar titlebar = window.titlebar(); + if(!window.error()) + titlebar.setTitle("foo"); +</programlisting +> Añada la gestión de error adecuada. Si no confía en la implementación de la ventana, también podrían utilizar <programlisting> + Titlebar titlebar = window.titlebar(); + if(!titlebar.isNull()) + titlebar.setTitle("foo"); +</programlisting +> que será más seguro. </para> +</listitem> +</itemizedlist> + +<para +>Existen otras condiciones que puede provocar un fallo, como una desconexión de la red (suponga que quita el cable entre su servidor y cliente mientras su aplicación se ejecuta). Sin embargo, su efecto es el mismo que una caída del servidor. </para> + +<para +>De forma general, dependerá de la política de la aplicación la forma en que ésta capturará los errores. Puede seguir el método «si el servidor se cuelga, necesitaremos depurar el servidor hasta que no haya un nuevo cuelgue», lo que significa que no necesita preocuparse por estos problemas. </para> + +</sect2> + +<sect2 id="references-internals"> +<title +>Detalles internos: Contador de referencia distribuída</title> + +<para +>Cualquier objeto existente debe ser propiedad de alguien. Si esto no es así, dejará de existir (más o menos) inmediatamente. Internamente, la propiedad se indica llamando a la función <function +>_copy()</function +>, que incrementa un contador de referencia, y se decrementa llamando a la función <function +>_release()</function +>. Tan pronto como el contador de referencia llega a cero, se producirá el borrado. </para> + +<para +>Como una variación de este tema, el uso remoto se indica por <function +>_useRemote()</function +>, y se elimina con <function +>_releaseRemote()</function +>. Estas funciones gestionan una lista que el servidor llama (y se hace propietario del objeto). Ésto se utiliza en el caso de que el servidor se desconecte (&ie;, cuelgue, fallo de red), para eliminar las referencias que todavía queden de los objetos. Esto se hace a través de <function +>_disconnectRemote()</function +>. </para> + +<para +>Ahora existe un problema. Considere un valor devuelto. Normalmente, el valor del objeto devuelto dejará de pertenecer a la función llamada. Sin embargo, no pertenecerá al que llama, hasta que no se reciba el objeto propietario del mensaje. Por tanto, existe un tiempo para los objetos «sin dueño». </para> + +<para +>Ahora, cuando se envía un objeto, se estará seguro de que tan pronto como se reciba, tendrá dueño, a menos que el receptor muera. Sin embargo, esto significa que se deben tomar medidas especiales con los objetos, al menos mientras se envían, y probablemente mientras se reciben, de modo que no mueran inmediatamente. </para> + +<para +>La forma en que &MCOP; hace esto es «etiquetando» los objetos que están en proceso de ser copiados a través de la conexión. Antes de iniciar una copia, se llama la función <function +>_copyRemote</function +>. Esto evita que el objeto se libere durante un tiempo (5 segundos). Una vez que el receptor llame a <function +>_useRemote()</function +>, se elimina la etiqueta. Por ello, todos los objetos que se envían a través de la conexión se etiquetan antes de transferirlos. </para> + +<para +>Si el receptor recibe un objeto que esté en el servidor, no podrá utilizar <function +>_useRemote()</function +> sobre él. Para este caso especial, existe <function +>_cancelCopyRemote()</function +> para eliminar la etiqueta manualmente. Además de éste, también existe un contador para eliminar la etiqueta, si es que se hizo el etiquetado y el receptor nunca recogió el objeto (debido a un cuelgue, fallo de red). Ésto lo hace la clase <classname +>ReferenceClean</classname +>. </para> + +</sect2> + +</sect1> + +<sect1 id="detail-gui-elements"> +<title +>Elementos de &GUI;</title> + +<para +>Los elementos de &GUI; están actualmente en estado experimental. Sin embargo, esta sección describirá lo que se supone que sucederá, por lo que si usted es un desarrollador, será capaz de entender como &arts; trabajará con &GUI;s en el futuro. Actualmente también existe escrito algo de código. </para> + +<para +>Los elementos de &GUI; deben usarse para permitir a las estructuras de síntesis interactuar con el usuario. En el caso más simple, el usuario debería ser capaz de modificar algunos parámetros de una estructura directamente (por ejemplo, un factor de aumento utilizado antes del final del módulo de juego). </para> + +<para +>En configuraciones más complejas, se podrían imaginar modificaciones de parámetros de grupos de estructuras por parte de los usuarios y/o de estructuras que no estén todavía en funcionamiento, como la modificación de la envolvente del <acronym +>ADSR</acronym +> del instrumento &MIDI; actualmente activo. Otras podrían configurar el nombre del archivo de algunas muestras basadas en instrumentos. </para +> + +<para +>Por otra parte, el usuario podría querer observar qué es lo que hace el sintetizador. Podría utilizar osciloscopios, analizadores de espectro, medidores de volumen y «experimentaciones» que explican la frecuencia de la curva de transferencia de alguno de los módulos de filtrado. </para> + +<para +>Finalmente, los elementos del &GUI; deben poder controlar la estructura completa que se está ejecutando en &arts;. El usuario debería ser capaz de asignar instrumentos a los canales midi, iniciar nuevos efectos de proceso, configurar su mesa de mezclas principal (que está construída con la propia estructura de &arts;) para tener un canal más y utilizar otra estrategia para sus ecualizadores. </para> + +<para +>Como puede ver, los elementos del <acronym +>GUI</acronym +> deberían incorporar todas las posibilidades de un estudio &arts; virtual simulado para el usuario. Por supuesto, debería poder interactuar de forma sencilla con las entradas midi (como, por ejemplo, deslizadores que se mueven si hay entradas &MIDI; que pueden cambiar este parámetro), y probablemente incluso generar efectos, para permitir al usuario interactuar para grabar utilizando un secuenciador. </para> + +<para +>Técnicamente, la idea es tener una clase base &IDL; para todos los componentes (<classname +>Arts::Widget</classname +>), y derivar una serie de componentes usados habitualmente a partir de él (como <classname +>Arts::Poti</classname +>, <classname +>Arts::Panel</classname +>, <classname +>Arts::Window</classname +>, ...). </para> + +<para +>Entonces, será posible implementar estos componentes utilizando un conjunto de herramientas, por ejemplo, &Qt; o Gtk. Finalmente, los efectos deberían construir sus &GUI;s a partir de los componentes existentes. Por ejemplo, un efecto freeverb podría construir su &GUI; utilizando cinco elementos <classname +>Arts::Poti</classname +> y un <classname +>Arts::Window</classname +>. Por tanto, Si existe una implementación &Qt; para estos componentes base, el efecto será capaz de mostrarse utilizando &Qt;. Si la implementación es en Gtk, también funcionará en Gtk (y más o menos funcionarán de la misma forma y tendrán un aspecto similar). </para> + +<para +>Finalmente, como estamos utilizando aquí &IDL;, &arts-builder; (u otras herramientas) será capaz de conectarse a los &GUI;s, o de autogenerar &GUI;s proporcionando pistas sobre los parámetros, y sólo está basado en interfaces. Debería ser relativamente sencillo escribir un clase «crear &GUI; a partir de la descripción», que proporciona la descripción de un &GUI; (conteniendo varios parámetros y componentes), y crear un objeto &GUI; a partir de él. </para> + +<para +>Basándose en &IDL; y en el modelo de componentes &arts;/&MCOP;, debería ser fácil extender los posibles objetos que pueden ser utilizados por el &GUI; tan solo añadiendo una implementación de extensiones para los nuevos filtros de &arts;. </para> + +</sect1> + +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/digitalaudio.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/digitalaudio.docbook new file mode 100644 index 00000000000..6f70881d8ec --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Introducción al audio digital</title> + +<para +>Muestreos digitales, filtros, efectos, &etc;.</para> + +</appendix> + + + diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/faq.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/faq.docbook new file mode 100644 index 00000000000..8dafbb58aa6 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/faq.docbook @@ -0,0 +1,1302 @@ +<!-- <?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 +>Preguntas y respuestas</title> + +<para +>Este sección responde a algunas de las preguntas más habituales sobre &arts;. </para> + +<qandaset id="faq-general"> +<title +>Preguntas generales</title> + +<qandaentry> +<question> +<para +>¿Soporta &kde; mi tarjeta de sonido para reproducción de audio? </para> +</question> + +<answer> +<para +>&kde; utiliza &arts; para reproducir sonido, y &arts; utiliza los controladores de sonido del núcleo de &Linux;, ya sean <acronym +>OSS</acronym +> o <acronym +>ALSA</acronym +> (utilizando la emulación de <acronym +>OSS</acronym +>). Si su tarjeta de sonido está soportada por <acronym +>ALSA</acronym +> o por <acronym +>OSS</acronym +> y correctamente configurada (&ie;, cualquier otra apliación de Linux puede reproducir sonido), funcionará. Hay, sin embargo, algunos problemas con hardware específico, por favor, lea la <link linkend="faq-hardware-specific" +>sección sobre problemas con hardware específico</link +> si tiene problemas con artsd en su ordenador. </para> +<para +>Mientras tanto se ha añadido soporte para varias plataformas más. Ésta es una lista completa de cómo se puede reproducir sonido con la versión más reciente de &arts;. Si su plataforma no está soportada, por favor, considere realizar usted mismo las modificaciones oportunas para que funcione. </para> + +<informaltable> +<tgroup cols="2"> +<thead> +<row> +<entry +>Método de E/S de audio de &arts;</entry> +<entry +>Comentario</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>paud</entry> +<entry +>Soporte para el dispositivo de audio personal de AIX</entry> +</row> + +<row> +<entry +>alsa</entry> +<entry +>Controladores ALSA-0.5 y ALSA-0.9 de Linux</entry> +</row> + +<row> +<entry +>libaudioio</entry> +<entry +>Soporte para la biblioteca genérica LibAudioIO que funciona en Solaris</entry> +</row> + +<row> +<entry +>nas</entry> +<entry +>Servidor de sonido NAS, útil para los terminales X con soporte para NAS</entry> +</row> + +<row> +<entry +>null</entry> +<entry +>Dispositivo de audio nulo, elimina todo el sonido silenciosamente</entry> +</row> + +<row> +<entry +>oss</entry> +<entry +>Soporte para OSS (sistema de sonido abierto), funciona en Linux, varios BSDs y otras plataformas con los controladores OSS instalados</entry> +</row> + +<row> +<entry +>toss</entry> +<entry +>Soporte para OSS multihilo, que funciona mejor en los casos donde el OSS estándar no lo hace correctamente</entry> +</row> + +<row> +<entry +>sgi</entry> +<entry +>Soporte directo multimedia de SGI para IRIX</entry> +</row> + +<row> +<entry +>sun</entry> +<entry +>Soporte para Solaris</entry> +</row> + +</tbody> +</tgroup> +</informaltable> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>No puedo reproducir archivos <literal role="extension" +>wav</literal +> con &artsd;. </para> +</question> + +<answer> +<para +>Compruebe que &artsd; está correctamente enlazado con <filename +>libaudiofile</filename +> (<userinput +><command +>ldd</command +> <parameter +>artsd</parameter +></userinput +>). Si no lo está, descargue el paquete tdesupport, recompílelo todo y funcionará. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Escucho sonidos cuando entro en el sistema como <systemitem class="username" +>root</systemitem +>, pero ningún otro usuario tiene sonido. </para> +</question> + +<answer> +<para +>Los permisos del archivo <filename class="devicefile" +>/dev/dsp</filename +> afectan a que los usuarios tengan o no sonido. Para que funcione correctamente, haga esto: </para> + +<procedure> +<step> +<para +>Acceda al sistema como <systemitem class="username" +>root</systemitem +>. </para> +</step> + +<step> +<para +>Abra una ventana de &konqueror;. </para> +</step> + +<step> +<para +>Vaya a la carpeta <filename class="directory" +>/dev</filename +>. </para> +</step> + +<step> +<para +>Pinche en el archivo <filename +>dsp</filename +> con el botón <mousebutton +>derecho</mousebutton +> del ratón, y abra las propiedades. </para> +</step> + +<step> +<para +>Pinche en el apartado <guilabel +>Permisos</guilabel +>. </para> +</step> + +<step> +<para +>Active las casillas <guilabel +>Leer</guilabel +> y <guilabel +>Escribir</guilabel +> en todas las secciones. </para> +</step> + +<step> +<para +>Pinche en <guibutton +>Aceptar</guibutton +>. </para> +</step> +</procedure> + +<para +>Puede conseguir los mismos resultados desde una ventana de terminal con la orden <userinput +><command +>chmod</command +> <option +>666</option +> <parameter +>/dev/dsp</parameter +></userinput +>. </para> + +<para +>Para restringir el sonido a algunos usuarios específicos, puede utilizar los permisos de grupo. En algunas distribuciones de &Linux; como Debian/Potato, <filename class="devicefile" +>/dev/dsp</filename +> ya aparece en propiedad de un grupo llamado <systemitem class="groupname" +>audio</systemitem +>, así que lo único que tiene que hacer es añadir los usuarios a ese grupo. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Esto vale para &artsd; pero, ¿qué hay de &kmix;, &kmid;, &kscd;, &etc;? </para> +</question> +<answer> + +<para +>Hay otros dispositivos que proporcionan la funcionalidad a la que acceden las aplicaciones multimedia. Puede tratarlos de la misma manera, bien haciéndolos accesibles para todo el mundo, o utilizando grupos para controlar el acceso. Esta es una lista, que puede estar incompleta (en caso de que haya varios dispositivos en la forma <filename class="devicefile" +>midi0</filename +>, <filename class="devicefile" +>midi1</filename +>, ..., aquí sólo se mostrará la versión 0): </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 +>¿Qué puedo hacer si artsd no se inicia o si se cuelga durante el funcionamiento?</para> +</question> + +<answer> +<para +>En primer lugar: trate de utilizar los parámetros predeterminados en &kcontrol; (o si lo ha iniciado manualmente, no incluya argumentos adicionales salvo quizá <userinput +><option +>-F</option +><parameter +>10</parameter +> <option +>-S</option +><parameter +>4096</parameter +></userinput +> para latencia). En contreto es <emphasis +>bastante probable que falle el full duplex</emphasis +> (transmisión bidireccional) con varios controladores, así que pruebe a desactivarlo. </para> + +<para +>Una buena forma de investigar por qué no se inicia &artsd; (o se cuelga durante el funcionamiento) es cargarlo manualmente. Abra una ventana de &konsole; y teclee: </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 +>También puede incluir la opción <option +>-l0</option +>, que mostrará más información sobre lo que está ocurriendo, como aquí: </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 +>Al hacer esto, lo más probable es que obtenga suficiente información sobre los motivos de los fallos. O, si se cuelga al hacer una cosa concreta, puede hacerla en este momento para observar «cómo» falla. Si desea informar de un fallo, el generar un trazado inverso con <command +>gdb</command +> y/o <command +>strace</command +> puede ayudar a localizar el problema. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Se pueden mover los archivos compilados de &artsd; a otra carpeta?</para> +</question> + +<answer> +<para +>No se podrá mover &artsd; sin problemas directamente. El único inconveniente es que &artswrapper; guarda la localización de &artsd; compilada por motivos de seguridad. Usted puede, sin embargo, utilizar el archivo <filename +>.mcoprc</filename +> (entradas TraderPath/ExtensionPath) para indicar a &artsd; dónde puede localizar sus componentes. Vea el <link linkend="the-mcoprc-file" +>capítulo sobre el archivo <filename +>.mcoprc</filename +></link +> para obtener más detalles sobre esto. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Puedo compilar &arts; con gcc-3.0?</para> +</question> + +<answer> +<para +>Respuesta rápida: no, &arts; no funcionará si lo compila con gcc-3.0. </para> + +<para +>Respuesta más larga: en su publicación oficial, hay dos fallos en gcc-3.0 que afectan a &arts;. El primero, fallo gcc-3.0 c++/2733 es relativamente inofensivo (y está relacionado con problemas con las declaraciones del ensamblador). Impide la compilación de convert.cc. Ya ha sido corregido en el CVS de gcc-3.0, y no será un problema en gcc-3.0.1 y superiores. Además hay una solución en la versión CVS de KDE/aRts. </para> +<para +>El segundo fallo de gcc-3.0, el c++/3145 (que trata sobre la generación de código erróneo en algunos casos de herencia virtual múltiple), es crítico. Las aplicaciones como &artsd; simplemente no funcionarán si están compiladas con gcc-3.0. Aunque se está haciendo algún progreso al respecto en la rama de gcc-3.0 en el momento de escribir esto, &artsd; sigue fallando habitualmente y de forma impredecible. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>¿Qué aplicaciones funcionan bajo &arts;?</para> +</question> +<answer> + +<para +>Obviamente, todas las aplicaciones incluídas en &kde; funcionan con &arts;. Ésto incluye: </para> + +<itemizedlist> +<listitem +><para +>&noatun;.</para +></listitem> +<listitem +><para +>&arts-builder;.</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 +>Juegos de &kde; como &kpoker; y &ktuberling;.</para +></listitem> +</itemizedlist> + +<para +>Algunas aplicaciones &kde; que aún no se incluyen en las publicaciones de &kde; (⪚, en kdenonbeta) también soportan &arts;, incluyendo: </para> + +<itemizedlist> +<listitem +><para +>&brahms;.</para +></listitem> +<listitem +><para +><application +>Kaboodle.</application +></para +></listitem> +<listitem +><para +><application +>Kdao.</application +></para +></listitem> +</itemizedlist> + +<para +>La siguientes aplicaciones que no son de &kde; también soportan &arts;: </para> + +<itemizedlist> +<listitem +><para +><application +>xmms</application +> (con el conector &arts;).</para +></listitem> +<listitem +><para +>Real Networks <application +>RealPlayer</application +> 8.0 (funciona con &artsdsp;. Se está considerando el soporte nativo de &arts;).</para +></listitem> +</itemizedlist> + +<para +>La siguientes aplicaciones <emphasis +>no</emphasis +> funcionan con &arts;: </para> + +<itemizedlist> +<listitem +><para +>none</para +></listitem> +</itemizedlist> + +<para +>Vea también las respuestas a las preguntas en la sección sobre <link linkend="faq-non-arts" +>aplicaciones que no son de &arts;</link +>. </para> + +<para +>Esta sección está incompleta, si tiene más información sobre aplicaciones soportadas o no soportadas, por favor, póngase en contacto con el autor para poder incluir aquí esos datos. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-non-arts"> +<title +>Aplicaciones que no son de &arts;</title> + +<qandaentry> +<question> +<para +>Una vez que &kde; está funcionando, ninguna otra aplicación puede acceder al dispositivo de sonido. </para> +</question> +<answer> +<para +>Ya que el servidor de sonido &arts;, utilizado por &kde;, está ocupando el dispositivo de sonido. Si el servidor está inactivo durante más de 60 segundos, se auto suspende y libera el dispositivo automáticamente. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Se supone que la suspensión es en 60 segundos, pero no en mi caso. </para> +</question> +<answer> +<para +>Si inicia artsd desde el panel de control de KDE, el tiempo de suspensión predeterminado es de 60 segundos. Si inicia artsd desde la línea de órdenes necesitará utilizar la opción -s para especificar el tiempo para la suspensión. De otro modo, el comportamiento predeterminado es desactivar la característica de suspensión. </para> +<para +>En este momento no hay suspensión si está en uso el full duplex. Apague el full duplex desde &kcontrol; para que funcione la suspensión. Desactivar el full duplex es una buena idea si &arts; se utiliza para la reproducción y no para la grabación de audio. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Cómo puedo ejecutar aplicaciones antíguas o que no soporten &arts;? </para> +</question> + +<answer> +<para +>Ejecútelas utilizando &artsdsp;. Por ejemplo, si normalmente ejecutaría: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>mpg123</command +> <option +>cosa.mp3</option +></userinput +></screen> + +<para +>utilice ahora:</para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>mpg123 cosa.mp3</option +></userinput +></screen> + +<para +>Esto reenviará la salida de sonido a &arts;. Este método no requiere realizar cambios en las aplicaciones. Es, sin embargo, una solución un poco engorrosa y que, además, no admite todas las características de las tarjetas de sonido, así que algunas aplicaciones podrían no funcionar. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>No puedo ejecutar &artsdsp; con ninguna aplicación, siempre falla. </para> +</question> +<answer> +<para +>Necesita una versión reciente de la biblioteca glibc. &artsdsp; no funcionará de forma fiable en distribuciones antiguas de &Linux;. Por ejemplo, en Debian 2.1 (basada en glibc 2.0) no funciona, mientras que en Debian 2.2 (basada en glibc 2.1.3), lo hace correctamente. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Hay algún tipo de límite teórico en las aplicaciones que evitaría el funcionamiento con &artsdsp;? </para> +</question> +<answer> +<para +>No. El uso de &artsdsp; puede resultar más lento y cargar más procesador que utilizar las <acronym +>API</acronym +>s de &arts; directamente. A parte de eso, cualquier aplicación que no funcione se deberá considerar como un fallo en &artsdsp;. La técnica utilizada por &artsdsp; debería, si está implementada correctamente, permitir que <emphasis +>cualquier</emphasis +> aplicación funcione (incluyendo aplicaciones grandes como <application +>Quake</application +> 3). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Qué puedo hacer si una aplicación no funciona con &artsdsp;? </para> +</question> +<answer> +<para +>Puede esperar a que &artsd; entre en suspensión o utilizar la orden <userinput +><command +>artsshell</command +> <option +>suspend</option +></userinput +> para hacer que el servidor entre forzosamente en suspensión. Sólo podrá suspender el servidor si no hay ninguna aplicación utilizando &arts; en ese momento, y no se permitirá el funcionamiento de ninguna aplicación que utilice &arts; durante el tiempo que dure la suspensión. </para> + +<para +>Si el servidor está ocupado, este es un método un poco bruto, pero efectivo, de solucionarlo: </para> + + +<screen +><prompt +>%</prompt +> <userinput +><command +>killall</command +> <option +>artsd</option +> ; <command +>killall</command +> <option +>artswrapper</option +></userinput> +<lineannotation +>Ahora inicie la aplicación.</lineannotation> +<prompt +>%</prompt +> <userinput +><command +>kcminit</command +> <option +>arts</option +></userinput +> +</screen> + +<para +>Ésto puede provocar que las aplicaciones que utilicen &arts; en ese momento fallen, al haberse cerrado el servidor. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>¿Qué ocurre con las aplicaciones escritas para &kde; 1.x? </para> +</question> +<answer> +<para +>Si está ejecutando aplicaciones de &kde; 1.x, cuya salida de sonido es a través del servidor de audio de &kde; 1, deberá ejecutar <application +>kaudioserver</application +> para que funcionen. Puede iniciar <application +>kaudioserver</application +> de la misma forma que otras aplicaciones que no son de &arts;: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>kaudioserver</option +></userinput +> +</screen> + +<para +>Deberá tener instalado kaudioserver (del mismo sitio del que haya obtenido las aplicaciones de &kde; 1.x), pertenece a &kde; 1.x y no a &kde; 2. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Qué ocurre con las aplicaciones que utilizan el servidor de sonido mejorado, <acronym +>ESD</acronym +>? </para> +</question> +<answer> +<para +>El problema es similar al de <application +>kaudioserver</application +>. Esas aplicaciones necesitan un servidor esd funcionando. Puede iniciar <command +>esd</command +> a través de &artsdsp;, y todas las aplicaciones <acronym +>ESD</acronym +> funcionarán correctamente, de esta manera: </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>esd</option +></userinput +> +</screen> +<para +>Las nuevas versiones de aRts ( +>= 1.2.0) también pueden utilizar el demonio de sonido mejorado en lugar de acceder directamente a la tarjeta de sonido. En la línea de órdenes, puede utilizar la opción -a, de la siguiente forma: </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-a esd</option +></userinput +> +</screen> +<para +>para conseguir soporte de EsounD, en KDE podrá utilizar kcontrol para configurar artsd y utilizar esd a través de Sonidos y multimedia -> Sistema de sonido -> E/S sonido. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-latency"> +<title +>Latencia</title> + +<qandaentry> +<question> +<para +>En ocasiones oigo pequeñas pausas al escuchar música, ¿se trata de un fallo? </para> +</question> +<answer> +<para +>Lo más probable es que no, sino que esté causado por el hecho de que el núcleo de &Linux; no se lleva muy bien con el procesamiento a tiempo real. Hay situaciones en las que &arts; no es capaz de mantener el flujo de reproducción. Usted puede, sin embargo, activar derechos de tiempo real (a través de &kcontrol;), y utilizar un tiempo de latencia grande (como <guilabel +>250ms</guilabel +> o <guilabel +>tan grande como sea posible</guilabel +>), lo que debería mejorar la situación. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Qué efecto tiene el parámetro del tiempo de respuesta? </para> +</question> +<answer> +<para +>El texto de ayuda de este parámetro en &kcontrol; puede despistas. Un valor más bajo significa que &arts; tardará menos tiempo en responder a los eventos externos (&ie;, el tiempo que pasa desde que se selecciona una ventana hasta que se oye un sonido reproducido por &artsd;). Además utiliza más recursos de <acronym +>CPU</acronym +>, y lo más probable es que produzca más ruidos.</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Se puede hacer algo para evitar las pausas? </para> +</question> +<answer> +<para +>Los usuarios de los discos duros <acronym +>IDE</acronym +> puede utilizar la orden <command +>hdparm</command +> para poner sus discos en modo <acronym +>DMA</acronym +>. Una advertencia: esto no funciona con todo el hardware, y puede dar como resultado el tener que reiniciar el sistema o, en algún caso poco habitual, en pérdida de datos. Lea la documentación sobre la orden <command +>hdparm</command +> para obtener más detalles. Yo lo he utilizado con éxito: </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 +>Debe hacer esto después de cada inicio del sistema, así que lo mejor es que lo incluya en algún script al inicio del sistema (esto depende de las distribuciones, en Debian &Linux; lo normal es añadirlo a <filename +>/etc/rc.boot</filename +>). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿La prioridad de tiempo real no parece tener ningún efecto? </para> +</question> +<answer> +<para +>Verifique que artswrapper está instalado con permisos suid de <systemitem class="username" +>root</systemitem +>, como se supone que debería estarlo. Muchas distribuciones (SuSE7.x, por ejemplo) no hacen esto. Puede verificarlo utilizando: ls -l $(which artswrapper). Correcto: <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 +> Incorrecto: <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 +> Si no tiene la s, puede ponerla utilizando: <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 +>Si hace &artswrapper; SUID <systemitem class="username" +>root</systemitem +>, probablemente mejorará la calidad de su sistema de audio reduciendo las distorsión en la música. Sin embargo, se incrementará el riesgo de que un fallo en el código o un usuario malicioso pueda colgar o dañar su máquina. Adicionalmente, en las máquinas multi-usuario, priorizar la alta calidad de audio puede deteriorar el rendimiento para los usuarios que intenten hacer un uso «productivo» de la máquina.</para> + +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>¿Por qué &artsd; consume tanto tiempo de <acronym +>CPU</acronym +>? </para> +</question> +<answer> +<para +>Compruebe sus parámetros de tiempo de respuesta. Sin embargo, la versión actual no está muy optimizada. Esto mejorará, y hasta ese momento no se puede hacer una predicción real de lo rápido o lento que puede ser &artsd;. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-network"> +<title +>Transparencia de red</title> + +<qandaentry> +<question> +<para +>¿Qué necesito para la transparencia de red? </para> +</question> +<answer> +<para +>Actívela en los parámetros del <guilabel +>Servidor de sonido</guilabel +> de &kcontrol; (<guilabel +>activar el servidor X11 para información de seguridad</guilabel +> y <guilabel +>transparencia de red</guilabel +>). Después copie su archivo <filename +>.mcoprc</filename +> a todas las máquinas en las que piense utilizar la transparencia de red. Vuelva a acceder al sistema. Asegúrese de que los ordenadores que está interaccionando conocen los nombres de los otros (&ie;, los nombres que resolverá o que se encuentren en el archivo <filename +>/etc/hosts</filename +>). </para> + +<para +>Esto debería ser todo. Sin embargo, si aún no funciona, aquí tiene algún detalle adicional. El proceso del servidor de sonido &arts;, &artsd;, sólo debe ejecutarse en uno de los sistemas, el que tenga la tarjeta de sonido que reproducirá el audio. Se puede iniciar automáticamente al acceder a &kde; (si está configurado en &kcontrol;), o de forma manual utilizando algo como: </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 +>El parámetro <option +>-n</option +> es para la transparencia de red, mientras que los otros tienen que ver con la lantencia. </para> + +<para +>El archivo <filename +>.mcoprc</filename +> debe contener esta entrada: </para> + +<screen +><userinput +>GlobalComm=Arts::X11GlobalComm</userinput +> +</screen> + +<para +>en todas las máquinas involucradas, para hacer que funcione la transparencia de red. Esto es lo que se activa con el parámetro del panel de control <guilabel +>del servidor X11 para información de seguridad</guilabel +>. </para> + +<para +>Por último, en todas la versiones de &kde; de la serie 2.0.x, hay un error que influye si no está configurado el nombre del dominio. Los clientes de &artsd; tratan de buscar dónde conectarse a través de la combinación <systemitem class="systemname" +><replaceable +>nombresistema</replaceable +>.<replaceable +>nombredominio</replaceable +></systemitem +>. Si el nombre del dominio está vacío, tratará de conectarse a <systemitem class="systemname" +><replaceable +>nombresistema</replaceable +></systemitem +>. (tenga en cuenta el punto adicional). Si se añade una entrada como ésta al archivo <filename +>/etc/hosts</filename +> (&ie;, <userinput +>orion.</userinput +> si el nombre de su sistema es <systemitem class="systemname" +>orion</systemitem +>), soluciona el problema. </para> +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>¿Cómo puedo analizar la transparencia de red si no funciona? </para> +</question> +<answer> +<para +>Asumiendo que usted tiene acceso al código fuente de &kde;, vaya a <filename class="directory" +>tdelibs/arts/examples</filename +>, y ejecute <userinput +><command +>make</command +> <option +>check</option +></userinput +> para compilar algunos programas, incluyendo <application +>referenceinfo</application +>. A continuación ejecute </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>./referenceinfo</command +> <option +>global:Arts_SimpleSoundServer</option +></userinput +> +</screen> + +<para +>La salida indicará el nombre del sistema y el puerto que están siendo utilizados por &arts;. Por ejemplo, <computeroutput +>tcp:orion:1698</computeroutput +> significa que cualquier cliente que intente utilizar la transparencia de red debería ser capaz de acceder al sistema <systemitem class="systemname" +>orion</systemitem +>. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-hardware-specific"> +<title +>Preguntas específicas de hardware</title> + +<qandaentry> +<question> +<para +>¿Con qué hardware no funciona artsd correctamente? </para> +</question> +<answer> +<para +>Parece ser que existen unos pocos controladores linux que no funcionan bien con aRts en algunas versiones del núcleo. Por favor, lea esta lista antes de informar de un fallo. Si encuentra que parte de la información de esta lista esta incompleta, por favor, no dude en comunicarlo. <informaltable +> <tgroup cols="4"> +<thead> +<row> +<entry +>Controlador / tarjeta de sonido linux</entry> +<entry +>Falla bajo</entry> +<entry +>Funciona bajo</entry> +<entry +>Observaciones</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>controlador i810 (Intel 810 + audio AC97)</entry> +<entry +>2.4.9</entry> +<entry +>2.4.18, 2.2.20, controlador oss comercial, alsa-0.5.12a con emulación OSS</entry> +<entry +>el controlador provoca sobrecarga de la cpu (ver debajo)</entry> +</row> + +<row> +<entry +>chipset 3/4 maestro</entry> +<entry +>2.4.9</entry> +<entry +>?</entry> +<entry +>el controlador algunas veces provoca la sobrecarga de la cpu (ver debajo)</entry> +</row> + +<row> +<entry +>controladores aureal8820 y aureal8830 de sourceforge</entry> +<entry +>2.4.17</entry> +<entry +>?</entry> +<entry +>el controlador activa el disparador/provoca la sobrecarga de la cpu (ver debajo)</entry> +</row> + +<row> +<entry +>OSS Comercial 3.9.4g con Aureal Vortex</entry> +<entry +>?</entry> +<entry +>?</entry> +<entry +>bloqueo del sistema</entry> +</row> + +<row> +<entry +>ymfpci</entry> +<entry +>2.4.0, 2.4.12</entry> +<entry +>2.4.17</entry> +<entry +>el controlador activa el disparador (ver debajo)</entry> +</row> + + + +</tbody> +</tgroup> +</informaltable> +</para> +</answer> +</qandaentry> + + + +<qandaentry> +<question> +<para +>¿Por qué se producen los problemas específicos de hardware y cómo puedo detectarlos? </para> +</question> +<answer> +<para +>La causa más común es que el controlador no proporciona a aRts la suficiente información sobre cuándo se debe escribir información de sonido. La mayoría de los controladores OSS proporcionan la información correcta, pero no todos. </para> +<para +>Puede que advierta que hay otras aplicaciones (como xmms) que no necesitan esta información, y que, sin embargo, funcionan correctamente incluso con su hardware. A pesar de todo, &arts; necesita esa información, o artsd no funcionará correctamente. Esto es un fallo del controlador, y no de &arts;. </para> +<para +>Hay dos tipos de comportamientos que artsd muestra cuando se está ejecutando un controlador incorrecto. O bien trata de forma contínua de enviar nueva información, pero nunca lo consigue, lo que produce un consumo de toda la potencia de la CPU, informa de <emphasis +>sobrecarga en la cpu</emphasis +> y sale. El otro problema es que a artsd se le puede comunicar información incorrecta sobre la cantidad de datos a escribir. En este caso artsd <emphasis +>se detendrá mostrando una advertencia</emphasis +> de este aspecto: <screen +>artsd: audiosubsys.cc:458: void Arts::AudioSubSystem::handleIO(int): +Assertion `len == can_write' failed. +Aborted +</screen> +</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Qué tiene mal el controlador si se produce el problema de la sobrecarga de la cpu? </para> +</question> +<answer> +<para +>Normalmente, artsd utiliza select() para descubrir cuándo se deben escribir nuevos datos. Entonces, utiliza la función ioctl(...GETOSPACE) para descubrir cuánta información debe escribir. Por último, escribe esa información. </para> +<para +>Los problemas ocurren cuando se llama a artsd contínuamente o si hay para escribir cantidades de información mínimas. La documentación de OSS especifica que select() únicamente llama a un proceso si hay al menos un fragmento para escribir. Sin embargo, si se llama a artsd sin datos para escribir, o muy pocos, por ejemplo, una sola muestra, este se mantendrá escribiendo pequeños segmentos de datos de audio, lo que resulta muy costoso y puede, en determinados casos, sobrecargar la cpu. </para> +<para +>Para solucionar esto, el controlador debe llamar a artsd únicamente si hay para escribir un fragmento completo. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>¿Qué le ocurre al controlador si se produce la advertencia? </para> +</question> +<answer> +<para +>Normalmente, artsd utiliza select() para descubrir cuándo se deben escribir nuevos datos. Entonces, utiliza la función ioctl(...GETOSPACE) para descubrir cuánta información debe escribir. Por último, escribe esa información. </para> +<para +>Si artsd no puede escribir toda la información que indica la llamada a ioctl, producirá una advertencia. Para solucionarlo, el controlador debe proporcionar la información correcta sobre la cantidad de espacio libre. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-other"> +<title +>Otros problemas</title> + +<qandaentry> +<question> +<para +>No puedo utilizar &arts-builder;. ¡Falla al ejecutar un módulo! </para> +</question> +<answer> +<para +>La causa más probable es que está utilizando estructuras antiguas o módulos que no están soportados en la versión 2 de &kde;. Por desgracia, la documentación que se encuentra en la web hace referencia a &arts;-0.3.4.1, que ya está obsoleto. El error del que más se informa es: que ejecutar una estructura en &arts-builder; da como resultado el mensaje de error <errorname +>[artsd] Synth_PLAY: el subsistema de audio ya está en uso.</errorname +> </para> + +<para +>Utilizando el módulo Synth_AMAN_PLAY en lugar de Synth_PLAY, el problema desaparecerá. Consulte también el archivo de ayuda de &arts-builder; (pulse <keycap +>F1</keycap +> en &arts-builder;). </para> + +<para +>Las versiones más recientes de &arts-builder; (&kde; 2.1 beta 1 y posteriores) vienen con un conjunto de ejemplos que pueden ser utilizados. </para> +</answer> +</qandaentry> + +</qandaset> + +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/future.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/future.docbook new file mode 100644 index 00000000000..382c2d62024 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Trabajo futuro</title> + +<para +>Esta sección describe algunos de los trabajos que están en progreso dentro de &arts;. El desarrollo avanza rápidamente, así que esta información podría estar obsoleta. Debería comprobar la lista del archivo TODO y los archivos de <link linkend="mailing-lists" +>la lista de correo</link +> para ver qué nueva funcionalidad se está planeando. Considérese libre para involucrarse en el nuevo diseño e implementación. </para> + +<para +>Este documento es un borrador que intenta dar una idea sobre cómo se integrarán las nuevas tecnologías en &arts;. En concreto, se ocupa de lo siguiente: </para> + +<itemizedlist> +<listitem +><para +>Cómo funcionan los interfaces.</para +></listitem> +<listitem +><para +>Los códecs: La decodificación de transmisiones mp3 o wav de forma que puedan ser utilizados como datos.</para +></listitem> +<listitem +><para +>Vídeo.</para +></listitem> +<listitem +><para +>Hilos.</para +></listitem> +<listitem +><para +>Sincronización.</para +></listitem> +<listitem +><para +>Expansión/enmascaramiento dinámico.</para +></listitem> +<listitem +><para +>Composición dinámica.</para +></listitem> +<listitem +><para +>&GUI;</para +></listitem> +<listitem +><para +>&MIDI;</para +></listitem> +</itemizedlist> + +<para +>Este trabajo está en progreso. Sin embargo, debería ser la base si lo que usted desea es encontrar nuevas tecnologías en &arts;. Además debería de dar una idea de cómo se van a afrontar esas cuestiones. Pero, por supuesto, corrija cualquier cosa que considere que se puede mejorar. </para> + +<para +>Elementos que utilizarán la tecnología de &arts; (así que, por favor, coordine sus esfuerzos): </para> + +<itemizedlist> +<listitem> +<para +><application +>KPhone</application +> (voz sobre <acronym +>IP</acronym +>). </para> +</listitem> + +<listitem> +<para +>&noatun; (reproductor de vídeo y audio). </para> +</listitem> + +<listitem> +<para +>&artscontrol; (programa de control del servidor de sonido). </para> +</listitem> + +<listitem> +<para +><application +>Brahms</application +> (secuenciador musical). </para> +</listitem> + +<listitem> +<para +><application +>Kaiman</application +> (reproductor de medios de &kde;2, compatible con kmedia2). </para> +</listitem> + +<listitem> +<para +><application +>mpglib</application +>/<application +>kmpg</application +> (tecnología de reproducción de audio y vídeo <acronym +>mpg</acronym +>). </para> +</listitem> + +<listitem> +<para +><application +>SDL</application +> (capa de medios directa para los juegos, aún no se ha comenzado a trabajar en ella pero será interesante). </para> +</listitem> + +<listitem> +<para +><application +>electric ears</application +> (el autor se puso en contacto conmigo. Estado desconocido). </para> +</listitem> +</itemizedlist> + +<sect1 id="interfaces-how"> +<title +>Cómo funcionan los interfaces</title> + +<!-- I think this is now obsolete and documented elsewhere ? --> + +<para +>Los interfaces &MCOP; están basados en el concepto de &arts;. Son transparentes a la red de forma equivalente a las clases de C++. Siempre que sea posible, debería orientar sus diseño hacia los interfaces. Éstos constan de cuatro partes: </para> + +<itemizedlist> +<listitem +><para +>Flujos síncronos.</para +></listitem> +<listitem +><para +>Flujos asíncronos.</para +></listitem> +<listitem +><para +>Métodos.</para +></listitem> +<listitem +><para +>Atributos.</para +></listitem> +</itemizedlist> + +<para +>Estos pueden mezclarse como usted prefiera. Las nuevas tecnologías deberían definirse en términos de interfaces. Lea las secciones sobre las transmisiones síncronas y asícronas, así como los interfaces KMedia2, ya que son buenos ejemplos sobre cómo funcionan las cosas. </para> + +<para +>Los interfaces se especifican en código <literal role="extension" +>.idl</literal +> y se ejecutan a través del compilador <command +>mcopidl</command +>. Se deriva la clase <classname +><replaceable +>Nombreinterfaz</replaceable +>_impl</classname +> para implementarlos, y se utiliza <function +>REGISTER_IMPLEMENTATION(Nombreinterfaz_impl)</function +> para insertar las implementaciones de los objetos en el sistema de objetos de &MCOP;. </para> + +</sect1> + +<sect1 id="codecs"> +<title +>Códecs - decodificación de datos</title> + +<para +>Los interfaces de kmedia2 permiten ignorar que los archivos wav, mp3 y otros se construyen a base de transmisiones de datos. En vez de eso, se implementan métodos para reproducirlos. </para> + +<para +>Por lo tanto, usted puede escribir una rutina de carga de ondas de forma que se puedan reproducir los archivos de ondas (como PlayObject), pero nadie más puede utilizar su código. </para> + +<para +>Las transmisiones asíncronas pueden ser una alternativa. Se define un interfaz que permite introducir y sacar bloques de datos. Se parece a la de &MCOP;: </para> + +<programlisting +>interface Codec { + entrada async byte stream indata; + salida async byte stream outdata; +}; +</programlisting> + + +<para +>Por supuesto los códecs también proporcionan atributos para emitir datos adicionales, como información sobre el formato. </para> + +<programlisting +>interface CodificadorAudioByte { + entrada async byte stream indata; + salida async byte stream outdata; + readonly attribute ratioMuestra, bits, canales; +}; +</programlisting> + +<para +>Este <interfacename +>CodificadorAudioByte</interfacename +>, por ejemplo, puede conectarse a un objeto <interfacename +>ByteStreamToAudio</interfacename +>, para hacer audio real en coma flotante. </para> + +<para +>Por supuesto, otros tipos de códecs podrían incorporar la emisión directa de información de vídeo, como </para> + +<programlisting +>interface VideoCodec { + entrada async byte stream indata; + salida video stream outdata; /* nota: las transmisiones de vídeo aún no existen */ +}; +</programlisting> + +<para +>En la mayoría de los casos, se debería emplear el concepto de un códec más que el método «tu sabes hacerlo funcionar y yo no» que ahora utiliza, por ejemplo, <interfacename +>WavPlayObject</interfacename +>. Sin embargo, alguien debería ponerse a experimentar un poco antes de que se pueda dar por finalizada la <acronym +>API</acronym +>. </para> + +</sect1> + +<sect1 id="video"> +<title +>Vídeo</title> + +<para +>Mi idea es proporcionar el vídeo como transmisiones asíncronas de algún tipo de datos nativo de &MCOP; que contenga imágenes. Este tipo de datos aún no está creado. Al hacerlo así, los conectores que tratan con las imágenes de vídeo pueden establecer enlaces de la misma manera que lo hacen los conectores de audio. </para> + +<para +>Estas son algunas de las cosas que no se deben olvidar: </para> + +<itemizedlist> +<listitem> +<para +>Hay espacios de color <acronym +>RGB</acronym +> y <acronym +>YUV</acronym +>. </para> +</listitem> +<listitem> +<para +>El formato debería estar de algún modo unido al flujo. </para> +</listitem> +<listitem> +<para +>La sincronización es importante. </para> +</listitem> +</itemizedlist> + +<para +>Mi idea es permitir la posibilidad de volver a implementar la clase <classname +>VideoFrame</classname +> (imagen de vídeo) de forma que pueda almacenar información en un segmento de memoria compartida. De esa manera, serían posibles incluso las transmisiones de vídeo entre distintos procesos sin mucha dificultad. </para> + +<para +>Sin embargo, la situación normal del vídeo es que las cosas estén en el mismo proceso, desde la decodificación hasta el dibujado. </para> + +<para +>He hecho un prototipo de una implementación de transmisiones de vídeo, que se puede descargar <ulink url="http://space.twc.de/~stefan/kde/download/video-quickdraw.tar.gz" +>aquí</ulink +>. Esto se deberá integrar en &MCOP; después de algunos experimentos. </para> + +<para +>Se debería proporcionar un componente del procesado que soporte XMITSHM (con <acronym +>RGB</acronym +> y <acronym +>YUV</acronym +>), Martin Vogt me ha dicho que está trabajando en algo de ese tipo. </para> + +</sect1> + +<sect1 id="threading"> +<title +>Hilos</title> + +<para +>En la actualidad, &MCOP; funciona en un solo hilo. Seguramente ésto no se podrá seguir manteniendo para el vídeo. De acuerdo. Estas son algunas de las cosas que hay que abordar con cuidado: </para> + + +<itemizedlist> +<listitem +><para +>SmartWrappers. No son seguros para multihilo debido al contador de referencias no seguro y otras cosas similares. </para> +</listitem> +<listitem> +<para +>Dispatcher / E/S. Tampoco es seguro. </para> +</listitem> +</itemizedlist> + +<para +>Sin embargo, lo que imagino es que habrá que hacer algunos módulos seguros en multihilo, tanto en transmisiones síncronas como asíncronas. De esa manera, con un sistema de flujo multihilo, se puede planificar la transmisión de señal sobre dos o más procesadores. Esto también ayudaría mucho al audio en los entornos multiprocesador. </para> + +<para +>Cómo funcionaría: </para> + + +<itemizedlist> +<listitem> +<para +>El sistema de transmisión decide qué módulos deberían calcular qué, así: </para> + <itemizedlist> + <listitem +><para +>Fotogramas de vídeo (con el método process_indata).</para +></listitem> + <listitem +><para +>Transmisiones de audio síncronas (calculateBlock).</para +></listitem> + <listitem +><para +>Otros transmisiones asíncronas, sobre todo transmisiones de bytes.</para +></listitem> + </itemizedlist> +</listitem> +<listitem> +<para +>Los módulos pueden calcular estas cosas en sus propios hilos. Para el audio, tiene sentido reutilizar los hilos (⪚, crear cuatro hilos para cuatro procesadores, independientemente de si están funcionando 100 módulos). Para el vídeo y la descompresión de bytes, puede ser más cómodo tener una implementación con bloqueos en un hilo propia, lo que se sincroniza con el resto de &MCOP; a través del sistema de transmisión. </para> +</listitem> + +<listitem> +<para +>Los módulos pueden no utilizar funcionalidad de &MCOP; (como las llamadas remotas) durante las operaciones multihilo. </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="synchronization"> +<title +>Sincronización</title> + +<para +>El vídeo y el &MIDI; (y el audio) requieren sincronización. Básicamente ésto viene determinado por unos códigos de tiempo. La idea que tengo es conectar los códigos de tiempo con transmisión asíncrona, añadiendo un código de tiempo en cada paquete. Si envía dos fotogramas de vídeo, hágalo en dos paquetes (serán grandes de todas formas), para que pueda tener dos códigos de tiempo diferentes. </para> + +<para +>El audio tienen códigos de tiempo implícitos, ya que es síncrono. </para> + +</sect1> + +<sect1 id="dynamic-composition"> +<title +>Composición dinámica</title> + +<para +>Debería ser posible decir: un efecto especial se componen de estos módulos más sencillos. Los efectos especiales deberían tener el aspecto de un módulo &MCOP; normal (véase el enmascaramiento), pero de hecho constar de otros módulos. </para> + +<para +>Esto es lo que hace falta en &arts-builder;. </para> + +</sect1> + +<sect1 id="gui"> +<title +>&GUI;</title> + +<para +>Todos los componentes del &GUI; serán módulos &MCOP;. Deberían de tener atributos como size (tamaño), label (etiqueta), color, etc. Un constructor <acronym +>RAD</acronym +> (&arts-builder;) debería ser capaz de componerlos visualmente. </para> + +<para +>El &GUI; debería ser almacenable, mediante el almacenamiento de los atributos. </para> + +</sect1> + +<sect1 id="midi-stuff"> +<title +>&MIDI;</title> + +<para +>El &MIDI; se implementará como transmisiones asíncronos. Hay dos opciones, una es utilizar las estructuras normales de &MCOP; para definir los tipos y la otra es introducir otros tipos propios. </para> + +<para +>Creo que las estructuras normales deberían bastar, algo como: </para> + +<programlisting +>struct EventoMidi { + byte b1,b2,b3; + sequence<byte> existe; +} +</programlisting> + +<para +>Las transmisiones asíncronas deberían soportar tipos de transmisión propios. </para> + +</sect1> + +</chapter> + + diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/glossary.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/glossary.docbook new file mode 100644 index 00000000000..5d87960ba9f --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Arquitectura de sonido avanzada para &Linux;. Un controlador de tarjetas de sonido para &Linux;. No está incluído en el código fuente del núcleo estándar. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-arts"> +<glossterm +>&arts;</glossterm> +<glossdef> +<para +>Sintetizador analógico de tiempo real. Es el nombre de la arquitectura/biblioteca/herramienta multimedia utilizada por el proyecto &kde; (téngase en cuenta el uso de las mayúsculas). </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-bsd"> +<glossterm +><acronym +>BSD</acronym +></glossterm> +<glossdef> +<para +>Distribución de software de Berkeley. Hace referencia a varios sistemas operativos compatibles con &UNIX; derivados del &UNIX; <acronym +>BSD</acronym +>. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-corba"> +<glossterm +><acronym +>CORBA</acronym +></glossterm> +<glossdef> +<para +>Arquitectura de comunicación de petición de objetos comunes. Un estándar para la implementación de ejecución remota orientada a objetos. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-cvs"> +<glossterm +><acronym +>CVS</acronym +></glossterm> +<glossdef> +<para +>Sistema de versiones concurrentes. Un sistema de administración de configuraciones utilizada por muchos proyectos, entre ellos &kde; y &arts;. </para> +</glossdef> +</glossentry> + +<glossentry id="glos-fft"> +<glossterm +><acronym +>FFT</acronym +></glossterm> +<glossdef> +<para +>Transformación rápida de Fourier. Un algoritmo para convertir datos de tiempo a frecuencias. Es muy utilizado en el procesamiento de señal. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-full-duplex"> +<glossterm +>Full Duplex</glossterm> +<glossdef> +<para +>La capacidad de una tarjeta de sonido para reproducir y grabar audio simultáneamente. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gpl"> +<glossterm +><acronym +>GPL</acronym +></glossterm> +<glossdef> +<para +>Licencia pública general de <acronym +>GNU</acronym +>. Una licencia de software creada por la Fundación del Software Libre que define los términos sobre la distribución del software libre. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gui"> +<glossterm +>&GUI;</glossterm> +<glossdef> +<para +>Interfaz gráfico de usuario. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-idl"> +<glossterm +><acronym +>IDL</acronym +></glossterm> +<glossdef> +<para +>Lenguaje de definición de interfaz. Un formato de programación independiente del lenguaje para especificar interfaces (métodos y datos). </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-kde"> +<glossterm +>&kde;</glossterm> +<glossdef> +<para +>Entorno de escritorio K. Un proyecto para desarrollar un entorno gráfico de escritorio libre para los sistemas compatibles con &UNIX;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-lgpl"> +<glossterm +><acronym +>LGPL</acronym +></glossterm> +<glossdef> +<para +>Licencia pública general <acronym +>GNU</acronym +> suavizada. Una licencia de software creada por la Fundación del Software Libre que define los términos sobre la publicación de software libre, menos restrictiva que la <acronym +>GPL</acronym +> y muy utilizada en las bibliotecas de software. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-mcop"> +<glossterm +>&MCOP;</glossterm> +<glossdef> +<para +>Protocolo de comunicación multimedia. El protocolo utilizado para la comunicación entre los módulos de software de &arts;. Similar a <acronym +>CORBA</acronym +> pero más sencillo y optimizado para el multimedia. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-midi"> +<glossterm +>&MIDI;</glossterm> +<glossdef> +<para +>Interfaz digital de instrumentos musicales. Un protocolo estándar para la comunicación entre instrumentos musicales electrónicos, también utilizado para referirse al formato de archivos para el almacenamiento de órdenes &MIDI;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-oss"> +<glossterm +><acronym +>OSS</acronym +></glossterm> +<glossdef> +<para +>Sistema de sonido abierto. Los controladores de sonido incluídos por el núcleo de &Linux; (a veces llamado <acronym +>OSS</acronym +>/Free) o una versión comercial vendida por 4Front Technologies. </para> +</glossdef> +</glossentry> + +</glossary> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/gui.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/gui.docbook new file mode 100644 index 00000000000..b769c161b6b --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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-es/docs/tdemultimedia/artsbuilder/helping.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/helping.docbook new file mode 100644 index 00000000000..b0f36792ea2 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Contribuciones a &arts;</title> + +<sect1 id="how-to-help"> +<title +>Cómo puede ayudar</title> + +<para +>El proyecto &arts; admite la ayuda de muchos desarrolladores para hacer que las aplicaciones multimedia existentes le soporten, para escribir nuevas aplicaciones multimedia, y para mejorar el propio &arts;. Sin embargo, no es necesario ser programador para colaborar. También se necesita ayuda de gente que haga pruebas de funcionamiento y envíe informes de fallos, traductores que adapten las aplicaciones y la documentación a otros idiomas, artistas que diseñen dibujos (especialmente para los módulos de <application +>artsbuilder</application +>), músicos que escriban módulos de ejemplo, y escritores que redacten la documentación. </para> +</sect1> + +<sect1 id="mailing-lists"> +<title +>Listas de correo</title> + +<para +>La mayoría de las discusiones sobre el desarrollo de &arts; tienen lugar en dos listas de correo. Es el lugar para tratar nuevas características e ideas de implementaciones o para pedir ayuda ante los problemas. </para> + +<para +>La lista de correo Multimedia de &kde; trata temas generales de multimedia en &kde; así como aplicaciones multimedia como &noatun; y &aktion;. Puede suscribirse desde la página web <ulink url="http://www.kde.org/mailinglists.html" +> http://www.kde.org/mailinglists.html</ulink +> o enviar un correo electrónico con el asunto <userinput +>subscribe <replaceable +>su-dirección-de-correo</replaceable +></userinput +> a <email +>[email protected]</email +>. La lista está guardada en <ulink url="http://lists.kde.org" +> http://lists.kde.org</ulink +>. </para> + +<para +>La lista de correo de &arts; trata temas específicos de &arts;, incluyendo el uso de &arts; externo a &kde;. Para suscribirse, envíe un correo electrónico que contenga en el cuerpo del mensaje <userinput +>subscribe <replaceable +>su-dirección-de-correo</replaceable +></userinput +> a <email +>[email protected]</email +>. La lista está guarda en <ulink url="http://space.twc.de/~stefan/arts-archive" +> http://space.twc.de/~stefan/arts-archive</ulink +>. </para> + +</sect1> + +<sect1 id="coding-standards"> +<title +>Estándares de programación</title> + +<para +>Para conseguir una lectura consistente de los códigos fuente, es importante mantener el mismo estilo de programación en todo el código de &arts;. Por favor, aunque escriba símplemente un módulo, trate de escribir y dar formato a su código fuente de acuerdo al estándar, así será más sencillo que otras personas mantegan esos archivos, y más fácil copiar porciones de un código a otro. </para> + +<variablelist> +<varlistentry> +<term +>Nombres de las funciones miembro</term> +<listitem> +<para +>Estilo &Qt;/&Java;. Eso significa utilizar mayúsculas en los cambios de palabra, la primera letra en minúsculas y sin caracteres de subrayado. </para> +<para +>Esto significa por ejemplo:</para> + +<programlisting +>crearDescripcionEstructura() + actualizarElemento(); + iniciar(); </programlisting> + +</listitem> +</varlistentry> + +<varlistentry> +<term +>Miembros de clases</term> +<listitem> +<para +>Los miembros de clases está en minúsculas, como 'barramenu' o 'boton'. </para> + +<para +>Cuando haya funciones de acceso, el estándar debe ser al estilo de &MCOP;, es decir, cuando haya un miembro largo <function +>foo</function +>, que no debe ser visible directamente, escriba funciones: </para> + +<programlisting +>foo(long nuevo_valor); + long foo(); </programlisting> + +<para +>para leer y establecer el valor. En ese caso, el valor real de <function +>foo</function +> debería quedar almacenado en <returnvalue +>_foo</returnvalue +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Nombres de clases</term> +<listitem> +<para +>Todas las clases deben comenzar con cada palabra en mayúsculas, como en <classname +>ModuloVer</classname +>, <classname +>ModuloSintesis</classname +>. Todas las clases que pertenezca a bibliotecas deben utilizar el espacio de nombres de &arts; como <classname +>Arts::Servidorsonido</classname +>. </para> +<para +>Las implementaciones de las clases &MCOP; deben ser llamadas <classname +>Clase_impl</classname +>, como <classname +>ServidorSonido_impl</classname +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Parámetros</term> +<listitem> +<para +>Los parámetros van siempre en minúsculas. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Variables locales</term> +<listitem> +<para +>La variables locales van siempre en minúsculas, y pueden tener nombres como <varname +>i</varname +>, <varname +>p</varname +>, <varname +>x</varname +>, &etc; según lo apropiado que sea. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Tabulación</term> +<listitem> +<para +>Un tabulador tiene una longitud de 4 espacios. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Espacios en expresiones</term> +<listitem> +<para +>Normalmente no es necesario utilizar espacios en expresiones. Puede, de todas formas, usarlos entre el operador y sus operandos. Sin embargo, si coloca un espacio antes de un operador (p.e. +), será necesario que coloque también uno después del mismo. La única excepción se produce en las expresiones de tipo de lista (con ,), donde sólo se debería poner un espacio después de la «,», pero nunca antes. Además, también es correcto omitir el espacio en este caso. </para> +<para +>Los siguientes ejemplos muestran el uso correcto de los espacios: </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 +>Los siguientes ejemplos muestras como <emphasis +>no</emphasis +> se deben utilizar los espacios. En las llamadas de función, después de if, while, for, swith y demás, no se debe escribir un espacio. </para> +<programlisting +>{ + // MAL: si escribe una lista, los espacios sólo deben ir después de la "," + int a , b , c , d , e , f; + + // MAL: no se han utilizado los espacios simétricamente con el operador = + a= 5; + + // MAL: if se considera una función y no debe ir seguida por un espacio + if (a == 5) { + } + + // MAL: nunca escriba espacios después de while + while (a--) + b++; + + // MAL: los nombres de funciones no deben ir seguidos por un espacio + arts_debug ("%d\n", c); + + // MAL: tampoco los nombres de los miembros + Arts::Object o = Arts::Object::null (); +} +</programlisting> +</listitem> +</varlistentry> + + +<varlistentry> +<term +>Nombres de los archivos fuente</term> +<listitem> +<para +>Los archivos fuente no deben tener mayúsculas en el nombre. Deben tener el nombre de la clase cuando implementen una sola clase. Su extensión es <literal role="extension" +>.cc</literal +> si se refieren a código independiente de &Qt;/&GUI;, y <literal role="extension" +>.cpp</literal +> si se refieren a código dependiente de &Qt;&GUI;. Los archivos de implementación para las interfaces deben llamarse <filename +><replaceable +>foo</replaceable +>_impl</filename +>, si Foo fuese el nombre del interfaz. </para> + +<para +>Los archivos &IDL; deben llamarse de una forma descriptiva de la colección de interfaces que contienen, también en minúsculas. No es bueno, concretamente, llamar al un archivo &IDL; como la propia clase, puesto que el intercambiador de mcopclass y las entradas de información de tipo colisionarán. </para> +</listitem> +</varlistentry> +</variablelist> +</sect1> + +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Makefile.am b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Makefile.am new file mode 100644 index 00000000000..78c8cc225b0 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = es +SUBDIRS = $(AUTODIRS) +KDE_DOCS = artsbuilder/images +KDE_MANS = AUTO diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Makefile.in b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Makefile.in new file mode 100644 index 00000000000..37a3f8c2889 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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/tdemultimedia/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@ +tdeinitdir = @tdeinitdir@ +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 = es +#>- 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/tdemultimedia/artsbuilder/images/Makefile'; \ +#>- cd $(top_srcdir) && \ +#>- $(AUTOMAKE) --gnu docs/tdemultimedia/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/tdemultimedia/artsbuilder/images/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdemultimedia/artsbuilder/images/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdemultimedia/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_RC.png Synth_SHELVE_CUTOFF.png Synth_MUL.png Synth_ENVELOPE_ADSR.png Synth_PLAY.png Synth_SEQUENCE_FREQ.png Synth_ADD.png Synth_CAPTURE.png Synth_NOISE.png Synth_PSCALE.png Synth_MOOG_VCF.png Synth_BUS_DOWNLINK.png Synth_STD_EQUALIZER.png Synth_PLAY_WAV.png Synth_SEQUENCE.png Synth_MULTI_ADD.png Synth_DEBUG.png Synth_DELAY.png Synth_WAVE_TRI.png Synth_PITCH_SHIFT.png Synth_FX_CFLANGER.png Synth_FREQUENCY.png Synth_DATA.png Synth_CDELAY.png Synth_NIL.png Synth_MIDI_TEST.png Synth_RECORD.png Synth_AMAN_RECORD.png Synth_FM_SOURCE.png Synth_XFADE.png Synth_BRICKWALL_LIMITER.png Synth_WAVE_PULSE.png Synth_COMPRESSOR.png Makefile.in Synth_BUS_UPLINK.png Synth_WAVE_SQUARE.png Synth_MIDI_DEBUG.png Synth_WAVE_SIN.png Synth_DIV.png 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_MUL.png Synth_DEBUG.png Synth_WAVE_TRI.png Synth_TREMOLO.png Synth_DIV.png Synth_FREQUENCY.png Synth_WAVE_SIN.png Synth_NIL.png Synth_STD_EQUALIZER.png Synth_BUS_DOWNLINK.png Synth_XFADE.png Synth_WAVE_PULSE.png Synth_BUS_UPLINK.png Synth_RC.png Synth_MIDI_TEST.png Synth_PLAY.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_CDELAY.png Synth_AMAN_PLAY.png Synth_COMPRESSOR.png Synth_PITCH_SHIFT.png Synth_WAVE_SQUARE.png Synth_SEQUENCE.png Synth_FM_SOURCE.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_ENVELOPE_ADSR.png Synth_MOOG_VCF.png Synth_NOISE.png Synth_ADD.png Synth_DELAY.png Synth_PLAY_WAV.png Synth_SEQUENCE_FREQ.png Synth_PSCALE.png Synth_SHELVE_CUTOFF.png Synth_MIDI_DEBUG.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_MUL.png Synth_DEBUG.png Synth_WAVE_TRI.png Synth_TREMOLO.png Synth_DIV.png Synth_FREQUENCY.png Synth_WAVE_SIN.png Synth_NIL.png Synth_STD_EQUALIZER.png Synth_BUS_DOWNLINK.png Synth_XFADE.png Synth_WAVE_PULSE.png Synth_BUS_UPLINK.png Synth_RC.png Synth_MIDI_TEST.png Synth_PLAY.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_CDELAY.png Synth_AMAN_PLAY.png Synth_COMPRESSOR.png Synth_PITCH_SHIFT.png Synth_WAVE_SQUARE.png Synth_SEQUENCE.png Synth_FM_SOURCE.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_ENVELOPE_ADSR.png Synth_MOOG_VCF.png Synth_NOISE.png Synth_ADD.png Synth_DELAY.png Synth_PLAY_WAV.png Synth_SEQUENCE_FREQ.png Synth_PSCALE.png Synth_SHELVE_CUTOFF.png Synth_MIDI_DEBUG.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_MUL.png Synth_DEBUG.png Synth_WAVE_TRI.png Synth_TREMOLO.png Synth_DIV.png Synth_FREQUENCY.png Synth_WAVE_SIN.png Synth_NIL.png Synth_STD_EQUALIZER.png Synth_BUS_DOWNLINK.png Synth_XFADE.png Synth_WAVE_PULSE.png Synth_BUS_UPLINK.png Synth_RC.png Synth_MIDI_TEST.png Synth_PLAY.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_CDELAY.png Synth_AMAN_PLAY.png Synth_COMPRESSOR.png Synth_PITCH_SHIFT.png Synth_WAVE_SQUARE.png Synth_SEQUENCE.png Synth_FM_SOURCE.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_ENVELOPE_ADSR.png Synth_MOOG_VCF.png Synth_NOISE.png Synth_ADD.png Synth_DELAY.png Synth_PLAY_WAV.png Synth_SEQUENCE_FREQ.png Synth_PSCALE.png Synth_SHELVE_CUTOFF.png Synth_MIDI_DEBUG.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_MUL.png Synth_DEBUG.png Synth_WAVE_TRI.png Synth_TREMOLO.png Synth_DIV.png Synth_FREQUENCY.png Synth_WAVE_SIN.png Synth_NIL.png Synth_STD_EQUALIZER.png Synth_BUS_DOWNLINK.png Synth_XFADE.png Synth_WAVE_PULSE.png Synth_BUS_UPLINK.png Synth_RC.png Synth_MIDI_TEST.png Synth_PLAY.png Synth_AMAN_RECORD.png Synth_MULTI_ADD.png Synth_FREEVERB.png Synth_CDELAY.png Synth_AMAN_PLAY.png Synth_COMPRESSOR.png Synth_PITCH_SHIFT.png Synth_WAVE_SQUARE.png Synth_SEQUENCE.png Synth_FM_SOURCE.png Synth_WAVE_SOFTSAW.png Synth_RECORD.png Synth_CAPTURE.png Synth_ENVELOPE_ADSR.png Synth_MOOG_VCF.png Synth_NOISE.png Synth_ADD.png Synth_DELAY.png Synth_PLAY_WAV.png Synth_SEQUENCE_FREQ.png Synth_PSCALE.png Synth_SHELVE_CUTOFF.png Synth_MIDI_DEBUG.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/tdemultimedia/artsbuilder/images/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu docs/tdemultimedia/artsbuilder/images/Makefile + cd $(top_srcdir) && perl ../scripts/admin/am_edit -p../scripts/admin docs/tdemultimedia/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-es/docs/tdemultimedia/artsbuilder/images/Synth_ADD.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_ADD.png Binary files differnew file mode 100644 index 00000000000..e06e47a0521 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_ADD.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png Binary files differnew file mode 100644 index 00000000000..908f6c0563d --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_PLAY.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png Binary files differnew file mode 100644 index 00000000000..ee9e799b2c8 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_AMAN_RECORD.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png Binary files differnew file mode 100644 index 00000000000..ba21cbc9f18 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BRICKWALL_LIMITER.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_DOWNLINK.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_DOWNLINK.png Binary files differnew file mode 100644 index 00000000000..a2ad7c93f3d --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_DOWNLINK.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_UPLINK.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_UPLINK.png Binary files differnew file mode 100644 index 00000000000..3253ce6988c --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_BUS_UPLINK.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CAPTURE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CAPTURE.png Binary files differnew file mode 100644 index 00000000000..38d52d59fb9 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CAPTURE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CDELAY.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CDELAY.png Binary files differnew file mode 100644 index 00000000000..6ddb4870a5b --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_CDELAY.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_COMPRESSOR.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_COMPRESSOR.png Binary files differnew file mode 100644 index 00000000000..a86ffd11084 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_COMPRESSOR.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DATA.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DATA.png Binary files differnew file mode 100644 index 00000000000..862388cfaeb --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DATA.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DEBUG.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DEBUG.png Binary files differnew file mode 100644 index 00000000000..9cc4357f567 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DEBUG.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DELAY.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DELAY.png Binary files differnew file mode 100644 index 00000000000..3bd53b34673 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DELAY.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DIV.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DIV.png Binary files differnew file mode 100644 index 00000000000..5b811cdda65 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_DIV.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_ENVELOPE_ADSR.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_ENVELOPE_ADSR.png Binary files differnew file mode 100644 index 00000000000..937e9468ac7 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_ENVELOPE_ADSR.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FM_SOURCE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FM_SOURCE.png Binary files differnew file mode 100644 index 00000000000..9554d41aa25 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FM_SOURCE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREEVERB.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREEVERB.png Binary files differnew file mode 100644 index 00000000000..1b1b8820033 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREEVERB.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREQUENCY.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREQUENCY.png Binary files differnew file mode 100644 index 00000000000..354eda36826 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FREQUENCY.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png Binary files differnew file mode 100644 index 00000000000..077539fe3d5 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_FX_CFLANGER.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_DEBUG.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_DEBUG.png Binary files differnew file mode 100644 index 00000000000..30c18efa5d8 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_DEBUG.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png Binary files differnew file mode 100644 index 00000000000..bd77d01587e --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MIDI_TEST.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png Binary files differnew file mode 100644 index 00000000000..55b48aaf222 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MOOG_VCF.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MUL.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MUL.png Binary files differnew file mode 100644 index 00000000000..0c98e4c82c9 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MUL.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png Binary files differnew file mode 100644 index 00000000000..a0ba2f1dfa2 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_MULTI_ADD.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NIL.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NIL.png Binary files differnew file mode 100644 index 00000000000..ca5de0768e8 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NIL.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NOISE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NOISE.png Binary files differnew file mode 100644 index 00000000000..97ab005cd93 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_NOISE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png Binary files differnew file mode 100644 index 00000000000..5b2b57a158e --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PITCH_SHIFT.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY.png Binary files differnew file mode 100644 index 00000000000..7f318b78e59 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY_WAV.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY_WAV.png Binary files differnew file mode 100644 index 00000000000..73c2c674ee3 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PLAY_WAV.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PSCALE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PSCALE.png Binary files differnew file mode 100644 index 00000000000..56e645b9d55 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_PSCALE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RC.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RC.png Binary files differnew file mode 100644 index 00000000000..45dd3765af7 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RC.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RECORD.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RECORD.png Binary files differnew file mode 100644 index 00000000000..d8e6a6ca7a5 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_RECORD.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE.png Binary files differnew file mode 100644 index 00000000000..25594c288f5 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE_FREQ.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE_FREQ.png Binary files differnew file mode 100644 index 00000000000..58efaaa67e6 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SEQUENCE_FREQ.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SHELVE_CUTOFF.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SHELVE_CUTOFF.png Binary files differnew file mode 100644 index 00000000000..cebd4bdc175 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_SHELVE_CUTOFF.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_STD_EQUALIZER.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_STD_EQUALIZER.png Binary files differnew file mode 100644 index 00000000000..6ae1a558e34 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_STD_EQUALIZER.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_TREMOLO.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_TREMOLO.png Binary files differnew file mode 100644 index 00000000000..917759c09ca --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_TREMOLO.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png Binary files differnew file mode 100644 index 00000000000..b67d88e0c58 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_PULSE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SIN.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SIN.png Binary files differnew file mode 100644 index 00000000000..6d26eab6ab6 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SIN.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png Binary files differnew file mode 100644 index 00000000000..2e697c4998e --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SOFTSAW.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SQUARE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SQUARE.png Binary files differnew file mode 100644 index 00000000000..ba99e85c0dd --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_SQUARE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_TRI.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_TRI.png Binary files differnew file mode 100644 index 00000000000..62083f4014a --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_WAVE_TRI.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_XFADE.png b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_XFADE.png Binary files differnew file mode 100644 index 00000000000..90498689710 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/images/Synth_XFADE.png diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.cache.bz2 b/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.cache.bz2 Binary files differnew file mode 100644 index 00000000000..5b6e019d64b --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.cache.bz2 diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.docbook new file mode 100644 index 00000000000..6464bca0192 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/index.docbook @@ -0,0 +1,449 @@ +<?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 % Spanish "INCLUDE" +> <!-- change language only here --> + <!ENTITY % addindex "IGNORE"> +]> + +<book lang="&language;"> +<bookinfo> +<title +>El manual de &arts;</title> +<authorgroup> + +<author +><firstname +>Stefan</firstname +> <surname +>Westerfeld</surname +> <affiliation +> <address +><email +>[email protected]</email +></address> +</affiliation> +</author> + +<author +><firstname +>Jeff</firstname +> <surname +>Tranter</surname +> <affiliation +> <address +><email +>[email protected]</email +></address> +</affiliation> +</author> + +<othercredit role="translator" +><firstname +>Salvador</firstname +><surname +>Gimeno Zanón</surname +><affiliation +><address +><email +>[email protected]</email +></address +></affiliation +><contrib +>Traductor</contrib +></othercredit +> <othercredit role="translator" +> <firstname +>Miguel</firstname +> <surname +>Revilla Rodríguez</surname +> <affiliation +><address +><email +>[email protected]</email +></address +></affiliation +> <contrib +>Traductor</contrib +></othercredit +> <othercredit role="translator" +> <firstname +>Alejandro</firstname +> <surname +>Exojo Piqueras</surname +> <affiliation +><address +><email +>[email protected]</email +></address +></affiliation +> <contrib +>Traductor</contrib +></othercredit +> +</authorgroup> + +<copyright> +<year +>1999-2001</year> +<holder +>Stefan Westerfeld y Jeff Tranter</holder> +</copyright> +<legalnotice +>&FDLNotice;</legalnotice> + +<date +>2001-06-10</date> +<releaseinfo +>1.00.09</releaseinfo> + +<abstract +><para +>Este manual describe &arts;, el Sintetizador Analógico en Tiempo Real.</para> + +</abstract> + +<keywordset> +<keyword +>aRts</keyword> +<keyword +>artsbuilder</keyword> +<keyword +>sintetizador</keyword> +<keyword +>multimedia</keyword> +<keyword +>estructura</keyword> +<keyword +>música</keyword> +<keyword +>sonido</keyword> +<keyword +>KDE</keyword> +</keywordset> +</bookinfo> + +<chapter id="introduction"> +<title +>Introducción</title> + +<sect1 id="what-is-arts"> +<title +>¿Qué es &arts;?</title> + +<para +>El sintetizador analógico en tiempo real, o &arts; (Analog Real-Time Synthesizer), es un sistema modular para sintetizar audio y música en ordenadores digitales. Utilizando unos pequeños bloques de construcción, llamados módulos, el usuario puede construir fácilmente complejas herramientas de procesado de audio. Los módulos proporcionan normalmente funciones tales como la generación de formas de onda de sonido, filtros, efectos de audio, mezclas, y la reproducción de audio digital en distintos formatos de archivo.</para> + +<para +>El servidor de sonido &artsd; mezcla el audio de distintas fuentes en tiempo real, permitiendo que múltiples aplicaciones de sonido compartan el acceso al hardware de audio de forma transparente.</para> + +<para +>Al utilizar &MCOP;, el Protocolo de Comunicaciones Multimedia, las aplicaciones multimedia pueden ser transparentes a la red, se pueden autentificar por seguridad, y pueden ser multiplataforma al utilizar interfaces definidos de forma independiente del lenguaje mediante el uso de &IDL;. También se provee de soporte para aplicaciones antiguas que no utilicen &arts;. Al ser uno de los componentes centrales del entorno de escritorio &kde; 2, &arts; ofrece las bases de la arquitectura multimedia de &kde; y en el futuro soportará más tipos de medios, incluyendo vídeo. Como &kde;, &arts; funciona sobre distintos sistemas operativos, incluyendo &Linux; y variantes de BSD. También puede utilizarse sin &kde;.</para> + +</sect1> + +<sect1 id="using-this-manual"> +<title +>Uso de este manual</title> + +<para +>Este manual pretende ofrecer una documentación comprensible sobre &arts; para usuarios con distintos niveles de conocimiento. Dependiendo de si usted es alguien que utiliza aplicaciones multimedia basadas en &arts; de vez en cuando, o de si es un desarrollador de aplicaciones multimedia, es posible que desee seguir caminos distintos a lo largo del manual.</para> + +<para +>Le recomendamos que primero lea el capitulo <link linkend="installation" +>Descargando y construyendo &arts;</link +> si necesita instalar y ejecutar &arts; por primera vez. Si ya tiene un sistema en funcionamiento, probablemente incluido con la distribución de su sistema operativo, puede optar por saltar esta sección.</para> + +<para +>Después debería leer las secciones del capítulo <link linkend="arts-tools" +>Herramientas &arts;</link +>, en especial &artsd;, &artscontrol;, &artsshell; y &artsdsp;. Esto le permitirá sacar el máximo provecho de &arts;.</para> + +<para +>Si está interesado en llegar más lejos con &arts;, lea el capítulo sobre <link linkend="artsbuilder" +>&arts-builder;</link +> y realice el tutorial. Esto le mostrará las grandes capacidades de &arts; y de los módulos incluídos que pueden ser utilizados sin ser un programador.</para> + +<para +>Si desea saber más sobre las interioridades de &arts;, bien para desarrollar aplicaciones multimedia, bien para mejorar el propio &arts;, lea todo o parte del capítulo <link linkend="arts-in-detail" +>&arts; al detalle</link +>. Le permitirá entender todos los conceptos que son necesarios para el desarrollo de software con &arts;.</para> + +<para +>Si está específicamente interesado en las capacidades <acronym +>MIDI</acronym +> de &arts;, debería leer el capítulo sobre <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 +>Si desea desarrollar aplicaciones multimedia que aprovechen &arts;, el capítulo <link linkend="arts-apis" +>API de &arts;</link +> trata en detalle las distintas <acronym +>API</acronym +>s.</para> + +<para +>Si desea ampliar &arts; desarrollando nuevos módulos, lea el capítulo <link linkend="arts-modules" +>Módulos &arts;</link +>.</para> + +<para +>Si está modificando una aplicación existente para que funcione con &arts;, lea el capítulo <link linkend="porting" +>Portando aplicaciones a &arts;</link +>.</para> + +<para +>Puede descubrir como colaborar con el proyecto &arts; en el capítulo <link linkend="contributing" +>Contribuyendo con &arts;</link +>, lea sobre el futuro desarrollo de &arts; en el capítulo <link linkend="future-work" +>Trabajo futuro</link +>, y encuentre enlaces a más información en la sección <link linkend="references" +>Referencias</link +>.</para> + +<para +>Hemos acabado de redondear el manual con algo de información adicional, incluyendo <link linkend="faq" +>respuestas a preguntas frecuentes</link +>, una <link linkend="contributors" +>lista con los colaboradores</link +>, los detalles del <link linkend="copyright-and-licenses" +>derechos de autor y la licencia</link +> de &arts;, y algo de información de referencia sobre <link linkend="intro-digital-audio" +>audio digital</link +> y <link linkend="midi-introduction" +>&MIDI;</link +>. También se ha incluído un <link linkend="glossary" +>glosario</link +>.</para> + +<note> +<para +>Este manual aun es un trabajo sin finalizar. Le invitamos a que colabore escribiendo parte de él, aunque si desea hacerlo, contacte primero con Jeff Tranter <email +>[email protected]</email +> o Stefan Westerfeld <email +>[email protected]</email +> para evitar la duplicidad de esfuerzos. </para> +</note> + +</sect1> + +<sect1 id="history"> +<title +>Historia</title> + +<para +>A finales de 1997 Stefan Westerfeld empezó a trabajar en un sistema modular, en tiempo real, para la síntesis de sonido. El código funcionaba inicialmente en un sistema PowerPC que ejecutaba &AIX;. Esta primera implementación era bastante simple, pero soportaba un sistema de flujo completo que era capaz, entre otras cosas, de reproducir archivos MP3 y transmisión de audio a través de módulos de efectos. </para> + + +<para +>El siguiente paso fue implementar una interfaz de usuario (&GUI;) para que los módulos pudieran manipularse de forma gráfica. Stefan tenía algo de experiencia en el uso de &kde;, por lo que fue elegido como la herramienta para la &GUI;, (sabiendo que podría ser también necesario hacer una versión Gnome/Gtk+) y esto llevó a que posteriormente se utilizara &Linux; como principal plataforma de desarrollo. Inicialmente llamado <application +>ksynth</application +>, el proyecto se renombró como &arts; y el ritmo de desarrollo aumentó. En esos momentos el proyecto estaba bastante completo, con un protocolo basado en <acronym +>CORBA</acronym +>, docenas de módulos, un editor gráfico de módulos, <acronym +>API</acronym +>s para C y C++, documentación, utilidades, una lista de distribución y una página web con un pequeño grupo de desarrolladores. El proyecto había recorrido un largo camino en poco más de un año de desarrollo.</para> + +<para +>Mientras el equipo de &kde; empezaba a planear &kde; 2.0, se hizo claro que &kde; necesitaba una infraestructura más potente de sonido y de medios en tiempo real. Se decidió adaptar &arts;, puesto que era un buen paso en esta dirección con una arquitectura probada. Un nuevo y mayor esfuerzo de desarrollo fue empleado en esta nueva versión de &arts;, siendo destacable el reemplazo del código <acronym +>CORBA</acronym +> con un nuevo subsistema, &MCOP;, optimizado para multimedia. La versión 0.4 de &arts; fue incluída en la versión 2.0 de &kde;.</para> + +<para +>El trabajo en &arts; continúa, mejorando el rendimiento y añadiendo nuevas funcionalidades. Es de destacar que aunque ahora &arts; es parte central de &kde;, puede utilizarse sin &kde;, y también es utilizado por aplicaciones que van más allá de la multimedia tradicional. El proyecto ha atraído algo de interés por parte del equipo de GNOME, abriendo la posibilidad de que tal vez algún día se convierta en la arquitectura multimedia estándar de los sistemas de escritorio &UNIX;.</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 +>Derechos de autor y licencia de &arts;</title> + +<para +>Derechos de autor del software &arts;. 1998-2001. Stefan Westerfeld <email +>[email protected]</email +>.</para> + +<para +><anchor id="contributors"/> Derechos de autor de la documentación. 1999-2001. Stefan Westerfeld <email +>[email protected]</email +> y Jeff Tranter <email +>[email protected]</email +>. </para> +<para +>Traducido por Salvador Gimeno Zanón <email +>[email protected]</email +>, Miguel Revilla Rodríguez <email +>[email protected]</email +> y Santiago Fernández Sancho <email +>[email protected]</email +>.</para +> +&underFDL; <para +>Todas las bibliotecas incluídas con &arts; tienen una licencia bajo los términos de la <acronym +>GNU</acronym +> Lesser General Public license. La mayor parte del código de &arts; se encuentra en las bibliotecas, incluyendo todo el <acronym +>MCOP</acronym +> y ArtsFlow. Esto permite que las bibliotecas sean utilizadas con aplicaciones que no sean gratuitas/libres si así se desea. </para> + +<para +>Hay algunos programas (como por ejemplo <application +>artsd</application +>), que son entregados bajo los términos de la <acronym +>GNU</acronym +> General Public License. Como hay diferentes opiniones sobre si enlazar programas <acronym +>GPL</acronym +> con &Qt; es legal, también se ha añadido una nota explicita que indica que, además de la <acronym +>GPL</acronym +>: también se da permiso para enlazar el programa con la biblioteca &Qt;, tratando &Qt; como una biblioteca que normalmente acompaña al núcleo del sistema, sea o no sea ese el caso.</para> + +</chapter> + +<appendix id="installation"> +<title +>Instalando &arts;</title> + +<para +>Para utilizar &arts; necesitará, obviamente, tenerlo instalado y en ejecución en su sistema. Hay dos formas de conseguir esto, que se describen en las siguientes secciones. </para> + +<sect1 id="binary-install"> +<title +>Instalando una distribución binaria precompilada</title> + +<para +>La forma más rápida y fácil de conseguir que &arts; se instale y funcione es instalar paquetes binarios precompilados para su sistema. La mayoría de distribuciones de &Linux; modernas incluyen &kde;, y si es &kde; 2.0 o superior incluirá &arts;. Si &kde; no va incluído con los discos de instalación puede que esté disponible para descargar desde el vendedor de su sistema operativo. También puede que esté disponible desde terceros. Asegúrese de utilizar paquetes que coincidan con la versión de su sistema operativo. </para> + +<para +>Una instalación básica de &kde; incluirá el servidor de sonido, permitiendo que la mayoría de aplicaciones reproduzcan audio. Si desea tener el conjunto completo de aplicaciones y herramientas multimedia, lo más probable es que necesite instalar más paquetes opcionales. </para> + +<para +>La desventaja de utilizar binarios precompilados es que puede que no sean de la versión más moderna de &arts;. Esto es particularmente probable si se incluyen en &CD-ROM;, ya que el ritmo de desarrollo de &arts; y &kde; es tan rápido que normalmente los medios en &CD-ROM; no son capaces de seguir el ritmo. También puede encontrarse con que, si tiene una de las arquitecturas o sistemas operativos menos comunes, no existan binarios precompilados y necesite utilizar el segundo método. </para> + +</sect1> + +<sect1 id="source-install"> +<title +>Construyendo desde los fuentes</title> + +<para +>Aunque necesite más tiempo, la forma más flexible de construir &arts; es compilarlo uno mismo desde los fuentes. Ésto le asegura que tiene una versión optimizada para la configuración de su sistema y le permite tener la versión más reciente. </para> + +<para +>Tiene dos opciones, puede instalar la versión estable más reciente incluída con &kde; o puede obtener la versión más reciente (pero posiblemente inestable) directamente desde el repositorio de <acronym +>CVS</acronym +> del proyecto &kde;. La mayoría de usuarios que no estén desarrollando para &arts; deberían utilizar la versión estable. Puede descargarla desde <ulink url="ftp://ftp.kde.org" +>ftp://ftp.kde.org</ulink +> o desde uno de los múltiples espejos del servidor. Si está colaborando en el desarrollo de &arts; lo más probable es que desee utilizar la versión del <acronym +>CVS</acronym +>. Si desea utilizar aRts sin KDE, puede descargar una captura de la versión de desarrollo sin KDE desde <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 +>Recuerde que si está compilando desde el <acronym +>CVS</acronym +>, algunos de los componentes de &arts; (por ⪚ los componentes básicos del núcleo, incluyendo el servidor de sonido) se encuentran en el módulo tdelibs del <acronym +>CVS</acronym +>, mientras que otros componentes adicionales (como por ⪚ <application +>artsbuilder</application +>) se incluyen en tdemultimedia. Esto puede cambiar en el futuro. También puede encontrar una versión en el módulo kmusic. Es una versión antigua (anterior a &kde; 2.0) que se ha quedado obsoleta. </para> + +<para +>Los requerimientos para construir &arts; son esencialmente los mismos que para construir &kde;. Los archivos configure se encargarán de detectar la configuración de su sistema y le informarán de si falta algún componente. Asegúrese de tener un controlador de sonido que funcione en su sistema (ya sea el controlador del núcleo <acronym +>OSS</acronym +>/Free, el controlador <acronym +>OSS</acronym +> de 4Front Technologies, o el controlador <acronym +>ALSA</acronym +> con emulación <acronym +>OSS</acronym +>). </para> + +<para +>Puede encontrar más información sobre descargar e instalar &kde; (incluyendo &arts;) en las <ulink url="http://www.kde.org/documentation/faq/index.html" +>&FAQ; de &kde;</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-es/docs/tdemultimedia/artsbuilder/mcop.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/mcop.docbook new file mode 100644 index 00000000000..cb501600c6c --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/mcop.docbook @@ -0,0 +1,1872 @@ +<!-- <?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;: modelo de objetos y transmisión</title> + +<sect1 id="mcop-overview"> + +<title +>Introducción</title> + +<para +>&MCOP; es el estándar que utiliza &arts; para: </para> + +<itemizedlist> +<listitem> +<para +>La comunicación entre los objetos. </para> +</listitem> + +<listitem> +<para +>La transparencia de red. </para> +</listitem> + +<listitem> +<para +>La descripción de entornos de objetos. </para> +</listitem> + +<listitem> +<para +>Independencia del lenguaje. </para> +</listitem> +</itemizedlist> + +<para +>Uno de los aspectos mas importantes de &MCOP; es el <emphasis +>lenguaje de descripción de interfaces</emphasis +>, &IDL;, por el cual muchas de las interfaces de &arts; y <acronym +>API</acronym +>s se definen en un lenguaje independiente. </para> + +<para +>Para utilizar las interfaces &IDL; de C++, está compilado por el compilador &IDL; en código C++. Cuando implementa una interfaz, éste deriva del esqueleto de una clase &IDL; que el compilador ha generado. Cuando utiliza una interfaz está utilizando un envoltorio. De esta forma, &MCOP; puede utilizar un protocolo si el objeto con el que se está comunicando no es local (de forma transparente a la red). </para> + +<para +>Este capítulo se propone describir las características básicas del modelo de objetos que resulta del uso de &MCOP;, el protocolo, cómo usar &MCOP; en C++ (lenguaje asociado), y mucho más. </para> + +</sect1> + +<sect1 id="interfaces"> + +<title +>Interfaces e &IDL;</title> + +<para +>Muchos de los servicios proporcionados por &arts;, como los módulos y el servidor de sonido, se definen en términos de <acronym +>interfaces</acronym +>. Las interfaces se especifican en un lenguaje de programación de formato independiente: &IDL;. </para> + +<para +>Ésto permite implementar que, muchos detalles como el formato de las transmisiones de datos multimedia, transparencia de red y dependencias del lenguaje de programación, estén ocultos desde la especificación de la interfaz. La herramienta, &mcopidl;, traduce la defición de interfaz a un lenguaje de programación específico (actualmente solo está soportado C++). </para> + +<para +>La herramienta genera un esqueleto con todo el código y la funcionalidad básicos. De esta clase podrá derivar las características que desee. </para> + +<para +>El &IDL; usado por &arts; es similar al usado por <acronym +>CORBA</acronym +> y <acronym +>DCOM</acronym +>. </para> + +<para +>Los archivos &IDL; pueden contener: </para> + +<itemizedlist> +<listitem> +<para +>Directivas #include al estilo C para otros archivos &IDL;. </para> +</listitem> + +<listitem> +<para +>Definición de tipos de enumeraciones y estructuras, cono en C/C++. </para> +</listitem> + +<listitem> +<para +>Definición de interfaces. </para> +</listitem> +</itemizedlist> + +<para +>En &IDL;, las interfaces se definen como una clase C++ o como una estructura C, pero con algunas restricciones. Como en C++, las interfaces pueden contener otras interfaces usando la herencia. Las definiciones de interfaces pueden incluír tres cosas: transmisiones, atributos y métodos. </para> + +<sect2 id="streams"> + +<title +>Transmisiones</title> + +<para +>Las transmisiones definen datos multimedia, uno de los componentes más importantes de un módulo. Las transmisiones se definen con el siguiente formato: </para> + +<para +>[ async ] in|out [ multi ] <replaceable +>tipo</replaceable +> stream <replaceable +>nombre</replaceable +> [ , <replaceable +>nombre</replaceable +> ] ; </para> + +<para +>Los transmisiones tienen una dirección definida con respecto al módulo, que se indica con las partículas in y out. El tipo de argumento define el tipo de datos, que puede ser uno de los tipos descritos más tarde para los atributos (no todos están actualmente soportados). Muchos módulos usan el tipo de transmisión de audio, que es un alias para 'punto flotante' ya que es el formato interno de datos usado para la transmisión de audio. Se pueden definir múltiples transmisiones del mismo tipo en la misma definición utilizando nombres separados por comas. </para> + +<para +>Las transmisiones son de manera predeterminada síncronas, que significa que son corrientes contínuas de datos a un ratio constante, como el audio <acronym +>PCM</acronym +>. El calificador async especifica una transmisión asíncrona, que se usa para corrientes discontínuas de datos. El ejemplo más común de flujo asíncrono es los mensajes &MIDI;. </para> + +<para +>La palabra clave multi, sólo válida para transmisiones de entrada, indica que la interfaz soporta un número variable de entradas. Ésto es útil para implementar dispositivos como mezcladores que puedan aceptar cualquier número de transmisiones de entrada. </para> + +</sect2> +<sect2 id="attributes"> + +<title +>Atributos</title> + +<para +>Los atributos son datos asociados con una instancia de una interfaz. Se declaran como variables miembro en C++, y puede usar algunos de los tipos primitivos boolean, byte, long, string o float. Puede también usar tipos enumerados o estructuras definidas por el usuario así como secuencias de tamaño variable usando la sintaxis sequence<type>. Los atributos pueden ser opcionalmente marcados como solo léctura. </para> + +</sect2> +<sect2 id="methods"> + +<title +>Métodos</title> + +<para +>Como en C++, los métodos pueden definirse en las interfaces. Los parámetros de los métodos están restringidos al mismo tipo que los atributos. La palabra clave oneway indica un método que retorna inmediatamente y se ejecuta asincrónicamente. </para> + +</sect2> + +<sect2 id="standardinterfaces"> + +<title +>Interfaces estándar</title> + +<para +>Muchas interfaces de módulos estándar están ya definidas en &arts;, como <interfacename +>StereoEffect</interfacename +> y <interfacename +>SimpleSoundServer</interfacename +>. </para> + +</sect2> + +<sect2 id="example"> +<title +>Ejemplo</title> + +<para +>Un simple ejemplo de módulo sacado de &arts; es el módulo retraso constante, alojado en el archivo <filename +>tdemultimedia/arts/modules/artsmodules.idl</filename +>. La definición de la interfaz se lista a continuación. </para> + +<programlisting +>interface Synth_CDELAY : SynthModule { + attribute float time; + in audio stream invalue; + out audio stream outvalue; +}; +</programlisting> + +<para +>Este módulo se hereda de <interfacename +>SynthModule</interfacename +>. Esta interfaz, definida en <filename +>artsflow.idl</filename +>, define los métodos estándar implementados en todos los módulos de sintetizadores de música. </para> + +<para +>CDELAY provoca un retraso en la transferencia del audio estéreo durante el tiempo especificado como un parámetro de coma flotante. La definición del interfaz tiene un atributo de tipo número de coma flotante para guardar el valor del retraso. Define dos transferencias de entrada de audio y dos de salida (habitual en los efectos estereofónicos). No precisa de otros métodos cuando se heredan éstos. </para> + +</sect2> + +</sect1> + +<sect1 id="more-about-streams"> +<title +>Más sobre transmisiones</title> + +<para +>Esta sección añade algunos consejos relacionados con las transmisiones. </para> + +<sect2 id="stream-types"> +<title +>Tipos de transmisión</title> + +<para +>Hay algunos requerimientos para que un módulo pueda hacer transmisión. Para ilustrar esto, considere los siguientes ejemplos: </para> + +<itemizedlist> +<listitem> +<para +>Escalar una señal por un factor dos. </para> +</listitem> + +<listitem> +<para +>Realizar conversiones de la frecuencia de muestreo. </para> +</listitem> + +<listitem> +<para +>Descomprimir una señal codificada con RLE. </para> +</listitem> + +<listitem> +<para +>Leer eventos &MIDI; desde <filename class="devicefile" +>/dev/midi00</filename +> e insertarlos en una transmisión. </para> +</listitem +> +</itemizedlist> + +<para +>El primer caso es el más simple: una vez que se reciben 200 muestras de entrada el módulo produce 200 muestras de salida. Solamente produce salida cuando recibe una entrada. </para> + +<para +>El segundo caso produce diferentes números de muestras de salida cuando recibe 200 muestras de entrada. Depende de la conversión que se realice, pero ese número se conoce a priori. </para> + +<para +>El tercer caso es incluso peor. Ya desde el principio no podrá averiguar cuántos datos reciben entradas de 200 bytes (probablemente muchos más de 200 bytes, pero...). </para> + +<para +>El último caso es un módulo que viene activo por sí mismo, y que en ocasiones produce datos. </para> + +<para +>En &arts;-0.3.4, solo se manejaban las transmisiones de primer tipo, y la mayor parte de las cosas funcionaban. Ésto es lo que probablemente necesitaba para escribir módulos que procesen audio. El problema con los demás tipos más complejos de transmisión, es que son difíciles de programar, y la mayor parte de las veces no necesitará estas características. Esto se debe a que podemos hacerlo con dos tipos diferentes de transmisiones: síncrona y asíncrona. </para> + +<para +>Las transmisiones síncronas tienen estas características: </para> + +<itemizedlist> +<listitem> +<para +>Los módulos deben ser capaces de calcular datos de cualquier longitud, dada una entrada suficiente. </para> +</listitem> + +<listitem> +<para +>Todas las transmisiones tienen el mismo ratio de muestreo. </para> +</listitem> + +<listitem> +<para +>La función <function +>calculateBlock()</function +> se llamará cuando existan suficientes datos disponibles, y el módulo pueda depender de que los punteros apunten a los datos. </para> +</listitem +> + +<listitem> +<para +>No se puede hacer asignación ni liberación de memoria. </para> +</listitem> +</itemizedlist> + +<para +>La transmisión asíncrona, por otro lado, sigue este comportamiento: </para> + +<itemizedlist> +<listitem> +<para +>Los módulos pueden producir datos algunas veces, o con ratio de muestreo variable, o solo si reciben una entrada desde algún descriptor de archivo. No se rigen por la regla «tener que ser capaces de satisfacer peticiones de cualquier tamaño». </para> +</listitem> + +<listitem> +<para +>Las transmisiones asíncronas de un módulo pueden tener ratios de muestreo completamente diferentes. </para> +</listitem> + +<listitem> +<para +>Transmisiones salientes: hay funciones específicas para asignar paquetes, para enviar paquetes, y un mecanismo opcional de votación que le dirá cuando debe crear más datos. </para> +</listitem> + +<listitem> +<para +>Transmisiones entrantes: puede recibir una llamada cuando recibe un nuevo paquete. Tendría que establecer cuándo se procesan todos los datos del paquete, si no lo hacen de una vez (lo podrá decidir posteriormente, y en el caso de que alguien haya procesado un paquete, indicar si se liberará/reutilizará). </para> +</listitem> +</itemizedlist> + +<para +>Cuando declare transmisiones, utilice la palabra clave «async» para indicar que desea hacer un flujo asíncrono. Así, por ejemplo, imaginemos que desea convertir una transimisión asíncrona de bytes en una transmisión síncrona de muestras. Su interfaz debería parecerse a esto: </para> + +<programlisting +>interface TransmisionDeByteAAudio : SynthModule { + async in byte stream entrada; // la transmisión asíncrona de entrada de muestras + + out audio stream izquierda,derecha; // la transmisión síncrona de salida de muestras +}; +</programlisting> + +</sect2> + +<sect2 id="async-streams"> +<title +>Utilizar transmisiones asíncronas</title> + +<para +>Suponga que decide escribir un módulo para producir sonido asíncronamente. Su interfaz puede parecerse a algo como esto: </para> + +<programlisting +>interface UnModulo : SynthModule +{ + async out byte stream salida; +}; +</programlisting> + +<para +>¿Cómo puede enviar los datos? El primer método se llama «push delivery» (entrega por empuje). Con las transmisiones asíncronas envía los datos como paquetes. Ésto significa que envía paquetes individuales con bytes como en el ejemplo de arriba. El proceso actual es: asignar un paquete, rellenarlo, enviarlo. </para> + +<para +>Ahora en términos de código. Primero asignamos el paquete: </para> + +<programlisting +>DataPacket<mcopbyte> *paquete = salida.allocPacket(100); +</programlisting> + +<para +>Ahora lo rellenamos: </para> + +<programlisting +>// convertir de modo que fgets contenga un puntero (char *) +char *datos = (char *)paquete->contents; + +// como puede ver, podrá reducir el tamaño del paquete tras la asignación +// si así lo desea +if(fgets(datos,100,stdin)) + paquete->size = strlen(datos); +else + paquete->size = 0; +</programlisting> + +<para +>Ahora lo enviamos: </para> + +<programlisting +>paquete->send(); +</programlisting> + +<para +>Ésto es muy simple, pero si deseamos enviar paquetes con la misma velocidad que el receptor pueda procesarlos, necesitaremos otra aproximación, el método «pull delivery» (entrega por empuje). Envía paquetes tan pronto como el receptor está preparado para procesarlos. Empieza con una cierta cantidad de paquetes que envía. Cuando el receptor procesa un paquete tras otro, se comenzará a rellenarlos con datos nuevos y se enviarán nuevamente. </para> + +<para +>Empiece llamando a setPull. Por ejemplo: </para> + +<programlisting +>salida.setPull(8, 1024); +</programlisting> + +<para +>Significa que desea enviar paquetes sobre los datos de salida. Tiene que empezar enviando 8 paquetes de una vez, y cuando el receptor procese alguno de ellos, tiene que rellenarlos. </para> + +<para +>Entonces, necesita implementar un método que llene los paquetes, que podría parecerse a esto: </para> + +<programlisting +>void request_salida(DataPacket<mcopbyte> *paquete) +{ + paquete->size = 1024; // no debe ser mayor que 1024 + for(int i = 0;i < 1024; i++) + paquete->contents[i] = (mcopbyte)'A'; + paquete->send(); +} +</programlisting> + +<para +>Ya está. Cuando se necesite enviar más datos, se puede empezar a enviar paquetes con tamaño cero, lo que detendrá la recepción. </para> + +<para +>Fíjese que es esencial dar al método el nombre exacto <methodname +>request_<replaceable +>nombre_transmision</replaceable +></methodname +>. </para> + +<para +>Empezamos enviando datos. Recibirlos es mucho más sencillo. Suponga que tiene un filtro ParaMinusculas, que simplemente convierte todas las letras en minúsculas: </para> + +<programlisting +>interface ParaMinusculas { + async in byte stream entrada; + async out byte stream salida; +}; +</programlisting> + +<para +>Es realmente simple de implementar. Aquí está la implementación completa: </para> + +<programlisting +>class ParaMinusculas_impl : public ParaMinusculas_skel { +public: + void process_entrada(DataPacket<mcopbyte> *paquete_entrada) + { + DataPacket<mcopbyte> *paquete_salida = salida.allocPacket(paquete_entrada->size); + + // convierte a minúsculas + char *texto_entrada = (char *)paquete_entrada->contents; + char *texto_salida = (char *)paquete_salida->contents; + + for(int i=0;i<paquete_entrada->size;i++) + textosalida[i] = tolower(textoentrada[i]); + + paquete_entrada->processed(); + paquete_salida->send(); + } +}; + +REGISTER_IMPLEMENTATION(ParaMinusculas_impl); +</programlisting> + +<para +>De nuevo, es esencial nombrar el método como <methodname +>process_<replaceable +>nombre_transmision</replaceable +></methodname +>. </para> + +<para +>Como puede comprobar, para cada paquete que llega tiene una llamada para una función (llamada <function +>process_entrada</function +>en nuestro caso). Necesita llamar al método <methodname +>processed()</methodname +> de un paquete para indicar que lo ha procesado. </para> + +<para +>Un consejo para la implementación: si el procesado tarda mucho (&ie;, si necesita esperar la salida de la tarjeta de sonido o algo similar), no llame a lo procesado inmediatamente, en su lugar almacene el paquete de datos completo y procese la llamada tan pronto como el paquete se haya procesado. De esta forma, los emisores tienen la posibilidad de saber cuanto durará su trabajo. </para> + +<para +>Como la sincronización con flujos asíncronos no es muy buena, debe usar flujos síncronos cuando sea posible y flujos asíncronos solo cuando sea necesario. </para> + +</sect2> + +<sect2 id="default-streams"> +<title +>Transmisiones predeterminadas</title> + +<para +>Suponga que tiene 2 objetos, por ejemplo un ProductorDeAudio y un ConsumidorDeAudio. El ProductorDeAudio tiene una transmisión de salida y el ConsumidorDeAudio tiene una de entrada. Cada vez que intente conectarlos, usará estas 2 transmisiones. El primer uso de predeterminación es el de habilitarle para hacer las conexiones sin especificar los puertos. </para> + +<para +>Ahora imagine que los dos objetos anteriores pueden manejar estéreo, y que cada uno tiene un puerto «izquierdo» y otro «derecho». Podría conectarse a ellos de una forma todavía más fácilmente que antes. Pero ¿cómo puede saber el sistema que se conecta cuál es el puerto de salida y cuál el de entrada? No existe una forma correcta de mapear la transmisión. De forma predeterminada se especifican varias transmisiones, con un orden. Así, cuando conecta un objeto con 2 salidas de transmisión predeterminada con otro con 2 entradas de transmisión predeterminadas, no necesitará especificar los puertos, y el mapeado se realizará de forma correcta. </para> + +<para +>Por supuesto, no está limitado al estéreo. Cualquier número de transmisiones pueden declararse predeterminados si es necesario, y la función connect comprobará que el número predeterminado para 2 objetos coinciden (en la dirección requerida) si usted no especifica los puertos a usar. </para> + +<para +>La sintaxis es la siguiente: en el &IDL;, puede usar la palabra clave 'default' en la declaración de la transmisión, o en una línea simple. Por ejemplo: </para> + +<programlisting +>interface CombinarDosEnUno { + default in audio stream entrada1, entrada2; + out audio stream salida; +}; +</programlisting> + +<para +>En este ejemplo, el objeto esperará a sus dos puertos de entrada estén conectados de forma predeterminada. La orden es la especificada en la línea 'default', por lo que un objeto como este otro: </para> + +<programlisting +>interface GeneradorDeRuidoDual { + out audio stream bzzt, couic; + default couic, bzzt; +}; +</programlisting> + +<para +>Hará conexiones de «couic» a «entrada1», y de «bzzt» a «entrada2» automáticamente. Tenga en cuenta que como solo hay una entrada para el mezclador, en este caso se hará de forma predeterminada (ver a continuación). La sintaxis utilizada en el generador de ruido es práctica para declarar un orden diferente que en la declaración, o seleccionando únicamente unos pocos puertos predeterminados. Las direcciones de los puertos en esta línea se pueden buscar por &mcopidl;, por tanto no lo especifique. Incluso puede mezclar puertos de entrada y de salida en cada línea, sólo es importante el orden. </para> + +<para +>Cuando se utiliza la herencia se deben seguir ciertas reglas: </para> + +<itemizedlist> +<listitem> +<para +>Si hay una lista predeterminada especificada en el &IDL;, la utilizará. Los puertos padre pueden ser colocados en esta lista también, ya sean predefinidos en el padre o no. </para> +</listitem> + +<listitem> +<para +>En otro caso hereda los valores predeterminados del padre. El orden es padre1 predeterminado1, padre1 predeterminado2.., padre2 predeterminado1... Si existe un antecedente común a ambos utilizando 2 ramas padre, se realiza una mezcla similar a un «virtual public» de forma predeterminada en la primera aparición de la lista. </para> +</listitem> + +<listitem> +<para +>Si todavía no hay una predeterminada y existe una transmisión simple en una dirección, ésta se utiliza como predeterminada para esta dirección. </para> +</listitem> +</itemizedlist> + +</sect2> + +</sect1> +<sect1 id="attribute-change-notify"> +<title +>Notificaciones de cambio de atributos</title> + +<!-- TODO: This should be embedded better into the context - I mean: the + context should be written ;-). --> + +<para +>Las notificaciones de cambio de atributos son una forma de saber cuando un atributo cambia. Es comparable con las señales y slots de &Qt; o Gtk. Por ejemplo, si tiene un elemento de una &GUI;, un deslizador, que configura un número entre 0 y 100, normalmente dispondrá de un objeto que haga algo con ese número (por ejemplo, podría estar controlando el volumen de alguna señal de audio). Por lo que le gustaría que una vez que el deslizador se mueva, el objeto que escala el volumen reciba una notificación. Una conexión entre un emisor y un receptor. </para> + +<para +>&MCOP; negocia con ésto, siendo capaz de efectuar notificaciones cuando los atributos cambian. Lo que se declara como «atributo» en el &IDL;, puede emitir estas notificaciones de cambio, y debería hacerlo, cuando se producen modificaciones. Aquello que se declara como «atributo» también puede recibir estas notificaciones. Así, por ejemplo, si tiene dos interfaces &IDL;, como estos: </para> + +<programlisting +>interface Deslizador { + attribute long min,max; + attribute long posicion; + }; + interface ControlDeVolumen : Arts::StereoEffect { + attribute long volume; // 0..100 + }; +</programlisting> + +<para +>Puede conectarlos usando notificaciones de cambio. Funciona usando la operación normal de conectar el sistema de flujo. En este caso, el código C++ para conectar dos objetos se parecería a esto: </para> + +<programlisting +>#include <connect.h> +using namespace Arts; +[...] +connect(deslizador,"position_changed",volumeControl,"volume"); +</programlisting> + +<para +>Como puede ver, cada atributo ofrece dos flujos diferentes, uno para enviar notificaciones de cambio, llamado <function +><replaceable +>nombre_atributo</replaceable +>_changed</function +>, y uno para recibir notificaciones de cambio, llamado <function +>nombre_atributo</function +>. </para> + +<para +>Es importante saber que las notificaciones de los cambios y las transmisiones asíncronas son compatibles. Son transparentes a la red. Por eso puede conectar una notificación de un cambio de un atributo en coma flotante de un componente de un &GUI; a una transmisión asíncrona de un módulo de síntesis que se esté ejecutando en otro ordenador. Esto implica que las notificaciones de cambio son <emphasis +>no síncronas</emphasis +>, lo que significa que después de que haya enviado la notificación de cambio, pasará algún tiempo hasta que la reciba realmente. </para> + +<sect2 id="sending-change-notifications"> + +<title +>Enviando notificaciones de cambio</title> + +<para +>Cuando implementa objetos que contienen atributos, necesita enviar notificaciones de cambio cuando un atributo cambia. El código para hacer esto debe parecerse a esto: </para> + +<programlisting +>void KPoti_impl::value(float nuevoValor) + { + if(nuevoValor != _valor) + { + _valor = nuevoValor; + value_changed(nuevoValor); // <- envía notificación de cambio + } + } +</programlisting> + +<para +>Es altamente recomendable utilizar código como éste para todos los objetos que implemente, ya que las notificaciones de cambio puede ser utilizadas por otras personas. Debería sin embargo evitar el envío de notificaciones con demasiada frecuencia, ya que si está procesando la señal, probablemente será mejor que mantenga un registro de cuando envió la última notificación, de forma que no envíe una con cada muestra que procese. </para> + +</sect2> + +<sect2 id="change-notifications-apps"> +<title +>Aplicaciones para notificaciones de cambio</title> + +<para +>Es especialmente práctico utilizar notificaciones de cambio junto con osciloscopios (elementos que visualizan datos de audio, por ejemplo), elementos gráficos, elementos de control, y monitorización. El código que utiliza esto se encuentra en <filename class="directory" +>tdelibs/arts/tests</filename +>, y en la implementación experimental de artsgui, que puede encontrar en <filename class="directory" +>tdemultimedia/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 +>El archivo <literal role="extension" +>.mcoprc</literal +></title> + +<para +>El archivo <literal role="extension" +>.mcoprc</literal +> (se encuentra en cada carpeta personal de cada usuario) puede usarse para configurar &MCOP; de diferentes maneras. Actualmente, son posibles las siguientes: </para> + +<variablelist> + +<varlistentry> +<term +>GlobalComm</term> +<listitem> +<para +>El nombre de un interfaz que se utilizará para la comunicación global. La comunicación global se utiliza para encontrar otros objetos y para obtener la cookie secreta. Los múltiples clientes/servidores &MCOP; deberían ser capaces de hablar entre ellos y para ello necesitan un objeto GlobalComm que sea capaz de compartir información entre ellos. Actualmente, los posibles valores son «Arts::TmpGlobalComm» para comunicarse a través de la carpeta <filename class="directory" +>/tmp/mcop-<replaceable +>nombreusuario</replaceable +></filename +> (que únicamente pueden trabajar en el ordenador local) y «Arts::X11GlobalComm» para comunicarse a través de las propiedades de la ventana raíz en el servidor X11. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>TraderPath</term> + +<listitem> +<para +>Especifica dónde encontrar la información de negociación. Puede enumerar más de una carpeta aquí separándolas por comas, como en el ejemplo. </para> +</listitem> + +</varlistentry> + +<varlistentry> +<term +>ExtensionPath</term> + +<listitem> +<para +>Especifica qué extensiones de carpetas se cargarán (en forma de bibliotecas compartidas). Se pueden especificar múltiples valores separados por comas. </para> +</listitem> + +</varlistentry> +</variablelist> + +<para +>Un ejemplo que usa todo lo que se describe arriba: </para> + +<programlisting +># archivo $HOME/.mcoprc +GlobalComm=Arts::X11GlobalComm + +# si es un desarrollador, puede ser práctico añadir una carpeta en su carpeta personal +# para que la ruta del negociador/extensión sea capaz de añadir componentes sin +# instalarlos +TraderPath="/opt/kde2/lib/mcop","/home/jose/mcopdesarrollo/mcop" +ExtensionPath="/opt/kde2/lib","/home/jose/mcopdesarrollo/lib" +</programlisting> + +</sect1> + +<sect1 id="mcop-for-corba-users"> +<title +>&MCOP; para usuarios de <acronym +>CORBA</acronym +></title> + +<para +>Si ha usado <acronym +>CORBA</acronym +> antes, verá que &MCOP; es más o menos lo mismo. De hecho, &arts; antes de la versión 0.4 usaba <acronym +>CORBA</acronym +>. </para> + +<para +>La idea básica de <acronym +>CORBA</acronym +> es la misma: implementar objetos (componentes). Usando las características de &MCOP;, sus objetos no están solo disponibles como clases normales del mismo proceso (via técnicas estándar de C++), sino también para servidores remotos de forma transparente. Para este trabajo, lo primero que necesita hacer es especificar la interfaz de sus objetos en un archivo &IDL;, al igual que el &IDL; de <acronym +>CORBA</acronym +>. Solo hay unas pequeñas diferencias. </para> + +<sect2 id="corba-missing"> +<title +>Características de <acronym +>CORBA</acronym +> que no existen en &MCOP;</title> + +<para +>En &MCOP; no existen los parámetros «in» y «out» en las invocaciones de métodos. Los parámetros son siempre de entrada, el código de retorno es siempre de salida, lo que significa que la interfaz: </para> + +<programlisting +>// idl CORBA +interface Contabilizar { + void cargar( in long importe ); + void abonar( in long importe ); + long saldo(); +}; +</programlisting> + +<para +>se escribe como: </para> + +<programlisting +>// idl MCOP +interface Contabilizar { + void cargar( long importe ); + void abonar( long importe ); + long saldo(); +}; +</programlisting> + +<para +>en &MCOP;. </para> + +<para +>No existe soporte de excepciones. &MCOP; no tiene excepciones, utiliza algo diferente para la gestión de errores. </para> + +<para +>No existen tipos 'union' ni 'typedef'. No se si realmente es un fallo, o una medida desesperada para sobrevivir. </para> + +<para +>No existe soporte para interfaces pasivas o referencias a objetos. </para> + +</sect2> + +<sect2 id="corba-different"> +<title +>Características de <acronym +>CORBA</acronym +> que son diferentes en &MCOP;</title> + +<para +>Declara secuencias como «secuencia<replaceable +>tipo</replaceable +>» en &MCOP;. No se necesita 'typedef'. Por ejemplo, en lugar de: </para> + +<programlisting +>// idl CORBA +struct Linea { + long x1,y1,x2,y2; +}; +typedef sequence<Linea> Lineas; +interface Trazador { + void trazar(in Lineas lineas); +}; +</programlisting> + +<para +>usted escribiría </para> + +<programlisting +>// idl MCOP +struct Linea { + long x1,y1,x2,y2; +}; +interface Trazador { + void trazar(sequence<Linea> lineas); +}; +</programlisting> + +</sect2> + +<sect2 id="no-in-corba"> +<title +>Características de &MCOP; que no existen en <acronym +>CORBA</acronym +></title> + +<para +>Puede declarar transmisiones, que se evaluarán por el entorno de trabajo &arts;. Las transmisiones se declaran de manera similar a los atributos. Por ejemplo: </para> + +<programlisting +>// idl MCOP +interface Synth_SUMAR : SynthModule { + in audio stream señal1,señal2; + out audio stream salida; +}; +</programlisting> + +<para +>Esto indica que su objeto aceptará dos transmisiones de audio síncronas entrantes llamadas señal1 y señal2. Síncrono significa que son transmisiones que entregan x muestras por segundo (u otro periodo de tiempo), de forma que el planificador garantizará que siempre proporcione una cantidad equilibrada de datos de entrada (⪚ 200 muestras de la señal1 y 200 de la señal2). Garantizará esto si su objeto es llamado con estas 200 muestras de señal1 + señal2, que producirá exactamente 200 muestra de valor de salida. </para> + +</sect2> + +<sect2 id="mcop-binding"> +<title +>Las uniones en el lenguaje C++ en &MCOP;</title> + +<para +>Difiere de <acronym +>CORBA</acronym +> principalmente en: </para> + +<itemizedlist> +<listitem> +<para +>Las cadenas utilizan la clase <acronym +>STL</acronym +> <classname +>string</classname +> de C++. Cuando se guardan secuencias, se guardan «planas», lo que significan que son consideradas un tipo primitivo. Por esta razón necesitan ser copiadas. </para> +</listitem> + +<listitem> +<para +>Los números 'long' son 'long' normales (excepto los de 32 bit). </para> +</listitem> + +<listitem> +<para +>Las secuencias utilizan la clase <acronym +>STL</acronym +> <classname +>vector</classname +> de C++. </para> +</listitem> + +<listitem> +<para +>Todas las estructuras se derivan de la clase &MCOP; <classname +>Type</classname +>, y se generan por el compilador &IDL; de &MCOP;. Cuando se guardan en secuencias, no se guardan de forma «plana», sino como punteros, ya que sino se realizaría demasiado trabajo de copiado. </para> +</listitem> +</itemizedlist> +</sect2> + +<sect2 id="implementing-objects"> +<title +>Implementando objetos &MCOP;</title> + +<para +>Después de haber pasado a través del compilador &IDL;, necesitará derivarlos de la clase <classname +>_skel</classname +>. Por ejemplo, imagine que tiene definida una interfaz como esta: </para> + +<programlisting +>// idl MCOP: hola.idl +interface Hola { + void hola(string s); + string concatenar(string s1, string s2); + long sumar2(long a, long b); +}; +</programlisting> + +<para +>Podrá pasar ésto por el compilador &IDL; haciendo <userinput +><command +>mcopidl</command +> <parameter +>hola.idl</parameter +></userinput +>, que debería generar <filename +>hola.cc</filename +> y <filename +>hola.h</filename +>. Para implementarlo, necesitará definir una clase C++ que herede el esqueleto: </para> + +<programlisting +>// archivo cabecera C++ - incluir hola.h en algún sitio +class Hola_impl : virtual public Hola_skel { +public: + void hola(const string& s); + string concatenar(const string& s1, const string& s2); + long sumar2(long a, long b); +}; +</programlisting> + +<para +>Finalmente, necesitará implementar los métodos de la forma habitual en C++. </para> + +<programlisting +>// archivo de implementación C++ + +// como puede ver las cadenas se pasan como referencias a const string (constantes de cadena) +void Hola_impl::hola(const string& s) +{ + printf("Hola '%s'!\n",s.c_str()); +} + +// cuando devuelvan un código se pasarán como cadenas «normales» +string Hola_impl::concat(const string& s1, const string& s2) +{ + return s1+s2; +} + +long Hola_impl::sumar2(long a, long b) +{ + return a+b; +} +</programlisting> + +<para +>Una vez que haya hecho esto, tendrá un objeto que podrá comunicarse utilizando &MCOP;. Cree uno (use las funcionalidades habituales de C++ para crear un objeto): </para> + +<programlisting +>Hola_impl servidor; +</programlisting> + +<para +>y tan pronto como dé a alguien la referencia: </para> + +<programlisting +>string referencia = servidor._toString(); + printf("%s\n",referencia.c_str()); +</programlisting> + +<para +>e ir al ciclo de inactividad de &MCOP;: </para> + +<programlisting +>Dispatcher::the()->run(); +</programlisting> + +<para +>La gente puede acceder a las cosas utilizando: </para> + +<programlisting +>// este código puede ejecutarse en cualquier parte, no necesariamente en el mismo proceso +// (también puede ejecutarse en un ordenador/arquitectura diferente) + + Hola *h = Hola::_fromString([la referencia al objeto impreso anteriormente]); +</programlisting> + +<para +>y llamar a los métodos: </para> + +<programlisting +>if(h) + h->hola("prueba"); + else + printf("¿Falló el acceso?\n"); +</programlisting> + +</sect2> +</sect1> + +<sect1 id="mcop-security"> +<title +>Consideraciones de seguridad de &MCOP;</title> + +<para +>Como los servidores &MCOP; escucharán en un puerto <acronym +>TCP</acronym +>, potencialmente, todo el mundo (si está conectado a Internet) puede intentar conectarse a los servicios &MCOP;. Por esta razón, es importante autentificar a los clientes. &MCOP; utiliza el protocolo md5-auth. </para> + +<para +>El protocolo md5-auth hace lo siguiente para asegurarse que únicamente los clientes seleccionados (de confianza) pueden conectarse al servidor: </para> + +<itemizedlist> +<listitem> +<para +>Asume que da a los clientes una cookie secreta. </para> +</listitem> + +<listitem> +<para +>Cada vez que un cliente se conecta, verifica que este cliente conoce la cookie secreta, sin transferirla (no sea que alguien que esté escuchando el tráfico de la red pueda descubrirla). </para> +</listitem> + +</itemizedlist> + +<para +>Para dar a cada cliente la cookie secreta, &MCOP; la colocará (normalmente) en la carpeta <filename class="directory" +>mcop</filename +> (en <filename class="directory" +>/tmp/mcop-<envar +>USER</envar +>/secret-cookie</filename +>). Por supuesto, puede copiarla a otros ordenadores. Sin embargo, si lo hace, utilice un mecanismo de transferencia segura, como <command +>scp</command +> (en <application +>ssh</application +>). </para> + +<para +>La autentificación de los clientes sigue los siguientes pasos: </para> + +<procedure> +<step> +<para +>[SERVIDOR] genera una cookie nueva (aleatoria) R. </para> +</step> + +<step> +<para +>[SERVIDOR] la envía al cliente. </para> +</step> + +<step> +<para +>[CLIENTE] lee la «cookie secreta» S desde un archivo. </para> +</step> + +<step> +<para +>[CLIENTE] baraja las cookies R y S y las transforma en una cookie barajada M utilizando el algoritmo MD5. </para> +</step> + +<step> +<para +>[CLIENTE] envía M al servidor. </para> +</step> + +<step> +<para +>[SERVIDOR] verifica que las R y S barajadas dan el mismo resultado que la cookie M recibida por el cliente. Si esto es así, la autentificación es correcta. </para> +</step> + +</procedure> + +<para +>Este algoritmo debería ser seguro, debido a: </para> + +<orderedlist> +<listitem> +<para +>Las cookies secretas y la aleatoria son «suficientemente aleatorias». </para> +</listitem> + +<listitem> +<para +>El algoritmo de cálculo de clave MD5 no permite encontrar el «texto original», formado por la cookie S y la cookie aleatoria R (que de cualquier forma es conocida), a partir de la cookie barajada M. </para> +</listitem> +</orderedlist> + +<para +>El protocolo &MCOP; comienza cada conexión nueva con un proceso de autentificación. Básicamente, se parece a esto: </para> + +<procedure> + +<step> +<para +>El servidor envía un mensaje ServerHello, que describe los protocolos de autentificación conocidos. </para> +</step> + +<step> +<para +>El cliente envía un mensaje ClientHello, que incluye información de autentificación. </para> +</step> + +<step> +<para +>El servidor envía un mensage AuthAccept. </para> +</step> +</procedure> + +<para +>Para comprobar como funciona la seguridad, deberíamos echar un vistazo a cómo se procesan los mensajes en las conexiones sin autentificar: </para> + +<itemizedlist> +<listitem> +<para +>Antes de que se produzca la autentificación, el servidor no recibirá otros mensajes de conexión. En su lugar, si el servidor, por ejemplo, espera un mensaje «ClienteHello», y obtiene un mensaje mcopInvocation, cerrará la conexión. </para> +</listitem> + +<listitem> +<para +>Si el cliente no envía un mensaje &MCOP; válido (sin el código especial de &MCOP; en el mensaje de cabecera) en la fase de autentificación, sino otra cosa, la conexión se cerrará. </para> +</listitem> + +<listitem> +<para +>Si el cliente intenta enviar un mensaje extremadamente largo (> 4.096 bytes en la fase de autentificación, el tamaño del mensaje se truncará a 0 bytes, lo que provocará que no sea aceptado para la autentificación). Esto evita que los clientes que no estén autentificados envíen ⪚ 100 megabytes de mensaje, que si se recibieran provocarían que el servidor se quedase sin memoria. </para> +</listitem> + +<listitem> +<para +>Si el cliente envía un mensaje ClientHello corrupto (uno en el que ha fallado la decodificación), la conexión se cierra. </para> +</listitem> + +<listitem> +<para +>Si el cliente no envía nada, finalizará el tiempo de espera (para implementar). </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="mcop-protocol"> +<title +>Especificaciones del protocolo &MCOP;</title> + +<sect2 id="mcop-protocol-intro"> +<title +>Introducción</title> + +<para +>Conceptualmente es similar a <acronym +>CORBA</acronym +>, pero pretende ampliarlo de forma que dé cobertura a las operaciones multimedia en tiempo real. </para> + +<para +>Proporciona un modelo de objeto multimedia, que puede utilizarse por ambos: comunicación entre componentes en un espacio de dirección (un proceso), y entre componentes que están en diferentes hilos, procesos o en diferentes servidores. </para> + +<para +>Todo junto, será diseñado para obtener un rendimiento extremadamente alto (de forma que todo sea optimizado para ser extremadamente rápido), lo que es deseable para las aplicaciones multimedia muy comunicativas. Por ejemplo, la transmisión de vídeos es una de las aplicaciones de &MCOP;, donde la mayoría de las aplicaciones <acronym +>CORBA</acronym +> caerían. </para> + +<para +>Las definiciones de interfaz pueden manejar lo siguiente nativamente: </para> + +<itemizedlist> +<listitem> +<para +>Transmisión contínua de datos (como datos de audio). </para> +</listitem> + +<listitem> +<para +>Transmisión de datos de eventos (como eventos &MIDI;). </para> +</listitem> + +<listitem> +<para +>Cuenta de referencia real. </para> +</listitem> +</itemizedlist> + +<para +>Y los trucos más importantes de <acronym +>CORBA</acronym +>, como: </para> + +<itemizedlist> +<listitem> +<para +>Invocaciones de métodos sícronos. </para> +</listitem> + +<listitem> +<para +>Invocaciones de métodos asíncronos. </para> +</listitem> + +<listitem> +<para +>Construir tipos de datos definidos por el usuario. </para> +</listitem> + +<listitem> +<para +>Herencia múltiple. </para> +</listitem> + +<listitem> +<para +>Pasar referencias de objetos. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="mcop-protocol-marshalling"> +<title +>La codificación del mensaje &MCOP;</title> + +<para +>Diseño de objetivos/ideas: </para> + +<itemizedlist> + +<listitem> +<para +>La codificación debería ser fácil de implementar. </para> +</listitem> + +<listitem> +<para +>La decodificación requiere que el receptor conozca el tipo que desea decodificar. </para> +</listitem> + +<listitem> +<para +>Se espera que el receptor utilice toda la información, por eso, se ignoran los datos del protocolo en la medida que: </para> + +<itemizedlist> +<listitem> +<para +>Si sabe que va a recibir un bloque de bytes, no necesitará buscar en cada byte un marcador. </para> +</listitem> + +<listitem> +<para +>Si sabe que va a recibir una cadena, no necesitará leer hasta encontrar el byte cero para averiguar su tamaño. </para> +</listitem> + +<listitem> +<para +>Sin embargo, si sabe que va a recibir una secuencia de cadenas, necesitará saber la longitud de cada una de ellas para conocer el final de la secuencia, ya que las cadenas tienen longitud variable. Pero si utiliza las cadenas para hacer algo práctico, necesitará hacer esto de todas formas, por ello no se perderá nada. </para> +</listitem> +</itemizedlist> + +</listitem> + +<listitem> +<para +>Uso del sistema lo más pequeña posible. </para> +</listitem> +</itemizedlist> + +<!-- TODO: Make this a table --> + +<para +>La codificación de los diferentes tipos se muestra a continuación: </para> + +<informaltable> +<tgroup cols="3"> +<thead> +<row> +<entry +>Tipo</entry> +<entry +>Proceso de codificación</entry> +<entry +>Resultado</entry> +</row> +</thead> + +<tbody> +<row> +<entry +><type +>void</type +></entry> +<entry +>Los tipo <type +>void</type +> se codifican omitiéndolos, por tanto no se escribe nada en la transmisión para ellos.</entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>long</type +></entry> +<entry +>Se codifica con cuatro bytes, primero el byte más significativo, por eso, el número 10.001.025 (que es 0x989a81) se codificaría como:</entry> +<entry +><literal +>0x00 0x98 0x9a 0x81</literal +></entry> +</row> + +<row> +<entry +><type +>enums</type +></entry> +<entry +><para +>se codifican como los tipos <type +>long</type +>.</para +></entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>byte</type +></entry> +<entry +><para +>Se codifica como un solo byte, por tanto el byte 0x42 se codificaría como:</para +></entry> +<entry +><literal +>0x42</literal +></entry> +</row> + +<row> +<entry +><type +>string</type +></entry> +<entry +><para +>Se codifica como un tipo <type +>long</type +>, conteniendo la longitud de la siguiente cadena, y a continuación la secuencia de caracteres de la cadena finalizando con un byte cero (que se incluye en la longitud).</para> +<important> +<para +>¡incluye el byte 0 para determinar el tamaño!</para> +</important> +<para +>«hola» se codificaría como:</para +></entry> +<entry +><literal +>0x00 0x00 0x00 0x05 0x68 0x6f 0x6c 0x61 0x00</literal +></entry> +</row> + +<row> +<entry +><type +>boolean</type +></entry> +<entry +><para +>Se codifica como un byte, conteniendo 0 si es <returnvalue +>falso</returnvalue +> o 1 si es <returnvalue +>verdadero</returnvalue +>, por ello, el valor lógico <returnvalue +>verdadero</returnvalue +> se codificaría como:</para +></entry> +<entry +><literal +>0x01</literal +></entry> +</row> + +<row> +<entry +><type +>float</type +></entry> +<entry +><para +>Se codifica utilizando las representación IEEE754 de cuatro bytes - el documento que detalla cómo funciona IEEE se encuentra aquí: <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 +> y aquí: <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 +>. Por tanto, el valor 2,15 se codificaría como:</para +></entry> +<entry +><literal +>0x9a 0x99 0x09 0x40</literal +></entry> +</row> + +<row> +<entry +><type +>struct</type +></entry> +<entry +><para +>Una estructura se codifica codificando sus contenidos. No se necesitan prefijos y sufijos adicionales, por ello, la estructura </para> +<programlisting +>struct prueba { + string name; // que es «hola» + long value; // que es 10.001.025 (0x989a81) +}; +</programlisting> +<para +>que se codificaría como</para +></entry> +<entry> +<literallayout +>0x00 0x00 0x00 0x05 0x68 0x6f 0x6c 0x61 +0x00 0x00 0x98 0x9a 0x81 +</literallayout +></entry> +</row> + +<row> +<entry +><type +>sequence</type +></entry> +<entry +><para +>Una secuencia se codifica como una lista de elementos que se siguen, codificándose, por tanto, los elementos uno a uno.</para> +<para +>Por ello una secuencia de 3 longs 'a', con a[0] = 0x12345678, a[1] = 0x01 y a[2] = 0x42 se codificaría como:</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 +>Si necesita hacer referencia a un tipo, todos los tipos primitivos se referencian a través de los nombres anteriores. Las estructuras y enumeraciones tienen sus propios nombres (como Header). Las secuencias se referencian como *<replaceable +>tipo normal</replaceable +>, por tanto una secuencia de longs es «*long» y una secuencia de estructuras Header es «*Header». </para> + +</sect2> + +<sect2 id="mcop-protocol-messages"> +<title +>Mensajes</title> + +<para +>El formato de la cabecera del mensaje &MCOP; está definido por esta estructura: </para> + +<programlisting +>struct Header { + long magic; // el valor 0x4d434f50, que se codifica como MCOP + long messageLength; + long messageType; +}; +</programlisting> + +<para +>Los messsageTypes posibles son actualmente </para> + +<programlisting +>mcopServerHello = 1 +mcopClientHello = 2 +mcopAuthAccept = 3 +mcopInvocation = 4 +mcopReturn = 5 +mcopOnewayInvocation = 6 +</programlisting> + +<para +>Breves notas sobre los mensajes &MCOP;: </para> + + +<itemizedlist> +<listitem> +<para +>Todo mensaje empieza con un Header. </para> +</listitem> + +<listitem> +<para +>Algunos tipos de mensaje deberían ser ignorados por el servidor, en tanto la autentificación no se haya completado. </para> +</listitem> + +<listitem> +<para +>Después de recibir la cabecera, el protocolo (conexión) manejado puede recibir el mensaje completo, sin buscar en el contenido. </para> +</listitem> +</itemizedlist> + +<para +>El messageLength en la cabecera es, por supuesto, en muchos casos redundante, lo que significa que esta aproximación no es minimalista en lo que respecta al número de bytes. </para> + +<para +>Sin embargo, conduce a una implementación sencilla (y rápida) de procesamiento de mensajes no bloqueantes. Con la ayuda de la cabecera, el mensaje puede ser recibido por las clases que manejan el protocolo en segundo plano (no bloqueante), si existen varias conexiones al servidor, todas ellas pueden ser servidas en paralelo. No necesitará ver el contenido del mensaje, para recibirlo (y para determinar cuando ha terminado), solo la cabecera, y el código para realizar ésto es muy sencillo. </para> + +<para +>Una vez que el mensaje se encuentre allí, puede ser decodificado y procesado de una sola pasada, sin preocuparse de que no se hayan recibido todos los datos (puesto que messageLength garantiza que estén todos). </para> + +</sect2> + +<sect2 id="mcop-protocol-invocations"> +<title +>Llamadas</title> + +<para +>Para llamar a un método remoto, necesita enviar la siguiente estructura en el cuerpo de un mensaje &MCOP; con messageType = 1 (mcopInvocation): </para> + +<programlisting +>struct Invocation { + long objectID; + long methodID; + long requestID; +}; +</programlisting> + +<para +>después de esto, enviará el parámetro como estructura, ⪚ si llama el método string concatenar(string s1, string s2), enviará una estructura como: </para> + +<programlisting +>struct InvocationBody { + string s1; + string s2; +}; +</programlisting> + + +<para +>Si el método se declara unidireccional, lo que significa asíncrono, sin devolver código, ésto será todo. En otro caso, recibirá un mensaje de respuesta con messageType = 2 (mcopReturn). </para> + +<programlisting +>struct ReturnCode { + long requestID; + <tipo_devuelto> result; +}; +</programlisting> + + +<para +>donde <tipodevuelto> es el tipo del resultado. Como los tipos void se omiten en la codificación, también podrá escribir el requestID si devuelve algo desde un método void. </para> + +<para +>Por tanto nuestro string concat(string s1, string s2) darían como resultado un código devuelto cómo </para> + +<programlisting +>struct ReturnCode { + long requestID; + string result; +}; +</programlisting> + +</sect2> + +<sect2 id="mcop-protocol-inspecting"> +<title +>Inspección de interfaces</title> + +<para +>Para hacer llamadas, necesitará conocer los métodos que un objeto soporta. Para hacer esto, los métodos methodID 0, 1, 2 y 3 tiene predefinidas ciertas funcionalidades. Esto es </para> + +<programlisting +>long _lookupMethod(MethodDef methodDef); // methodID siempre 0 +string _interfaceName(); // methodID siempre 1 +InterfaceDef _queryInterface(string name); // methodID siempre 2 +TypeDef _queryType(string name); // methodID siempre 3 +</programlisting> + +<para +>para leer esto, por supuesto, también necesitará </para> + +<programlisting +>struct MethodDef { + string methodName; + string type; + long flags; // puesto a 0 por ahora (requerido para la transmisión) + sequence<ParamDef> signature; +}; + +struct ParamDef { + string name; + long typeCode; +}; +</programlisting> + +<para +>El campo 'parameters' contiene los componentes de tipo que especifican el tipo de los parámetros. El tipo del código devuelto se especifica en el campo 'type' de MethodDef. </para> + +<para +>Estrictamente hablando, sólo los métodos <methodname +>_lookMethod()</methodname +> y <methodname +>_interfaceName()</methodname +> son diferentes entre objetos, mientras que <methodname +>_queryInterface()</methodname +> y <methodname +>_queryType()</methodname +> son siempre los mismos. </para> + +<para +>¿Cuáles son estos methodID? si hace una llamada &MCOP;, pasará un número para el método que está llamando. La razón de ésto es que los números se pueden procesar mucho más rápido que las cadenas cuando se ejecuta una petición &MCOP;. </para> + +<para +>¿Cómo obtendrá estos números? Si conoce la firma del método, que es un MethodDef que describe el método, (que contiene el nombre, tipo, nombres de parámetro, tipos de parámetro y otros), puede pasar esto al _lookupMethod del objeto al que desea llamar un método. Como _lookupMethod está preasociado a methodID 0, no debería tener problemas para hacerlo. </para> + +<para +>Por otra parte, sino conoce la firma del método, puede encontrar qué métodos están soportados utilizando _interfaceName, _queryInterface y _queryType. </para> +</sect2> + +<sect2 id="mcop-protocol-typedefs"> +<title +>Definiciones de tipo</title> + +<para +>La definición de los tipos de datos se describen utilizando la estructura <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 +>Por qué &arts; no usa &DCOP;</title> + +<para +>Desde que &kde; abandonó <acronym +>CORBA</acronym +> completamente, y está usando &DCOP; en su lugar, la pregunta natural que surge es por qué &arts; no está haciendo eso. Después de todo, el soporte para &DCOP; está en <classname +>KApplication</classname +>, está bien mantenido, y supuestamente bien integrado con libICE, entre otras cosas. </para> + +<para +>Como habrá (potencialmente) mucha gente preguntando si es realmente necesario usar &MCOP; en lugar de &DCOP; aquí está la respuesta. No me malinterpreten. No estoy intentando decir «&DCOP; es malo». Estoy intentando decir «&DCOP; no es la solución adecuada para &arts;» (mientras que sí lo es para otras muchas cosas). </para> + +<para +>En primer lugar necesita entender para qué fué escrito &DCOP; exactamente. Se creo en dos días durante el encuentro &kde;-TWO, intentó ser tan simple como fuera posible, un protocolo de comunicación realmente «ligero». La implementación descarta de forma especial todo aquello que implique complejidad, por ejemplo, un concepto completo de cómo deberían ser codificados los tipos de datos. </para> + +<para +>Aunque &DCOP; no se ocupa de ciertas cosas (como: ¿cómo envío una cadena de forma transparente por una red?) - ésto es necesario hacerlo. Por lo que, todo lo que &DCOP; no hace, se deja a &Qt; en las aplicaciones &kde; que hoy usan &DCOP;. Éste es el tipo de administración más usado (usando el operador de serialización de &Qt;). </para> + +<para +>Por lo que &DCOP; es un protocolo mínimo que habilita perfectamente a las aplicaciones &kde; para envíar mensajes simples como «abrir una ventana apuntando a http://www.kde.org» o «sus datos de configuración han cambiado». Sin embargo, dentro de &arts; el enfoque se hace en otra dirección. </para> + +<para +>La idea es que las pequeñas extensiones en &arts; se comunicarán tratando algunas estructuras de datos como «eventos midi», «punteros de posicionamiento de canciones» y «diagramas de flujo». </para> + +<para +>Estos son tipos de datos complejos, que deberían ser enviados entre diferentes objetos, y pasados como transmisiones, o parámetros. &MCOP; suple el tipo concepto, para definir tipos de datos complejos a partir de otros más simples (similar a las estructuras o matrices en C++). &DCOP; no se preocupa de los tipos, ya que esto se deja en manos del programador: escribiendo clases C++ para los tipos, y asegurándose de serializarlos correctamente (por ejemplo: soporte para el operador de transmisión de &Qt;). </para> + +<para +>Pero de esta forma, serían inaccesibles a todo lo que no fuera codificación directa C++. Especialmente, no podría diseñar un lenguaje de script, que conociese todos los tipos de extensiones que pudieran estar expuestas, ya que no se describen a sí mismos. </para> + +<para +>El mismo argumento se aplica también a los interfaces. Los objetos &DCOP; no exponen sus relaciones, jerarquía de herencias, etc. Si intentase escribir un navegador de objetos que mostrase «qué atributos tiene este objeto», no podría. </para> + + +<para +>Aunque Matthias me dijo que existía una función «functions» en cada objeto que indicaba los métodos que soporta un objeto, esto dejaría fuera cosas como atributos (propiedades), transmisiones y relaciones de herencia. </para> + +<para +>Esto rompe seriamente aplicaciones como &arts-builder;. Pero recuerde: &DCOP; no pretende ser un modelador de objetos (dado que &Qt; ya tiene alguno como <application +>moc</application +> o otros), o algo parecido a <acronym +>CORBA</acronym +>, pero sí proporcionar comunicación entre aplicaciones. </para> + +<para +>La razón por la que existe &MCOP; es: debería funcionar muy bien con la transmisión entre objetos. &arts; hace uso intensivo de pequeñas extensiones, que se interconecta con las transmisiones. La versión <acronym +>CORBA</acronym +> de &arts; tuvo que introducir una división muy incómoda entre «los objetos SynthModule», que era la forma en que los módulos funcionaban cuando hacían la transmisión, y «el interfaz <acronym +>CORBA</acronym +>», que era algo externo. </para> + +<para +>Gran cantidad de código se preocupaba de la forma de hacer la interacción entre «los objetos SynthModule» y «el interfaz <acronym +>CORBA</acronym +>» de forma natural, pero no lo era, ya que <acronym +>CORBA</acronym +> no sabía nada de transmisiones. &MCOP; sí. Eche un vistazo al código (algo como <filename +>simplesoundserver_impl.cc</filename +>). ¡Mucho mejor! Las transmisiones se pueden declarar en el interfaz de los módulos, y se pueden implementar de forma natural. </para> + +<para +>Nadie lo puede negar. Una de las razones por las que escribí &MCOP; fue la velocidad. Aquí están los argumentos por los que &MCOP; fue definitivamente más rápido que &DCOP; (incluso sin mostrar imágenes). </para> + + +<para +>Una llamada en &MCOP; tendrá una cabecera con seis «long». Esto es: </para> + +<itemizedlist> +<listitem +><para +>Código de «MCOP».</para +></listitem> +<listitem +><para +>Tipo de mensaje (llamada).</para +></listitem> +<listitem +><para +>Tamaño de la solicitud en bytes.</para +></listitem> +<listitem +><para +>ID de la solicitud.</para +></listitem> +<listitem +><para +>ID del objeto objetivo.</para +></listitem> +<listitem +><para +>ID del método objetivo.</para +></listitem> +</itemizedlist> + +<para +>A continuación siguen los parámetros. Tenga en cuenta que la decodificación de esto es extremadamente rápido. Puede utilizar tablas de búsqueda para encontrar el objeto y la función de decodificación del método, lo que significa que la complejidad es O(1) (tardará la misma cantidad de tiempo, independientemente de cuántos objetos estén vivos, o cuántas funciones tengan). </para> + +<para +>Comparando esto con &DCOP;, verá que existen, al menos: </para> + +<itemizedlist> +<listitem +><para +>Una cadena para el objeto de destino - algo como «miCalculadora».</para +></listitem +> +<listitem +><para +>Una cadena como «incluirNumero(int,int)» para especificar el método.</para +></listitem> +<listitem +><para +>Algunos protocolos de información más añadidos por libICE, y otros específicos de DCOP, no lo se.</para +></listitem> +</itemizedlist> + +<para +>Esto es mucho más complicado de decodificar, puesto que necesitará procesar la cadena, buscar la función, &etc;. </para> + +<para +>En &DCOP;, todas las solicitudes se ejecutan a través de un servidor (<application +>DCOPServer</application +>), lo que significa, que el proceso de una invocación síncrona se parece a esto: </para> + +<itemizedlist> +<listitem> +<para +>El proceso cliente envía una llamada. </para> +</listitem> + +<listitem> +<para +>El <application +>DCOPServer</application +> (hombre-en-el-medio) recibe la llamada y mira dónde necesita ir, y la envía al servidor «real». </para> +</listitem +> + +<listitem> +<para +>El proceso servidor recibe la llamada, realiza la petición y envía el resultado. </para> +</listitem> + +<listitem> +<para +>El <application +>DCOPServer</application +> (hombre-en-el-medio) recibe el resultado y ... lo envía al cliente. </para> +</listitem> + +<listitem> +<para +>El cliente descodifica la respuesta. </para> +</listitem> +</itemizedlist> + +<para +>En &MCOP;, la misma llamada se parece a esto: </para> + +<itemizedlist> +<listitem> +<para +>El proceso cliente envía una llamada. </para> +</listitem> + +<listitem> +<para +>El proceso servidor recibe la llamada, realiza la petición y envía el resultado. </para> +</listitem> + +<listitem> +<para +>El cliente descodifica la respuesta. </para> +</listitem> +</itemizedlist> + +<para +>Estando ambos correctamente implementados, la estrategia punto-a-punto de &MCOP; debería ser dos veces más rápida que la estrategia hombre-en-el-medio de &DCOP;. Fíjese que sin embargo que hay por supuesto razones para escojer la estrategia &DCOP;, como por ejemplo: si tiene 20 aplicaciones ejecutándose, y cada aplicación está hablando a cada aplicación, necesitará 20 conexiones con &DCOP;, y 200 con &MCOP;. Sin embargo en el caso multimedia, esto se supone que no es una configuración usual. </para> + +<para +>Intenté comparar &MCOP; y &DCOP;, haciendo una llamada como añadir dos números. Modifique testdcop para conseguir esto. Sin embargo, la prueba no fue lo suficientemente precisa por parte de &DCOP;. Llamé el método en el mismo proceso que hizo la llamada para &DCOP;, y no podrá librarse de un mensaje de depuración, por ello utilicé la redirección de la salida. </para> + +<para +>La prueba solo utilizó un objeto y una función, esperando que los resultados de &DCOP; se redujesen con más objetos y funciones, mientras que los resultados de &MCOP; fueran los mismos. El proceso <application +>dcopserver</application +> tampoco estaba conectada a otras aplicaciones, ya que si estuviera conectado con otras aplicaciones, el rendimiento del enrutado disminuiría. </para> + +<para +>El resultado obtenido fue que mientras con &DCOP; obtuve más de 2.000 llamadas por segundo, con &MCOP; conseguí más de 8.000 llamadas por segundo. Esto da como resultado un factor de 4. Sé que &MCOP; no está afinado al máximo posible todavía (Comparación: <acronym +>CORBA</acronym +>, implementado con mico, hace entre 1.000 y 1.500 llamadas por segundo). </para> + +<para +>Si desea datos más «elaborados», piense en escribir alguna pequeña aplicación a medida para &DCOP; y envíemela. </para> + +<para +><acronym +>CORBA</acronym +> tiene una interesante funcionalidad que permite utilizar objetos que implementó una vez, como «procesos separados del servidor», o como «biblioteca». Puede utilizar el mismo código para hacerlo, y <acronym +>CORBA</acronym +> decidirá hacerlo de forma transparente. Con &DCOP;, no se ha intentado ésto, y está lejos de ser posible realmente. </para> + +<para +>&MCOP; por otra parte debería soportar ésto desde el principio. Por eso podrá ejecutar un efecto dentro de &artsd;. Pero si hace esto con un editor de ondas, podrá seleccionar ejecutar el mismo efecto dentro de su espacio de proceso también. </para> + +<para +>Mientras que &DCOP; no es más que una forma de comunicación entre aplicaciones, &MCOP; es también una forma de comunicarse dentro de las aplicaciones. Esto es especialmente importante para la transmisión multimedia (puede ejecutar múltiples objetos &MCOP; de forma paralela, para resolver una tarea multimedia en su aplicación). </para> + +<para +>Aunque &MCOP; no hace esto actualmente, las posibilidades están abiertas a la implementación de funcionalidades de calidad de servicio. Algo como «este evento &MIDI; es extremadamente importante en comparación con esta llamada». O algo como «necesito llegar puntual». </para> + +<para +>Por otro lado, la transferencia se puede integrar en el protocolo &MCOP; sin problemas, y ser combinada con elementos <acronym +>QoS</acronym +>. Dado que el protocolo puede cambiarse, la transferencia &MCOP; no debería ser tan lenta como la transmisión convencional <acronym +>TCP</acronym +>, pero: es más fácil y consistente de utilizar. </para> + +<para +>No es necesario basar una plataforma multimedia en &Qt;. Una vez decidido ésto, y utilizando la serialización y otras funcionalidades de &Qt;, se podría concluir fácilmente en una plataforma solo-&Qt; (e incluso solo-&kde;). Quiero decir: tan pronto como vea a GNOME utilizando &DCOP;, o quizá algo similar, comprobaré si estaba equivocado. </para> + +<para +>Como &DCOP; no sabe nada sobre los tipos de datos que envía, podría utilizar &DCOP; sin utilizar &Qt;, veamos el uso diario que se hace de &kde;: la gente envía tipos como <classname +>QString</classname +>, <classname +>QRect</classname +>, <classname +>QPixmap</classname +>, <classname +>QCString</classname +>, ..., de un lado para otro. Esto utiliza la serialización &Qt;. Por eso si alguien elige soportar &DCOP; en un programa GNOME, debería utilizar tipos <classname +>QString</classname +>,... (aunque no lo haga de facto), y emular la forma en que &Qt; realiza la transmisión, o podría enviar otros tipos de cadena, imágenes y rectángulos, lo que dejaría de ser interoperativo. </para> + +<para +>Bueno, sea como fuere, &arts; siempre intentó funcionar con o sin &kde;, con o sin &Qt;, con o sin X11, y quizá incluso con o sin &Linux; (y no ha habido problemas con la gente que lo ha portado a un popular sistema operativo no libre). </para> + +<para +>Mi posición es que los componentes no-&GUI; deberían ser escritos independientemente del &GUI;, para que puedan ser compartidos con tantos desarrolladores (u usuarios) como sea posible. </para> + +<para +>Es obvio que la utilización de dos protocolos <acronym +>IPC</acronym +> puede provocar inconvenientes. Incluso más, si ninguno de ellos es estándar. Sin embargo, estas razones no son suficientes para cambiar a &DCOP;. Si existe un interés significativo para encontrar una forma de unir los dos, perfecto, lo intentaremos. Incluso intentaré hacer que &MCOP; hable <acronym +>IIOP</acronym +>, y tendremos un <acronym +>ORB</acronym +> <acronym +>CORBA</acronym +> ;). </para> + +<para +>He hablado con Matthias Ettrich un poquito sobre el futuro de los dos protocolos, y hemos visto como podrían ir las cosas. Por ejemplo, &MCOP; podría manejar la comunicación del mensaje en &DCOP;, colocando los protocolos un poco más juntos entre sí. </para> + +<para +>Se pueden tomar varias soluciones: </para> + +<itemizedlist> +<listitem> +<para +>Escribir una pasarela &MCOP; - &DCOP; (sería posible, y haría posible la interoperatividad). Nota: Si desea trabajar en ello debe tener en cuenta que es un prototipo experimental. </para> +</listitem> + +<listitem> +<para +>Integrar todo lo que los usuarios esperan de &DCOP; en &MCOP;, y utilizar solo &MCOP; - también se podría añadir una «opción-intermedia» a &MCOP; ;). </para> +</listitem> + +<listitem> +<para +>Basar &DCOP; en &MCOP; en lugar de en libICE, y comenzar a integrar lentamente las cosas. </para> +</listitem> +</itemizedlist> + +<para +>Sin embargo, puede no ser la peor posibilidad utilizar cada protocolo para aquello para lo que fue creado (existen grandes diferencias en los objetivos de diseño), y no intentar juntarlos en uno. </para> + +</sect1> +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/midi.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/midi.docbook new file mode 100644 index 00000000000..6ceb60f0aa7 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/midi.docbook @@ -0,0 +1,510 @@ +<!-- <?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 +>Introducción</title> + +<!-- what-to-say-here: aRts has three roles + * moving midi events around between applications + * abstracting the hardware + * synthesizer --> + +<para +>El soporte de &MIDI; en &arts; puede hacer una serie de cosas. La primera de todas, permite la <emphasis +>comunicación</emphasis +> entre diferentes elementos de software que producen o consumen eventos &MIDI;. Si, por ejemplo, usted tiene un secuenciador y un generador de muestras que son compatibles con &arts;, &arts; puede enviar los eventos &MIDI; desde el secuenciador al generador de muestras. </para> + +<para +>Por otro lado, &arts; también puede ayudar a las aplicaciones a <emphasis +>interaccionar con el hardware</emphasis +>. Si un elemento de software (por ejemplo, el generador de muestras) trabaja con &arts;, podrá recibir los eventos &MIDI; desde un teclado externo. </para> + +<para +>Por último, &arts; es un gran <emphasis +>sintetizador modular</emphasis +>. Está diseñado para ser exactamente eso. Así que puede construir instrumentos a partir de pequeños módulos utilizando artsbuilder, y después utilizar esos instrumentos para componer o reproducir música. Síntesis no tiene por qué significar síntesis pura, hay módulos que se pueden utilizar para reproducir muestras. Así que &arts; puede ser un generador de muestras, un sintetizador, etc., y al ser totalmente modular, es muy fácil de extender, muy sencillo para experimentar con él, potente y flexible. </para> +</sect1> + +<sect1 id="midi-manager"> +<title +>El administrador &MIDI;</title> +<!-- what-to-say-here: + * how to use artscontrol - view midimanager + * what does autorestore do? (not yet implemented - so not yet documented) --> + +<para +>El componente central en &arts; que mantiene el registro de qué aplicaciones están conectadas y cómo se deben intercambiar los eventos midi, es el administrador midi. Para verlo o influir en su comportamiento, abra artscontrol. Después seleccione en el menú la opción <menuchoice +><guilabel +>Ver</guilabel +><guilabel +>Administrador MIDI</guilabel +> </menuchoice +>. </para> + +<para +>En la parte izquierda, verá <guilabel +>Entradas MIDI</guilabel +>. En ese lugar se mostrarán todos los objetos que produzcan eventos &MIDI;, como un puerto &MIDI; externo que envía datos a un teclado &MIDI; conectado, un secuenciador que reproduce una canción, etc. En el lado derecho, verá <guilabel +>Salidas MIDI</guilabel +>. En ese recuadro estarán todos los elementos que consumen eventos &MIDI;, como un generador de muestras simulado (por software), o el puerto &MIDI; externo donde se puede conectar un generador de muestras por hardware. Las nuevas aplicaciones como secuenciadores, etc., se registrarán a sí mismas, así que las listas van cambiando con el tiempo. </para> + +<para +>Es posible conectar las entradas con las salidas seleccionando la entrada en la lista izquierda y la salida en la derecha y pulsando sobre el botón <guilabel +>Conectar</guilabel +>. <guilabel +>Desconectar</guilabel +> funciona de la misma manera. Verá las conexiones como pequeñas líneas, entre las entradas y las salidas, en el centro de la ventana. Tenga en cuenta que un mismo origen se puede conectar con varios destinos (y viceversa). </para> + +<para +>Los programas (como el secuenciador Brahms) se añadirán automáticamente al iniciarse y se eliminarán de la lista al cerrarse. Pero también se pueden añadir nuevos elementos utilizando el menú <guilabel +>Añadir</guilabel +>: </para> + +<variablelist> +<varlistentry> +<term +><guimenuitem +>Puerto MIDI del sistema (OSS)</guimenuitem +></term> +<listitem> +<para +>Esto creará un nuevo objeto de &arts; que se comunicará con un puerto midi externo. </para> + +<para +>Como los puertos midi externos pueden tanto enviar como recibir datos, esta opción añadirá una entrada y una salida. Bajo &Linux;, debería tener su tarjeta instalada bajo un controlador <acronym +>OSS</acronym +> (o <acronym +>OSS</acronym +>/Free, que viene incluído en el núcleo de &Linux;) o <acronym +>ALSA</acronym +>, para hacer que funcione. Se le pedirá el nombre del dispositivo. Normalmente será <filename class="devicefile" +>/dev/midi</filename +> o <filename class="devicefile" +>/dev/midi00</filename +>. </para> + +<para +>Sin embargo, si tiene más de un dispositivo &MIDI; o un controlador de retorno de &MIDI; instalado, puede haber más opciones. Para obtener información sobre sus puertos midi, inicie el &kcontrolcenter;, y seleccione <menuchoice +><guilabel +>Información</guilabel +> <guilabel +>Sonido</guilabel +></menuchoice +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Salida de síntesis MIDI de aRts</guimenuitem +></term> +<listitem> +<para +>Esto añadirá una nueva salida &MIDI; a un instrumento de síntesis de &arts;. Si elige el elemento del menú, se abrirá un diálogo que le permitirá escoger un instrumento. Puede crear nuevos instrumentos utilizando artsbuilder. Podrá elegir cualquiera de los archivos <literal role="extension" +>.arts</literal +> cuyo nombre comience por <filename +>instrument_</filename +>. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> + +<sect1 id="brahms"> +<title +>Uso de &arts; y Brahms</title> + +<para +>En realidad, ponerlo en funcionamiento es muy sencillo. Se necesita una versión de &brahms; preparada para &kde; 2.1, que se puede encontrar en el módulo <acronym +>CVS</acronym +> de <literal +>kmusic</literal +>. También hay información de cómo obtener &brahms; en la <ulink url="http://www.arts-project.org/" +>página web de aRts</ulink +>, en la sección de descargas. </para> + +<para +>Al iniciarlo, se mostrará el administrador &MIDI;. Si desea realizar síntesis, añada simplemente un instrumento de síntesis &MIDI; a través de <menuchoice +><guilabel +>Añadir</guilabel +><guilabel +>Salida de síntesis MIDI de aRts</guilabel +></menuchoice +>. </para> + +<para +>Elija un instrumento (por ejemplo, <guilabel +>organ2</guilabel +>). Conéctelos utilizando el botón <guilabel +>Conectar</guilabel +>. Por último, puede comenzar a componer en &brahms;, y la salida será sintetizada por &arts;. </para> + +<para +>En general, es una buena idea mantener la ventana de &artscontrol; abierta, y comprobar que el volumen no es excesivamente alto (la calidad empeora cuando las barras alcanzan el límite superior). Ahora puede comenzar a trabajar en una nueva canción con &arts;, y si ya ha terminado, puede publicarla en la página web 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 +> es una pequeña aplicación que le permite enviar eventos &MIDI; desde la línea de órdenes. Se registrará como un cliente como cualquiera de las otras aplicaciones. La manera más sencilla de utilizarlo es <screen +><prompt +>%</prompt +> <userinput +><command +>midisend</command +> <option +>-f</option +> <parameter +><replaceable +>/dev/midi00</replaceable +></parameter +></userinput +> </screen +> que hará más o menos lo mismo que añadir un puerto &MIDI; del sistema en &artscontrol;. (No del todo, ya que <command +>midisend</command +> sólo envía eventos). La diferencia es que resulta sencillo, por ejemplo, iniciar <command +>midisend</command +> en varios ordenadores (y, de esa manera, utilizar la transparencia de red). </para> + +<para +>También es posible hacer que <command +>midisend</command +> envíe datos desde <filename class="devicefile" +>stdin</filename +>, lo que se puede utilizar para reenviar información desde programas no compatibles con &arts;, de esta manera: <screen +><prompt +>%</prompt +> <userinput +><command +><replaceable +>aplicación_que_produce_eventos_midi_en_stdout</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 +>Construcción de instrumentos</title> + +<para +>La forma en la que &arts; hace síntesis midi es la siguiente: hay unas estructuras que tienen puertos de entrada, de donde se obtiene la frecuencia, la velocidad (volumen) y un parámetro que indica si la nota está aún pulsada. La estructura debe ahora sintetizar exactamente esa nota con ese volumen, y reaccionar en el parámetro de pulsación (donde 'pressed' = 1 significa que el usuario aún mantiene la tecla pulsado y 'pressed' = 0 significa que ya la ha soltado). </para> + +<para +>Cuando lleguen los eventos &MIDI;, &arts; creará nuevas estructuras para las notas según sea vayan necesitando, dándoles los parámetros, y eliminándolas una vez haya terminado su cometido. </para> + +<para +>Para crear un utilizar una de esas estructuras, debe hacer lo siguiente: </para> + +<itemizedlist> +<listitem> +<para +>Para comenzar, la forma más cómoda es abrir <filename +>template_Instrument.arts</filename +> en &arts-builder;. </para> + +<para +>Puede hacerlo usando <menuchoice +><guimenu +>Archivo</guimenu +><guimenuitem +>Abrir ejemplo...</guimenuitem +></menuchoice +> y escogiendo <guimenuitem +>template_Instrument</guimenuitem +> en el selector de archivos. Ésto proporcionará una estructura vacía con los parámetros requeridos, que solo necesitarán «rellenarse». </para> +</listitem> + +<listitem> +<para +>Para procesar la falta de parámetros, es conveniente utilizar Synth_ENVELOPE_ADSR, o, en caso de reproducir alguna onda de percusión, hágalo sin más, ignorando los parámetros que falten. </para> +</listitem> + +<listitem> +<para +>La propia estructura debería indicar cuándo ya no es necesaria a través de la salida «done». Si done vale <returnvalue +>1</returnvalue +>, &arts; asume que se puede borrar la estructura. El envoltorio ADSR proporciona un parámetro que llamado «done», no siendo necesario conectarse a la salida de la estructura. </para> +</listitem> + +<listitem> +<para +>Debe renombrar su estructura a algún nombre que empiece por <filename +>instrument_</filename +>, como <filename +>instrument_piano.arts</filename +>. Debe guardar el archivo bajo el mismo nombre en su carpeta <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +> (que es dónde artsbuilder guarda los archivos normalmente). </para> +</listitem> + +<listitem> +<para +>Finalmente, una vez lo haya guardado será capaz de usarlo con &artscontrol; en el administrador &MIDI;.</para> +</listitem> + +<listitem> +<para +>Oh, y por supuesto su estructura debería reproducir los datos de audio que genera para las salidas izquierda y derecha de la estructura, que se reproducirán entonces a través del administrador de audio (puede verlo en &artscontrol;), por lo que finalmente podrá oírlo (o postprocesarlo con efectos). </para> +</listitem> +</itemizedlist> + +<para +>Un buen método para aprender cómo hacer instrumentos es abrir un instrumento existente a través de <menuchoice +><guilabel +>Archivo</guilabel +><guilabel +>Abrir ejemplo </guilabel +></menuchoice +> y mirar cómo funciona ;) </para> +</sect1> + +<sect1 id="mapped-instruments"> +<title +>Instrumentos mapeados</title> + +<para +>Los instrumentos mapeados son instrumentos que se comportan de forma diferente dependiendo del tono, del programa, del canal o de la velocidad. Puede, por ejemplo, construir un piano de 5 octavas, utilizando una muestra para cada octava (desplazamiento del tono correspondiente). Esto suena mucho mejor que utilizar una única muestra. </para> + +<para +>Puede también construir un mapa de tambores, que reproduce una muestra de tambor específica por cada tecla. </para> + +<para +>Finalmente, es muy útil si coloca varios sonidos en un instrumento mapeado en diferentes programas. De esta manera, puede usar su secuenciador, teclado externo u otra fuente &MIDI; para cambiar entre los sonidos sin tener que tocar &arts; mientras trabaja. </para> + +<para +>Un buen ejemplo de esto es el instrumento <filename +>arts_all</filename +>, que incluye todos los instrumentos que vienen con &arts; en un solo mapa. De esta manera, solo necesita establecerse una vez en &artscontrol; para usar este «instrumento», y así, puede componer una cancion entera en un secuenciador sin preocuparse de &arts;. ¿Necesita otro sonido? Simplemente cambie el programa del secuenciador, y &arts; le dará otro sonido. </para> + +<para +>Crear estos mapas es muy fácil. Sólo necesita crear un archivo de texto y escribir reglas similares a éstas: </para> + +<programlisting +>ON <replaceable +>[ condiciones ...]</replaceable +> DO structure=<replaceable +>estructura</replaceable +>.arts +</programlisting> + +<para +>Las condiciones pueden ser una o más de entre las siguientes: </para> + +<variablelist> + +<varlistentry> +<term +><option +>pitch</option +></term> + +<listitem> +<para +>El tono es lo que se reproduce. Debería utilizar esto si desea dividir su instrumento dependiendo del tono. En nuestros ejemplos iniciales, un piano que usa diferentes muestras para diferentes octavas debería utilizar esta condición. Puede especificar un solo tono, de forma similar a <userinput +><option +>pitch</option +>=<parameter +>62</parameter +></userinput +> o un rango de tonos, como <userinput +><option +>pitch</option +>=<parameter +>60</parameter +>-<parameter +>72</parameter +></userinput +>. Los posibles tonos se encuentran entre <parameter +>0</parameter +> y <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>program</option +></term> +<listitem> +<para +>El programa está activo en el canal al que se envía la nota. Normalmente, los secuenciadores le permiten seleccionar el «instrumento» a través de la configuración del programa. Están permitidos los programas sencillos o los rangos, esto es, <userinput +><option +>program</option +>=<parameter +>3</parameter +></userinput +> o <userinput +><option +>program</option +>=<parameter +>3</parameter +>-<parameter +>6</parameter +></userinput +>. Los posibles programas se encuentran entre <parameter +>0</parameter +> y <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>channel</option +></term> +<listitem> +<para +>El canal al que se enviará la nota. Están permitidos los canales simples o los rangos, esto es <userinput +><option +>channel</option +>=<parameter +>0</parameter +></userinput +> o <userinput +><option +>channel</option +>=<parameter +>0</parameter +>-<parameter +>8</parameter +></userinput +>. Los posibles canales están entre <parameter +>0</parameter +> y <parameter +>15</parameter +>. </para> +</listitem> + +</varlistentry> +<varlistentry> +<term +><option +>velocity</option +></term> +<listitem> +<para +>La velocidad (volumen) que tiene la nota. Se permiten velocidades simples (¿quién querría usar esto?) o los rangos, esto es, <userinput +><option +>velocity</option +>=<parameter +>127</parameter +></userinput +> o <userinput +><option +>velocity</option +>=<parameter +>64</parameter +>-<parameter +>127</parameter +></userinput +>. Las posibles velocidades están entre <parameter +>0</parameter +> y <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Un ejemplo completo de un mapa puede ser (esto aparece en el actual <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 +>Como puede ver, la estructura elegida depende del programa. En el programa 11, podrá ver un «mapa de batería» (con dos entradas), que reproducirá un «bombo» en C-5 (pitch=60), y un «platillo» en C#5 (pitch=61). </para> + +<para +>Para hacer que los archivos de mapa aparezcan automáticamente en &artscontrol; como elección para el instrumento, deben llamarse <filename +>instrument_<replaceable +>algo</replaceable +>.arts-map</filename +> y residir en su carpeta, bajo <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +>, o en la carpeta &kde; bajo <filename class="directory" +>$<envar +>KDEDIR</envar +> usr/local/kde/share/apps/artsbuilder/examples</filename +>. Las estructuras que usa el mapa pueden darse con una ruta absoluta, o con una ruta relativa a la carpeta en la que se encuentra. </para> + +<para +>Extender el mapa arts_all e incluso hacer un mapa completo general de &MIDI; para &arts; es buena idea para hacer &arts; sencillo de utilizar tras instalarlo. Por favor, contribuya creando instrumentos interesantes que puedan ser incluídos en futuras versiones de &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-es/docs/tdemultimedia/artsbuilder/midiintro.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/midiintro.docbook new file mode 100644 index 00000000000..13a1789107c --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Introducción al <acronym +>MIDI</acronym +></title> + +<para +>Pendiente de escribir. </para> + +</appendix> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/modules.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/modules.docbook new file mode 100644 index 00000000000..df80735c1c7 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/modules.docbook @@ -0,0 +1,1317 @@ +<!-- <?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 +>módulos &arts;</title> + + <sect1 id="modules-introduction"> +<title +>Introducción</title> + +<para +>Este capítulo describe todos los módulos estándar de &arts;. Una de las características más potentes de &arts;, es que los módulos se pueden conectar juntos en estructuras para implementar nuevas funciones como efectos e instrumentos. </para> + +<para +>Los módulos se dividen en dos categorías. Los módulos de síntesis se usan para implementar las «tuberías» que manipulan las transmisiones de datos multimedia para añadir nuevos efectos, instrumentos, mezcladores y aplicaciones. Los módulos visuales le permiten proporcionar una interfaz gráfica de usuario para controlar las estructuras de sonido que se construyen con los módulos de síntesis. </para> + +</sect1> + +<sect1 id="synth-modules-reference"> +<title +>Referencia de módulos de síntesis</title> + + +<sect2 id="mcat-synth-arithmetic-mixing"> +<title +>Aritmética + Mezclas</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 +>Añade dos señales. </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 +>Multiplica una señal por un factor. Puede usarlo para reducir señales (0 < factor < 1), aumentarlas (factor > 1) o invertirlas (factor < 0). Fíjese que el factor debe ser una señal y no una constante (⪚ una envoltura o una señal real). </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 +>Divide una señal por un factor. Puede utilizarlo para dividir una señal por otra. O cambia valor1 a 1 y obtendrá un valor recíproco de valor2 como valor de salida. Tenga cuidado de que valor2 nunca alcance 0 o tendrá problemas con las divisiones por cero. </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 +>Añade un número arbitrario de señales. Si necesita sumar las ondas producidas por cuatro osciladores diferentes, puede por ejemplo, conectar todas sus salidas a un módulo Synt_MULTI_ADD. Ésto es más eficiente que usar tres módulos Synth_ADD. </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 +>Cruza dos señales. Si el porcentaje de entrada es -1, sólo se escucha la señal izquierda y si es 1, sólo se escucha la señal derecha. Cuando es 0, ambas señales se escuchan con el mismo volumen. </para> + +<para +>Permite asegurar que su señal permanezca en un rango bien definido. Si tiene dos señales entre -1 y 1 antes del fundido cruzado mantendrán el mismo rango después de él. </para> +</sect3> + +<sect3 id="mref-synth-autopanner-sect"> +<title +>Synth_AUTOPANNER</title> +<anchor id="mref-synth-autopanner"/> + +<para +>Es el opuesto al fundido. Toma una señal mono y la divide en una señal estéreo: Se utiliza para envolver la señal de entrada entre las salidas izquierda y derecha. Esto hace mezclas más animadas. Una aplicación estándar podría ser una guitarra o un sonido brusco. </para> + +<para +>Conecte un <acronym +>LFO</acronym +>, a una onda sinusoidal o de diente de sierra, por ejemplo, 'inlfo', y seleccione una frecuencia ente 0,1 y 5Hz para obtener un efecto tradicional o más para los efectos especiales. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-busses"> +<title +>Buses</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 +>Un enlace de subida para un bus. Proporciona las señales izquierda y derecha, y el nombre del bus en el que los datos deberían ir en el puerto del «bus». La señal combinada de todos los enlaces de subida con este nombre aparecerán en cada enlace de bajada de este «bus». </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 +>Obtiene (la suma de) todos los datos y los coloca en un determinado bus (con el nombre que especificó en el puerto del «bus»). </para> +</sect3> + +</sect2> + +<!-- TODO AFTER KDE2.1: move freeverb into delays, and rename category to + Delays & reverbs --> + +<sect2 id="mcat-synth-delays"> +<title +>Retrasos</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 +>Retrasa la señal entrante durante una cantidad de tiempo. La especificación del tiempo debe estar entre 0 y maxdelay para un retraso entre 0 y maxdelay segundos. </para> + +<para +>Este tipo de retraso <emphasis +>no se utilizará</emphasis +> en estructuras de retroalimentación. Esto es debido a que se trata de una variable de retraso. Puede modificar su longitud mientras se está ejecutando, e incluso asignarle un valor inferior a 0. Pero como en una estructura de retroalimentación la propia salida se necesita para calcular las siguientes muestras, un retraso cuyo valor caiga a cero puede producir una situación de parada. </para> + +<para +>Utilice CDELAY en esta configuración, quizá combinando una pequeña constante de retraso (de 0,001 segundos) con un retraso flexible. </para> + +<para +>También puede combinar CDELAY y un DELAY para conseguir un retraso de tamaño variable con un valor mínimo en un bucle de retroalimentación. Asegúrese de incluir un 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 +>Retrasa la señal de entrada durante una cantidad de tiempo. El tiempo especificado debe ser mayor que 0 para un retraso de 0 segundos o más. El retraso es constante durante los cálculos, lo que significa que no se puede modificar. </para> + +<para +>Esto ahorra tiempo de computación sino se hace ninguna interpolación, y es práctico para estructuras recursivas. Vea la descripción anterior (Synth_DELAY). </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-envelopes"> +<title +>Envoltorios</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 +>Es un envoltorio <acronym +>ADSR</acronym +> clásico lo que significa que puede especificar: </para> + +<variablelist> +<varlistentry> +<term +>active</term> +<listitem> +<para +>Si la nota está siendo pulsada en ese momento por el usuario. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>La señal de entrada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>attack</term> +<listitem> +<para +>El tiempo que debe pasar entre que el usuario presiona una nota y la señal alcanza su máxima amplitud (en segundos). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>decay</term> +<listitem> +<para +>El tiempo que debe pasar entre que la señal alcanza su máxima amplitud y regresa a algún valor constante (en segundos). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>sustain</term> +<listitem> +<para +>El valor constante al que se mantiene la señal más tarde, hasta que el usuario suelte la nota. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>release</term> +<listitem> +<para +>El tiempo que debe pasar entre que el usuario suelta una nota hasta que la señal es reducida hasta cero (en segundos). </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Podrá escalar la señal en el valor de salida. Si el envoltorio <acronym +>ASDR</acronym +> ha finalizado, valdrá 1. Puede utilizar ésto para proporcionar una salida «hecho» para un instrumento (que hará que la estructura del instrumento sea borrada por el enrutador de objetos &MIDI; después de que la fase de inicio haya finalizado). </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 +>El módulo Synth_PSCALE escalará el flujo de audio que se dirige a través de él desde volumen 0 (silencio) a 1 (sonido original) volviendo a 0 (silencio), según la posición (la posición se obtiene desde Synth_SEQUENCE). La posición donde el pico debe ocurrir puede darse como pos. </para> + +<para +>Ejemplo: Estableciendo top a 0,1 significa que después de que se reproduzca el 10% de la nota, el volumen debe alcanzar el máximo y empezar a decaer después. </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-effects"> +<title +>Efectos</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 +>Es un efecto de reverberación. En la implementación actual, está pensado para pasar una señal estéreo a través del reverberador, y que él -añada- su efecto de reverberación a la señal. </para> + +<note> +<para +>Ésto significa que puede usarse dentro de un StereoEffectStack perfectamente. </para> +</note> + +<para +>La señal de entrada debe conectarse a (inleft, inright), y la señal de salida a (outleft, outright). </para> + +<para +>Los parámetros que puede configurar son: </para> + +<variablelist> +<varlistentry> +<term +>roomsize</term> +<listitem> +<para +>El tamaño de la habitación que la reverberación simula (rango: 0..1, donde 1 es la habitación más grande posible). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>damp</term> +<listitem> +<para +>Especifica un filtro que hace que la habitación simulada absorba las altas frecuencias (rango 0..1, donde 1 significa que la absorción de altas frecuencias es más agresiva). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>wet</term> +<listitem> +<para +>La cantidad de señal de reverberación (esto es, la cantidad de señal que debería ser modificada por los filtros, resultando un sonido «mojado», esto es «sonido reverberado»). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>dry</term> +<listitem> +<para +>La cantidad de señal pura pasada, resultando un eco (o combinado con un retraso) más que un efecto de reverberación (rango: 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 +>La cantidad de efecto estéreo que el algoritmo de reverberación añade al efecto de reverberación, haciendo que el sonido tenga un estéreo más amplio (rago:0..1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mode</term> +<listitem> +<para +>[ PENDIENTE: Creo que si el modo es 1, la reverberación mantiene la imagen actual del sonido, mientras que 0 es la operación normal ] </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 +>El módulo trémolo modula la amplitud según una onda <acronym +>LFO</acronym +>. Normalmente usaría una onda sinusoidal, pero, ¿por qué limitarse?. Lo que obtiene es un efecto muy intenso que atraviesa muchos arreglos debido a su rango altamente dinámico. El efecto trémolo es aún uno de los efectos favoritos de los guitarristas, aunque ya no es tan popular como en los años 60. </para> + +<para +>[ PENDIENTE: actualmente está implementado como invalue + abs(inlfo) - quizá tendría más sentido implementarlo como invalue * (1+inlfo*profundidad), donde profundidad sería un parámetro entre 0..1 - a decidir después de &kde;2.1. Si tiene algún comentario, envíe un correo a la lista de &arts; ;).] </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 +>Un flanger es un efecto de retraso de tiempo variable. Este módulo se proporciona para hacer más fácil el desarrollo de complejos efectos flanger, el cual contiene el núcleo de un flanger de un canal. </para> + +<para +>Contiene los siguientes puertos:</para> + +<variablelist> +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>La señal que desea procesar. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>lfo</term> +<listitem> +<para +>Preferiblemente una onda sinusoidal que module el tiempo de retraso dentro del flanger (-1 .. 1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mintime</term> +<listitem> +<para +>El valor mínimo para un retraso dentro de este efecto en milisegundos. Valores sugeridos: intente utilizar valores como 1 ms. Por favor, utilice valores < 1.000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>maxtime</term> +<listitem> +<para +>El valor máximo para un retraso dentro de este efecto en milisegundos. Valores sugeridos: intente utilizar valores como 5 ms. Por favor, utilice valores < 1.000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>outvalue</term> +<listitem> +<para +>La señal de salida. Es importante que mezcle esto con la señal original para obtener el efecto deseado. </para> +</listitem> +</varlistentry> +</variablelist> + +<tip> +<para +>Puede usar esto como base para un efecto de coro. </para> +</tip> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-filters"> +<title +>Filtros</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 +>El efecto pitch shifting (desplazamiento del tono) cambia la frecuencia de la señal de entrada sin afectar a la velocidad. Una aplicación para esto es, por ejemplo, cambiar el tono de su voz mientras lo graba (y reproduce) en tiempo real. </para> + +<para +>El parámetro <emphasis +>speed</emphasis +> es la velocidad relativa con la que la señal se reproducirá. Por lo que una speed de dos haría el sonido dos veces más alto (&ie;, una frecuencia de entrada de 440 Hz daría como resultado una señal de salida de 880 Hz). </para> + +<para +>El parámetro <emphasis +>frequency</emphasis +> se usa internamente para cambiar entre diferentes granos de la señal. Es ajustable, y dependiendo de su elección, el desplazamiento del tono sonará más o menos realista para usar según su caso. Un buen valor para empezar es con algo como 5 ó 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 +>Elimina todas las frecuencias por encima de la frecuencia de corte. </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 +>Este módulo recorta una señal para que se ajuste al rango [-1, 1]. No hace nada para evitar la distorsión que se produce cuando se recortan señales altas. Puede usar ésto como un efecto (por ejemplo, para crear una onda sinusoidal ligeramente cortada). Sin embargo, probablemente sea una buena idea enviar posteriormente la señal a través un filtro de paso bajo, si lo usa, para hacer que suene menos agresivo. </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 +>Este es un interesante bloque de ecualizador parametrizado. Sus parámetros son: </para> + +<variablelist> +<varlistentry> +<term +>invalue, outvalue</term> +<listitem> +<para +>La señal que se filtrará por el ecualizador. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>low</term> +<listitem> +<para +>Cómo se deben cambiar las bajas frecuencias. El valor es en dB, mientras 0 significa no cambiar las bajas frecuencias, -6 significaría reducirlas 6 dB, y +6 significaría aumentarlas 6 dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mid</term> +<listitem> +<para +>Cómo debe cambiar el ecualizador las frecuencias medias, en dB (mirar abajo). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>high</term> +<listitem> +<para +>Cómo debe cambiar el ecualizador las frecuencias altas, en dB (mirar abajo). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>frequency</term> +<listitem> +<para +>Es la frecuencia central del ecualizador en Hz, las frecuencias medias están alrededor de ese espectro, y las bajas y altas frecuencias por debajo y encima. Fíjese que esa frecuencia no puede ser mayor que la mitad que el ratio de muestreo, normalmente en los 22.050 Hz, y tampoco menor que 1 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>q</term> +<listitem> +<para +>Esto influye en la extensión del espectro central. Debería ser un número positivo > 0. Un valor de uno es razonable, valores más altos de q corresponden a valores más estrechos de espectro de frecuencias intermedias. Valores inferiores a uno se corresponden a un espectro amplio. </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 +>Un filtro por resonancia filtra todas las secuencias alrededor de un determinado pico. Ésto no es una forma práctica de especificar frecuencias intermedias (que no se cortará), ya que la entrada son dos constantes externas, f y b. El código es muy antiguo, de los primeros días de los sintetizadores, y probablemente será reemplazado por un filtro nuevo que tenga como parámetros la frecuencia y la resonancia. </para> + +<para +>Pruebe con algo como b=5, f=5 ó b=10, f=10 ó b=15, f=15. </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 +>Filtra todas las frecuencias por encima de la frecuencia de corte (es un filtro de 24db con 4 polos, lo que filtra -24db por octava por encima de la frecuencia de corte), pero ofrece un parámetro adicional para ajustar la resonancia del filtro, de forma que 0 significa sin resonancia y 4 auto-oscilación. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-midi-sequencing"> +<title +>MIDI + Secuenciado</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 +>Este módulo carga la estructura de un instrumento desde un archivo, y se registra a sí mismo como salida midi en el administrador &MIDI; de &arts;. Las notas enviadas a esta salida resultarán en voces del instrumento. </para> + +<note> +<para +>Es más fácil configurar ésto en &artscontrol; que hacerlo manualmente en &arts-builder;. </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 +>Reproducirá una secuencia de notas una y otra vez. Las notas se dan en notación de tracker, y se separan por punto y coma. Un ejemplo es <literal +>A-3;C-4;E-4;C-4</literal +>. La velocidad se da como segundos por nota, por lo que si quiere obtener 120 bpm, especifique algo como 0,5 segundos/nota, ya que 60 segundos/0,5 segundos por nota=120 bpm. </para> + +<para +>Puede dar a cada nota una longitud relativa a la velocidad usando dos puntos después de la nota y después poniendo la longitud. Un ejemplo es <literal +>A-3:2;C-4:0,5;D-4:0,5;E-4;</literal +>. Como puede ver, los programas de composición midi tienden a ser más confortables ;) </para> + +<para +>Synth_SEQUENCE proporciona información adicional sobre la nota que se está reproduciendo en ese momento, donde 0 significa que acaba de empezar y 1 que acabó. Esta información puede ser usada por Synth_PSCALE. </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 +>Este módulo funciona como Synth_SEQUENCE con la única diferencia de que no escribe los nombres de las notas sino las frecuencias. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-samples"> +<title +>Muestras</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 +>Reproducirá un archivo <literal role="extension" +>wav</literal +>. Sólo estará presente si dispone de libaudiofile en su ordenador. El archivo wav empezará tan pronto como el módulo se cree. </para> + +<para +>Parará tan pronto como se termine, entonces finished se establecerá a 1. El parámetro speed puede usarse para reproducir el archivo más rápido o más lento, donde 1 es la velocidad normal (la grabada). </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 +>E/S de sonido</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 +>Normalmente no necesitará este módulo, a menos que esté escribiendo aplicaciones independientes. Normalmente dentro de &artsd;, ya existe un módulo Synth_PLAY, y crear otro no funcionará. </para> +</important> + +<para +>El módulo Synth_PLAY sacará la señal de audio por la tarjeta de sonido. Los canales izquierdo y derecho deben contener la entrada <emphasis +>normalizada</emphasis +> para los canales. Si su entrada no está entre -1 y 1, obtendrá cortes. </para> + +<para +>Como ya se dijo, puede haber solo un módulo Synth_PLAY en uso, ya que este accede directamente a la tarjeta de sonido. Use buses si desea mezclar más de una transmisión antes de la reproducción. Use el módulo Synth_AMAN_PLAY para obtener algo como una salida de audio dentro de &artsd;. </para> + +<para +>Tenga en cuenta que Synth_PLAY también hace la sincronización de la estructura completa. Esto significa: no hay Synth_PLAY = no hay fuente de sincronización = no hay sonido. Por tanto, necesitará (exactamente) un objeto Synth_PLAY. </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 +>Normalmente no necesitará este módulo, a menos que vaya a escribir aplicaciones independientes. Normalmente dentro de artsd, ya existe un módulo Synth_RECORD, y crear otro no funcionará. </para> +</important> + +<para +>El módulo Synth_RECORD grabará una señal desde la tarjeta de sonido. Los canales derecho e izquierdo contendrán la entrada de los canales (entre -1 y 1). </para> + +<para +>Como ya se mencionó, solo se puede utilizar un módulo Synth_RECORD, ya que tiene acceso directo a su tarjeta de sonido. Utilice los buses si desea utilizar la grabación de la transmisión de audio en más de un lugar. Utilice el módulo Synth_AMAN_RECORD para obtener algo parecido a una entrada de artsd. Para que esto funcione, &artsd; debe ejecutarse <emphasis +>con el full duplex activo</emphasis +> (transmisión bidireccional). </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 +>El módulo Synth_AMAN_PLAY sacará su señal de audio. Es mejor (pero no necesario) que saque una señal normalizada (entre -1 y 1). </para> + +<para +>Este módulo usará el administrador de audio para asignar donde se reproducirá la señal. El administrador de audio puede controlarse a través de &artscontrol;. Para hacer más intuitivo su uso, es bueno dar a la señal que reproduce un nombre. Ésto puede hacerse a través de la opción <emphasis +>title</emphasis +>. Otra característica del administrador de audio es el ser capaz de recordar dónde reprodujo una señal la última vez. Para hacerlo necesita ser capaz de distinguir señales. Es por eso por lo que debe asignar un nombre único a <emphasis +>autoRestoreID</emphasis +> también. </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 +>El módulo Synth_AMAN_RECORD grabará una señal de audio desde una fuente externa (&ie;, un micrófono) en &artsd;. La señal será una señal normalizada (entre -1 y 1). </para> + +<para +>Este módulo usará el administrador de audio para asignar donde se reproducirá la señal. El administrador de audio puede controlarse a través de artscontrol. Para hacer más intuitivo su uso, es bueno dar a la señal que reproduce un nombre. Ésto puede hacerse a través de la opción <emphasis +>title</emphasis +>. Otra característica del administrador de audio es el ser capaz de recordar donde grabó una señal la última vez. Para hacerlo necesita ser capaz de distinguir señales. Es por eso por lo que debe asignar un nombre único a <emphasis +>autoRestoreID</emphasis +> también. </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 +>El módulo Synth_CAPTURE escribirá una señal de audio a un archivo wav en su disco duro. El archivo se llamará <filename +>/tmp/mcop-<replaceable +>nombreusuario</replaceable +>/capture.wav</filename +> </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-tests"> +<title +>Pruebas</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 +>No hace nada. Es útil solamente en situaciones de pruebas. </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 +>Puede utilizar esto para la depuración. Se imprimirá el valor de la señal de 'invalue' en intervalos regulares (por ejemplo, 1 por segundo), combinada con el comentario que haya establecido. De esta forma podrá encontrar si algunas señales se encuentran dentro de ciertos rangos, o si están en cualquiera. </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 +>Puede utilizar esto para depurar la forma en que los eventos &MIDI; están llegando a &arts;. </para> + +<para +>Cuando un MIDI_DEBUG está ejecutando &artsserver; imprimirá líneas como: </para> + +<screen +><computeroutput +>201 100753.837585 on 0 42 127</computeroutput +></screen> + +<screen +><computeroutput +>202 101323.128355 off 0 42</computeroutput +></screen> + +<para +>Mientras que la primera línea le dice que 100.753ms (esto es 100 segundos) después de que se inicie el MIDI_DEBUG, llegó un evento al canal 0. Este evento tiene la velocidad (volumen) de 127, la más alta posible. La siguiente línea muestra el evento de liberación del midi. [PENDIENTE: esto no funciona correctamente, hacerlo funcionar, y hacerlo a través del administrador &MIDI; ]. </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 +>Crea una señal con un valor constante. </para> +<!-- TODO: this doesn't really belong in test, does it? --> +</sect3> +</sect2> + +<sect2 id="mcat-synth-osc-mod"> +<title +>Oscilación y modulación</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 +>Todos los osciladores en &arts; no precisan un frecuencia como entrada, pero sí de una posición en la onda. La posición debería estar entre 0 y 1, que se mapeará como un objeto Synth_WAVE_SIN estándar en el intervalo 0..2*pi. Para generar valores de oscilación para un frecuencia se utiliza el módulo Synth_FREQUENCY. </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 +>Esto se utiliza para modular la frecuencia. Coloque su frecuencia en la entrada de frecuencia y coloque otra señal en la entrada modulador. A continuación defina el nivel de modulación (modlevel) a algo similar a 0,3. La frecuencia se modulará con el modulador. Inténtelo. Funciona bien cuando sitúa una retroalimentación en él, lo que significa tener una combinación de señal de salida retrasada respecto a Synth_FM_SOURCE (necesitará colocarlo en algún oscilador de forma que tome el papel de Synth_FREQUENCY) y de alguna otra señal para obtener buenos resultados. </para> + +<para +>Funciona muy bien en combinación con osciladores Synth_WAVE_SIN. </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-waveforms"> +<title +>Formas de onda</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 +>Oscilador sinusoidal. Coloque una señal 'pos' de Synth_FREQUENCY o de Synth_FM_SOURCE en la entrada. Así obtendrá una onda sinusoidal como salida. La señal 'pos' especifica la posición en la onda, el rango 0..1 es mapeado internamente como 0..*pi. </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 +>Oscilador triangular. Coloque una señal 'pos' de Synth_FREQUENCY o de Synth_FM_SOURCE en la entrada. Así obtendrá una onda triangular como salida. La señal 'pos' especifica la posición en la onda, el rango 0..1 se mapeará internamente como 0..2*pi. Tenga cuidado. La señal de entrada <emphasis +>debería</emphasis +> estar en el rango 0..1 para que la señal de salida pueda producir buenos resultados. </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 +>Generador de ruido. Genera una señal aleatoria entre -1 y 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 +>Oscilador de ondas cuadradas. Coloque una señal 'pos' de Synth_FREQUENCY o de Synth_FM_SOURCE en la entrada. Así obtendrá una onda cuadrada como salida. La señal 'pos' especifica la posición en la onda, el rango 0..1 se mapeará internamente como 0..2*pi. Tenga cuidado. La señal de entrada <emphasis +>debería</emphasis +> estar en el rango 0..1 para la señal de salida para producir buenos resultados. </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 +>Oscilador de ondas de diente de sierra. Similar al oscilador Synth_WAVE_TRI. Coloque una señal 'pos' de Synth_FREQUENCY o de Synth_FM_SOURCE en la entrada. Así obtendrá un onda de diente de sierra como salida. La señal 'pos' especifica la posición en la onda, el rango 0..1 se mapeará internamente como 0..2*pi. Tenga cuidado. La señal de entrada <emphasis +>debería</emphasis +> estar en el rango 0..1 para la señal de salida para producir buenos resultados. </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 +>Oscilador de pulso - este modulo es similar en la idea al oscilador rectangular (Synth_WAVE_RECT), pero proporciona un relación configurable del nivel alto/bajo a través del parámetro <emphasis +>dutycycle</emphasis +>. Coloque una señal 'pos' de Synth_FREQUENCY o de Synth_FM_SOURCE en la entrada. Así obtendrá un onda de pulso como salida. La señal 'pos' especifica la posición en la onda, el rango 0..1 se mapeará internamente como 0..2*pi. Tenga cuidado. La señal de entrada <emphasis +>debería</emphasis +> estar en el rango 0..1 para la señal de salida para producir buenos resultados. </para> +</sect3> +</sect2> +<sect2 id="mcat-synth-misc"> +<title +>Varios</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 +>Este módulo reduce el rango dinámico de la señal. Por ejemplo, los compresores son prácticos para compensar las variaciones de amplitud de intensidad cuando alguien habla por el micrófono. </para> + +<para +>Tan pronto como el nivel de entrada exceda un determinado nivel (el umbral) la señal se comprimirá. Simplemente multiplica todo lo que esté por el encima del umbral con el ratio, que debería ser un número entre 0 y 1. Finalmente la señal completa se multiplica por el factor de salida. </para> + +<para +>Los argumentos attack y release retrasa el inicio y el final de la compresión. Use esto si, por ejemplo, aún desea escuchar el ruidoso inicio de una base de tambores. El argumento es en milisegundos y un attack o release de 0ms es posible pero puede producir un ligero ruido. </para> + +</sect3> +</sect2> +</sect1> + +<sect1 id="visual-modules-reference"> +<title +>Referencia de módulos visuales</title> + +<para +>PENDIENTE para cuando los módulos visuales estén más «terminados». </para> +</sect1> + +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/porting.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/porting.docbook new file mode 100644 index 00000000000..0ecbc29d67b --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/porting.docbook @@ -0,0 +1,52 @@ +<!-- <?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 +>Portando aplicaciones a &arts;</title> + +<sect1 id="using-artsdsp"> +<title +>Utilizando &artsdsp;</title> + +<para +>La utilidad &artsdsp;, <link linkend="artsdsp" +>descrita con anterioridad</link +>, permite que la mayoría de aplicaciones antiguas que trabajan directamente sobre los dispositivos de audio, funcionen correctamente con &arts;. Las aplicaciones escritas para utilizar el Enlightenment Sound Daemon (<application +>esd</application +>) también funcionarán en la mayoría de casos ejecutando <application +>esd</application +> sobre &artsdsp;. </para> + +<para +>Esto ofrece una buena solución a corto plazo para portar aplicaciones existentes a &kde;. Sin embargo, no permite que la aplicación utilice todas las posibilidades de &arts;, tales como el uso de módulos y transmisiones multimedia que no sean de audio digital. Si la aplicación va más allá de ejecutar archivos de audio, es lógico añadir soporte nativo para &arts; a la aplicación. </para> + +<para +>Utilizar &arts; también significa que la aplicación no tiene mucho trabajo que hacer, ya que puede utilizar las funciones de &arts; para manejar codecs y diferentes tipos de medios, así como tener control sobre el hardware de sonido. </para> + +</sect1> + +<sect1 id="adding-native-arts-support"> +<title +>Añadiendo soporte nativo para &arts;</title> + +<para +>Al utilizar &arts; se encontrará con diferentes <link linkend="arts-apis" +><acronym +>API</acronym +>s</link +> para escoger. La decisión sobre cual utilizar depende de una serie de factores, incluyendo el tipo de medio que se utilizará (sonido, &MIDI;, &CD; audio, &etc;), las características requeridas a la <acronym +>API</acronym +>, y si se está programando en C++. En la mayoría de los casos la elección debería ser relativamente obvia en base a las necesidades. </para> + +<para +>En los casos de portabilidad entre plataformas, las aplicaciones que deban poderse ejecutar en plataformas diferentes al &kde;, no pueden depender de que &arts; esté presente. Un buen método para adaptarse a diferentes ambientes multimedia es el uso de conectores. Si además la <acronym +>API</acronym +> de los conectores es abierta y está bien documentada permitiremos que otras personas diferentes al desarrollador de la aplicación puedan implementar un conector para &arts;. </para> + +</sect1> + +</chapter> + diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/references.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/references.docbook new file mode 100644 index 00000000000..0c4b232fffc --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/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 +>Referencias</title> + +<variablelist> + +<varlistentry> +<term +><ulink +url="http://multimedia.kde.org" +>http://multimedia.kde.org</ulink +></term> +<listitem> +<para +>Esta es la principal página web sobre información relacionada con &kde; y multimedia. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><ulink +url="http://www.arts-project.org" +>http://www.arts-project.org</ulink +></term> +<listitem> +<para +>Es la página web del proyecto &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>&kde; 2.0 Development</term> +<listitem> +<para +>El capítulo 14 de este libro publicado trata sobre multimedia, incluyendo &arts;. Esta disponible impreso o en línea con anotaciones desde <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 +>Esta web tiene una extensa lista de aplicaciones de sonido y &MIDI; para &Linux;. </para> +</listitem> +</varlistentry> + +</variablelist> + +</chapter> diff --git a/tde-i18n-es/docs/tdemultimedia/artsbuilder/tools.docbook b/tde-i18n-es/docs/tdemultimedia/artsbuilder/tools.docbook new file mode 100644 index 00000000000..7f370c76c75 --- /dev/null +++ b/tde-i18n-es/docs/tdemultimedia/artsbuilder/tools.docbook @@ -0,0 +1,1003 @@ +<!-- +<?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 +>Herramientas &arts;</title> + +<para +>Incluídas con &arts; son una serie de utilidades para controlar y configurar su comportamiento. Necesita estar algo familiarizado con muchas de estas herramientas para usar &arts; de forma efectiva. Esta sección describe cada utilidad y sus opciones para las órdenes. </para> + +<sect1 id="kde-control-center"> +<title +>&kcontrol;</title> + +<para +>Cuando ejecuta &arts; bajo &kde;, el &kcontrolcenter; provee un grupo de opciones en el panel de control bajo la categoría <guilabel +>Sistema de sonido</guilabel +>. Algunas de estas opciones las usa &arts;. Puede también asociar sonidos con varios eventos del administrador de ventanas y &kde; usando el panel <menuchoice +><guilabel +>Sonidos y multimedia</guilabel +><guilabel +>Notificaciones de sistema</guilabel +> </menuchoice +>. Consulte el manual de &kcontrol; para obtener información sobre el manejo de las opciones del panel. </para> + +</sect1> + +<sect1 id="artsd"> +<title +>&artsd;</title> + +<para +>El acceso a los recursos del hardware de sonido es controlado por &artsd;, el demonio de &arts;. Ésto permite a aplicaciones diferentes enviar solicitudes simultáneas al servidor, donde pueden ser mezcladas y reproducidas. Sin un servidor de sonido centralizado una aplicación usando un dispositivo de sonido podría hacer que otras aplicaciones no lo pudieran usar. </para> + +<para +>Para usar &arts; tiene que haber una y solo una copia de &artsd; ejecutándose. Se ejecuta normalmente cuando &kde; se inicia si está activado en el panel de &kcontrol; el <guilabel +>Servidor de sonido</guilabel +> </para> + +<para +>El programa acepta los siguientes argumentos:</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 +>método de audio </replaceable +></option +> <option +>-r <replaceable +>ratio de muestreo </replaceable +></option +> <option +>-b <replaceable +>bits </replaceable +></option +> <option +>-d </option +> <option +>-D <replaceable +>nombre de dispositivo </replaceable +></option +> <option +>-F <replaceable +>fragmentos </replaceable +></option +> <option +>-S <replaceable +>tamaño </replaceable +></option +> <option +>-s <replaceable +>segundos </replaceable +></option +> <option +>-m <replaceable +>nombre aplicación </replaceable +></option +> </group +> <group choice="opt" +> <option +>-h</option +> <option +>-A</option +> <option +>-v</option +> <option +>-l <replaceable +>nivel </replaceable +></option +> </group +> </cmdsynopsis> + +<variablelist +><varlistentry> +<term +><option +>-r <replaceable +>ratio de muestreo</replaceable +></option +></term> +<listitem> +<para +>Establece el ratio de muestreo a usar.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Muestra la utilización de la orden.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-n</option +></term> +<listitem> +<para +>Habilita la transparencia de red.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-p <replaceable +>puerto</replaceable +></option> +</term> +<listitem> +<para +>Establece el puerto <acronym +>TCP</acronym +> a usar (implica <option +>-n</option +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-u</option +></term> +<listitem> +<para +>Público, sin autentificación (peligroso).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-d</option +></term> +<listitem> +<para +>Habilita operaciones en ambas direcciones (full duplex).</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-D <replaceable +>nombre de dispositivo</replaceable +></option +></term> +<listitem> +<para +>Especifica el dispositivo de audio (normalmente <filename +>/dev/dsp</filename +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-F <replaceable +>fragmentos</replaceable +></option +></term> +<listitem> +<para +>Establece el número de fragmentos.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-S <replaceable +>tamaño</replaceable +></option +></term> +<listitem> +<para +>Establece el tamaño de los fragmentos, en bytes.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-s <replaceable +>segundos</replaceable +></option +></term> +<listitem> +<para +>Establece el tiempo de autosuspensión en segundos. El valor cero desactiva la autosuspensión.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m <replaceable +>nombre applicación</replaceable +></option +></term> +<listitem> +<para +>Especifica el nombre de la aplicación que se usará para mostrar errores, avisos y mensajes de información. Si está ejecutando KDE puede usar la utilidad <application +>artsmessage</application +> para ésto.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-N</option +></term> +<listitem> +<para +>Incrementa el tamaño de la memoria de intercambio de red a un valor adecuado para ejecutarse sobre una LAN a 10 mbps. Es equivalente a usar la opción -w 5 (ver a continuación). </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-w <replaceable +>n</replaceable +></option +></term> +<listitem> +<para +>Cuando ejecute <application +>artsd</application +> a través de una conexión de red a otro servidor, normalmente querrá utilizar un tamaño de memoria de intercambio más grande para evitar pérdidas. ARts proporciona aplicaciones con un tamaño de memoria de intercambio mínimo sugerido. Sin esta opción, el tamaño predeterminado está basado en el tamaño del fragmento * número de fragmento. Utilizar esta opción puede incrementar el tamaño predeterminado con un factor <replaceable +>n</replaceable +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-l <replaceable +>nivel</replaceable +></option +></term> +<listitem> +<para +>Establece el nivel de información: 3 (silencio), 2 (avisos), 1 (información) ó 0 (depuración).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +></term> +<listitem> +<para +>Muestra el nivel de la versión.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>En la mayoría de los casos con ejecutar &artsd; será suficiente. </para> +</sect1> + +<sect1 id="artswrapper"> +<title +>&artswrapper;</title> + +<para +>Para proveer una buena respuesta en tiempo real, &artsd; se ejecuta normalmente como un proceso en tiempo real (en plataformas en las que se soportan prioridades en tiempo real). Ésto requiere permisos de <systemitem class="username" +>root</systemitem +>, por lo que para minimizar las implicaciones de seguridad, &artsd; puede iniciarse usando un pequeño programa &artswrapper; el cual simplemente establece prioridad en tiempo real (ejecutándose como <systemitem class="username" +>root</systemitem +>) y después arranca &artsd; como un usuario no <systemitem class="username" +>root</systemitem +>. </para> + +<para +>Si hace artswrapper SUID <systemitem class="username" +>root</systemitem +>, probablemente mejorará la calidad de su reproductor de audio reduciendo los saltos en la música. Sin embargo, también incrementará el riesgo de fallos en el código o de que un usuario malicioso pueda colgar o perjudicar su máquina. Además, en las máquinas multiusuario, priorizar el audio de alta calidad puede dar como resultado un menor rendimiento para los usuarios que intentan hacer «productivo» el uso de la máquina.</para> + +</sect1> + +<sect1 id="artsshell"> +<title +>&artsshell;</title> + +<para +>El orden &artsshell; se ideó como una utilidad para realizar varias funciones relacionadas con el servidor de sonido. Se espera que la utilidad se extienda con nuevas órdenes en el futuro (consulte los comentarios del código fuente para ver algunas ideas). </para> + +<para +>La orden tiene el siguiente formato: </para> + +<!-- LW: FIX THIS --> + +<cmdsynopsis +><command +>artsshell</command +> <group +> <arg +>suspend</arg +><arg +>status</arg +> <arg +>terminate</arg +> <arg +>autosuspend <replaceable +>segundos</replaceable +></arg +> <arg +>networkbuffers <replaceable +>n</replaceable +></arg +> <arg +>volume [<replaceable +>volumen</replaceable +>]</arg +> <arg +>stereoeffect <replaceable +>opciones</replaceable +></arg +> </group +> <group +> <option +>-h</option +> <option +>-q</option +> </group +> </cmdsynopsis> + +<para +>artsshell [opciones] <replaceable +>orden</replaceable +> [<replaceable +>opciones de la orden</replaceable +>] </para> + +<para +>Están soportadas las siguientes opciones: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-q</option +></term> +<listitem> +<para +>Suprime todas las salidas.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Muestra la utilización de la orden.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Están soportadas las siguientes órdenes:</para> + +<variablelist> + +<varlistentry> +<term +><option +>suspend</option +></term> +<listitem> +<para +>Suspende el servidor de sonido. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>status</option +></term> +<listitem> +<para +>Muestra información del estado del servidor de sonido.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>terminate</option +></term> +<listitem> +<para +>Finalizar el servidor de sonido. Ésto puede confundir y/o colgar aplicaciones que se estén usando en ese momento. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>autosuspend</option +> <parameter +>segundos</parameter +></term> +<listitem> +<para +>Establece el tiempo de autosuspensión en el número especificado de segundos. El servidor de sonido se suspenderá asimismo si está ocioso durante ese periodo de tiempo. El valor cero desactiva la autosuspensión. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>networkbuffers</option +> <parameter +>n</parameter +></term> +<listitem> +<para +>Establece el tamaño de la memoria de intercambio de red a un factor <parameter +>n</parameter +> veces el tamaño predeterminado. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>volume</option +> [<replaceable +>volumen</replaceable +>]</term> +<listitem> +<para +>Establece el nivel de volumen para la salida de audio del servidor de sonido. El argumento <replaceable +>volumen</replaceable +> es un valor de coma flotante. Si no se añaden argumentos se muestra el volumen actual. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect list</option +></term> +<listitem> +<para +>Lista todos los módulos de efectos estéreo disponibles.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect insert [top|bottom]</option +> <replaceable +>nombre</replaceable +></term> +<listitem> +<para +>Inserta un efecto estéreo en la pila de efectos estéreo. Devuelve un identificador que puede usarse después para borrarlo. Puede instalarse en la parte superior o en la inferior (predeterminado).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect remove</option +> <replaceable +>id</replaceable +></term> +<listitem> +<para +>Quita el efecto estéreo con identificador <replaceable +>id</replaceable +> de la pila de efectos.</para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsplay"> +<title +><application +>artsplay</application +></title> + +<para +>La orden <application +>artsplay</application +> es una utilidad para reproducir un archivo de sonido. Acepta un solo argumento correspondiente al nombre del archivo de sonido que será enviado al servidor de sonido para ser reproducido. El archivo de sonido puede ser de alguno de los tipos de archivo de sonido comunes <literal role="extension" +>wav</literal +> o <literal role="extension" +>au</literal +>. Ésta utilidad es buena para comprobar si el servidor de sonido está funcionando. Ejecutando dos órdenes en paralelo o en una rápida sucesión puede demostrar cómo el servidor de sonido combina más de una fuente de sonido.</para> + +</sect1> + +<sect1 id="artsdsp"> +<title +><application +>artsdsp</application +></title> + +<para +>El servidor de sonido solo soporta aplicaciones que soporten &arts;. Algunas aplicaciones heredadas querrán acceder al dispositivo de sonido directamente. La orden &artsdsp; proporciona una solución provisional que permite a la mayor parte de estas aplicaciones ejecutarse sin cambios. </para> + +<para +>Cuando una aplicación se ejecuta bajo &artsdsp; todos los accesos al dispositivo de audio <filename class="devicefile" +>/dev/dsp</filename +> son interceptados y mapeados dentro de las llamadas al <acronym +>API</acronym +> de &arts;. A pesar de que la emulación del dispositivo no es muy buena, muchas aplicaciones funcionan de este modo, aunque con alguna degradación en la ejecución y la latencia. </para> + +<para +>La orden &artsdsp; sigue el siguiente formato: </para> + +<!-- LW: FIX THIS --> +<para +>artsdsp [<replaceable +>opciones</replaceable +>] <replaceable +>argumentos de la aplicación</replaceable +> </para> + +<para +>Se reconocen las siguientes opciones: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-h</option +>, <option +>--help</option +></term> +<listitem> +<para +>Muestra un mensaje de ayuda.</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-n</option +> <option +>--name</option +> = <replaceable +>nombre</replaceable +></term> +<listitem> +<para +>Usa <replaceable +>nombre</replaceable +> para identificar un reproductor en <command +>artsd</command +>.</para> + +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m</option +> <option +>--mmap</option +></term> +<listitem> +<para +>Emula el mapeo de memoria (⪚ para <application +>Quake</application +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +> <option +>--verbose</option +></term> +<listitem> +<para +>Muestra los parámetros.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Una llamada típica es: </para> + +<para> +<userinput +><command +>artsdsp</command +> <option +>-v</option +> <option +>-m</option +> <parameter +>realplay <replaceable +>cancion.mp3</replaceable +></parameter +></userinput> +</para> + +<para +>Algunas aplicaciones funcionan mejor con la opcion <option +>--mmap</option +>. No todas las características del dispositivo de sonido son totalmente emuladas, pero muchas aplicaciones deberían funcionar. Si encuentra una que no lo hace, envíe un detallado informe del fallo y los desarrolladores intentarán arreglarlo. De nuevo, recuerde que ésta es una solución provisional y algo fea. La mejor solución es añadir soporte nativo para &arts; en las aplicaciones. Si su aplicación favorita de sonido no tiene soporte para &arts; pregunte a sus desarrolladores para proveérselo. </para> + +</sect1> + +<sect1 id="artscat"> +<title +><application +>artscat</application +></title> + +<para +>Es una simple utilidad para enviar datos de audio puros al servidor de sonido. Necesita especificar el formato de los datos (ratio de muestreo, tamaño de muestra y número de canales). Probablemente sea una utilidad que no usará a menudo, pero puede ser útil para hacer pruebas. La sintaxis de la orden es: </para> + +<!-- LW: FIX THIS --> + +<para +>artscat [ <replaceable +>opciones</replaceable +> ] [ <replaceable +>nombre de archivo</replaceable +> ] </para> + +<para +>Si no se especifica un nombre de archivo, lee la entrada estándar. Están soportadas las siguientes opciones: </para> + +<variablelist> +<varlistentry> +<term +><option +>-r</option +> <parameter +>ratio de muestreo</parameter +></term> +<listitem> +<para +>Establece el ratio de muestreo a usar. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-b</option +> <parameter +>bits</parameter +></term> +<listitem> +<para +>Establece el tamaño de muestra a usar (8 o 16). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-c</option +> <parameter +>canales</parameter +></term> +<listitem> +<para +>Establece el número de canales (1 ó 2). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Muestra el uso de la orden y sale. </para> +</listitem> +</varlistentry> + +</variablelist> +</sect1> + +<sect1 id="artscontrol"> +<title +>&artscontrol;</title> + +<para +>Ésta es una aplicación gráfica para realizar una serie de tareas relacionadas con el servidor de sonido. La ventana predeterminada muestra dos indicadores de volumen y un deslizador para controlar este volumen. Desde el menú <guimenu +>Ver</guimenu +> puede seleccionar otras funciones: </para> + +<variablelist> + +<varlistentry> +<term +><guimenuitem +>Campo FFT</guimenuitem +></term> +<listitem> +<para +>Abre una ventana que muestra una pantalla con un analizador de espectro en tiempo real. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Administrador de audio</guimenuitem +></term> +<listitem> +<para +>Muestra las fuentes de sonido activas y le permite conectarlas a alguno de los buses disponibles. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Estado de aRTs</guimenuitem +></term> +<listitem> +<para +>Muestra si el servidor de sonido se está ejecutando y si trabaja en tiempo real. Indica si el servidor será autosuspendido y permite suspenderlo automáticamente. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Administrador midi</guimenuitem +></term> +<listitem> +<para +>Muestra entradas y salidas &MIDI; activas y le permite realizar conexiones [PENDIENTE: ¿No funciona todavía? Necesita más detalles]. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>FreeVerb</guimenuitem +></term> +<listitem> +<para +>Conecta el efecto de reverberación FreeVerb a la pila de efectos de salida de &arts; y le permite controlar los parámetros del efecto gráficamente. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Pantalla de volumen estilo led</guimenuitem +></term> +<listitem> +<para +>Cambia el indicador de volumen de la ventana principal para usar una pantalla con formato de <acronym +>LED</acronym +> en lugar de una barra de progreso. </para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsc-config"> +<title +><application +>artsc-config</application +></title> + +<para +>Ésta es una utilidad para ayudar a los desarrolladores utilizando el <acronym +>API</acronym +> C de &arts;. Da como resultado la salida apropiada para el compilador así como las opciones necesarias cuando se compila y enlaza código con &arts;. Se pretende que sea utilizado sin archivos para ayudar a la portabilidad. La orden acepta tres opciones: </para> + +<variablelist> +<varlistentry> +<term +><option +>--cflags</option +></term> +<listitem> +<para +>Muestra los indicadores del compilador cuando se compila con la <acronym +>API</acronym +> C de &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>--libs</option +></term> +<listitem> +<para +>Muestra los indicadores del enlazador necesarios cuando se enlaza con la <acronym +>API</acronym +> C de &arts;. </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><acronym +>--version</acronym +></term> +<listitem> +<para +>Muestra la versión de la orden <command +>artsc-config</command +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>La respuesta usual de la orden se muestra a continuación:</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 +>Puede usar esta utilidad para crear un archivo utilizando una regla como: </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 +>La utilidad &mcopidl; es el compilador de archivos &IDL; para &MCOP;, el Protocolo de Comunicación Multimedia usado por &arts;. Las interfaces en &arts; se definen en &IDL;, un lenguaje independiente, Lenguaje de Definición de Interfaces. La utilidad &mcopidl; acepta un archivo &IDL; como entrada y genera archivos cabecera y fuente en C++ para una clase, implementando la interfaz. La orden utiliza la siguiente sintaxis: </para> + +<!-- LW: FIX THIS --> + +<para +>mcopidl [ <replaceable +>opciones</replaceable +> ] <replaceable +>nombrearchivo</replaceable +> </para> + +<para +>Las opciones válidas son:</para> +<variablelist> +<varlistentry> +<term +><option +>-I</option +> <parameter +>directorio</parameter +></term> +<listitem> +<para +>Busca cabeceras en el <parameter +>directorio</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-e</option +> <parameter +>nombre</parameter +></term> +<listitem> +<para +>Excluye el nombre de una estructura, interfaz o tipo enum durante la generación del código. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-t</option +></term> +<listitem> +<para +>También crea archivos <literal role="extension" +>.mcoptype</literal +>/<literal role="extension" +>.mcopclass</literal +> con información de tipo para el archivo &IDL;. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Puede encontrar más información sobre &MCOP; e &IDL; en la sección <link linkend="interfaces" +>Interfaces e &IDL;</link +>. </para> + +</sect1> + +</chapter> |
