diff options
| author | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-12-03 11:05:10 -0600 |
|---|---|---|
| committer | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-12-03 11:05:10 -0600 |
| commit | f7e7a923aca8be643f9ae6f7252f9fb27b3d2c3b (patch) | |
| tree | 1f78ef53b206c6b4e4efc88c4849aa9f686a094d /tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder | |
| parent | 85ca18776aa487b06b9d5ab7459b8f837ba637f3 (diff) | |
| download | tde-i18n-f7e7a923aca8be643f9ae6f7252f9fb27b3d2c3b.tar.gz tde-i18n-f7e7a923aca8be643f9ae6f7252f9fb27b3d2c3b.zip | |
Second part of prior commit
Diffstat (limited to 'tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder')
17 files changed, 10455 insertions, 0 deletions
diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/Makefile.am b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/Makefile.am new file mode 100644 index 00000000000..babf802f3a2 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/Makefile.am @@ -0,0 +1,4 @@ +KDE_LANG = pt_BR +SUBDIRS = $(AUTODIRS) +KDE_DOCS = AUTO +KDE_MANS = AUTO diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/Makefile.in b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/Makefile.in new file mode 100644 index 00000000000..5becf8a5926 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/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 +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 = pt_BR +#>- SUBDIRS = $(AUTODIRS) +#>+ 1 +SUBDIRS =. +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-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=future.docbook porting.docbook glossary.docbook helping.docbook artsbuilder.docbook detail.docbook midiintro.docbook modules.docbook mcop.docbook faq.docbook midi.docbook tools.docbook Makefile.in digitalaudio.docbook references.docbook apis.docbook Makefile.am + +#>+ 2 +docs-am: glossary.docbook porting.docbook apis.docbook references.docbook mcop.docbook detail.docbook future.docbook artsbuilder.docbook digitalaudio.docbook faq.docbook modules.docbook tools.docbook midi.docbook helping.docbook midiintro.docbook + +#>+ 13 +install-nls: + $(mkinstalldirs) $(DESTDIR)$(kde_htmldir)/$(KDE_LANG)/artsbuilder + @for base in glossary.docbook porting.docbook apis.docbook references.docbook mcop.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 glossary.docbook porting.docbook apis.docbook references.docbook mcop.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 glossary.docbook porting.docbook apis.docbook references.docbook mcop.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-pt_BR/docs/tdemultimedia/artsbuilder/apis.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/apis.docbook new file mode 100644 index 00000000000..9e5d2b9c8d0 --- /dev/null +++ b/tde-i18n-pt_BR/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 Programação de Aplicativos do &arts;</title> + +<sect1 id="api-overview"> +<title +>Visão Geral</title> +<para +>O aRts não é somente uma peça de software, ele também fornece uma variedade de APIs para uma variedade de propósitos. Nesta seção, eu tentarei descrevê-las de uma maneira geral, com uma olhada sumária do que as APIs supostamente fazem, e como elas interagem. </para> + +<para +>Existe uma importante distinção a fazer: a maioria das APIs são <emphasis +>independentes de localização e linguagem</emphasis +> porque elas são especificadas como <emphasis +>mcopidl</emphasis +>. Por isto, você pode basicamente usar os serviços que elas oferecem a partir de qualquer linguagem, implementá-las em qualquer linguagem, e não precisa preocupar-se se está lidando com objetos locais ou remotos. Aqui está uma lista das principais: </para> + + +<variablelist> +<varlistentry> +<term +>core.idl</term> + <listitem +><para +>Definições básicas que formam o núcleo da funcionalidade MCOP, como o próprio protocolo, definições de objeto, o negociador, o sistema de fluxo e assim por diante. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsflow.idl</term> + + <listitem +><para +>Ela contém o sistema de fluxo que você usará para conectar-se com fluxos de áudio, a definição do <emphasis +>Arts::SynthModule</emphasis +> que é a base para qualquer interface que possui fluxos, e finalmente alguns objetos de áudio úteis. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>kmedia2.idl</term> + + + <listitem +><para +>Aqui, um objeto que pode tocar uma mídia (<emphasis +>Arts::PlayObject</emphasis +>) é definido. Tocadores de mídia como o noatun do KDE será capaz de tocar qualquer mídia para a qual um PlayObject pode ser encontrado. Assim faz sentido implementar PlayObjects para vários formatos (como mp3, vídeo mpg, midi, wav, ...) desta base, e muitos já estão prontos. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>soundserver.idl</term> + + <listitem +><para +>Aqui, uma interface para o amplo sistema do servidor de som artsd é definida. A interface é chamada <emphasis +>Arts::SoundServer</emphasis +>, e implemente funcionalidades como aceitar fulxos a partir da rede, executar amostras, criar outros objetos personalizados do aRts e assim por diante. A transparência de rede é implícita devido ao uso do MCOP (como para todas as demais interfaces daqui). </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsbuilder.idl</term> + <listitem +><para +>Este módulo define a funcionalidade básica de gráfico de fluxo, que é, combinando objetos simples para mais complexos, definir um gráfico deles. Isto define a interface básica <emphasis +>Arts::StructureDesc</emphasis +>, <emphasis +>Arts::ModuleDesc</emphasis +> e <emphasis +>Arts::PortDesc</emphasis +> que contém uma descrição de uma estrutura, módulo e porta. Existe também uma maneira de obter "objetos da rede" fora desta conexão e descrições de valores, usando uma fabricação. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmidi.idl</term> + + <listitem +><para +>Este módulo define a funcionalidade midi básica, como objetos que produzem eventos midi, o que é um evento midi, um <emphasis +>Arts::MidiManager</emphasis +> para conectar os produtores e consumidores de eventos midi, e assim por diante. Como sempre a transparência de rede está implícita. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsmodules.idl</term> + <listitem +><para +>Aqui estão vários filtros adicionais, osciladores, efeitos, retardos e assim por diante, tudo necessário para processamento de sinal útil real, e para construir instrumentos complexos e efeitos além dos blocos de construção básicos. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>artsgui.idl</term> + + <listitem +><para +>Isto cuida dos objetos visuais. Ele define o tipo básico <emphasis +>Arts::Widget</emphasis +> a partir do qual todos os módulos GUI derivam. Isto produzirá independência de conjunto de ferramentas de desenvolvimento, e ... edição visual de GUI, e GUIs serializáveis. Além disso, como os elementos GUI possuem atributos normais, seus valores podem ser diretamente conectados a algum módulo de processamento de sinal (isto é, o valor de um índice deslizante para um filtro de corte). Como sempre: transparente à rede. </para +></listitem> + +</varlistentry> + +</variablelist> +<para +>Onde possível, o próprio aRts é implementado usando IDL. Por outro lado, existem algumas APIs <emphasis +>específicas de linguagem</emphasis +>, usando seja C++ plano ou C plano. É normalmente mais adequado usar interfaces IDL quando possível, e outras APIs quando necessário. Aqui está uma lista das APIs específicas de linguagem: </para> + +<variablelist> + +<varlistentry> +<term +>KNotify, KAudioPlayer (incluída no libtdecore)</term> + + <listitem +><para +>Estas são APIs convenientes do KDE para os casos mais simples e comuns, onde você somente deseja tocar uma amostra. As APIs estão em C++ plano, otimizadas para o Qt/KDE, e são fáceis de usar e obter. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsc</term> + <listitem +><para +>Interface em C plano para o servidor de som. Muito útil para portar aplicativos legados. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libmcop</term> + + <listitem +><para +>Aqui está toda a magia que o MCOP faz. A biblioteca contém as coisas básicas que você precisa conhecer para escrever um aplicativo MCOP simples, o expedidor, temporizadores, gerenciamento de entrada e saída, além dos mecanismos internos necessários para o protocolo MCOP propriamente dito funcionar. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libartsflow</term> + <listitem +><para +>Somando à implementação do artsflow.idl, alguns utilitários úteis como conversão de taxa de amostragem. </para +></listitem> + +</varlistentry> + +<varlistentry> +<term +>libqiomanager</term> + + <listitem +><para +>Integração do MCOP no ciclo de eventos Qt, quando você escreve aplicativos Qt usando MCOP. </para +></listitem> + +</varlistentry> + +</variablelist> + + + +</sect1> +<sect1 id="knotify"> +<title +>knotify</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="kaudioplayer"> +<title +>kaudioplayer</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="libkmid"> +<title +>libkmid</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="kmedia2"> +<title +>kmedia2</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="soundserver"> +<title +>servidor de som</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="artsflow"> +<title +>artsflow</title> +<para +>Não escrito ainda </para> +</sect1> + +<sect1 id="capi"> +<title +><acronym +>API</acronym +> C</title> + +<sect2 id="capiintro"> +<title +>Introdução</title> + +<para +>A <acronym +>API</acronym +> C do &arts; foi desenhada para tornar fácil escrever e portar aplicativos em C plano para o servidor de som &arts;. Ela fornece funcionalidade de fluxo (enviando fluxos de amostra para o <application +>artsd</application +>), tanto em bloco como não-bloco. Para a maioria dos aplicativos você simplesmente removerá as poucas chamadas do sistema que lidam com seu dispositivo de áudio e as substituirá com as chamadas apropriadas ao &arts;.</para> + +<para +>Eu fiz dois portes como prova do conceito: <application +>mpg123</application +> e <application +>quake</application +>. Você pode obter os remendos a partir <ulink url="http://space.twc.de/~stefan/kde/download/artsc-patches.tar.gz" +>daqui</ulink +>. Sinta-se à vontade para enviar seus próprios remendos para o mantenedor do &arts; ou de pacotes de programas multimídia de modo que eles possam integrar o suporte ao &arts; em seu código.</para> + +</sect2> + +<sect2 id="capiwalkthru"> +<title +>Explanação Rápida</title> + +<para +>Enviar áudio para o servidor de som com a <acronym +>API</acronym +> é muito simples:</para> +<procedure> +<step +><para +>inclua o arquivo de cabeçalho usando <userinput +>#include <artsc.h></userinput +></para +></step> +<step +><para +>inicialize a <acronym +>API</acronym +> com <function +>arts_init()</function +></para +></step> +<step +><para +>crie um fluxo com <function +>arts_play_stream()</function +></para +></step> +<step +><para +>configure parâmetros específicos com <function +>arts_stream_set()</function +></para +></step> +<step +><para +>escreva dados de amostra para o fluxo com <function +>arts_write()</function +></para +></step> +<step +><para +>feche o fluxo com <function +>arts_close_stream()</function +></para +></step> +<step +><para +>libere a <acronym +>API</acronym +> com <function +>arts_free()</function +></para +></step> +</procedure> + +<para +>Aqui está um pequeno exemplo que ilustra isto:</para> + +<programlisting +>#include <stdio.h> +#include <artsc.h> +int main() +{ + arts_stream_t stream; + char buffer[8192]; + int bytes; + int errorcode; + + errorcode = arts_init(); + if (errorcode < 0) + { + fprintf(stderr, "arts_init error: %s\n", arts_error_text(errorcode)); + return 1; + } + + stream = arts_play_stream(44100, 16, 2, "artsctest"); + + while((bytes = fread(buffer, 1, 8192, stdin)) > 0) + { + errorcode = arts_write(stream, buffer, bytes); + if(errorcode < 0) + { + fprintf(stderr, "arts_write error: %s\n", arts_error_text(errorcode)); + return 1; + } + } + + arts_close_stream(stream); + arts_free(); + + return 0; +} +</programlisting> +</sect2> + +<sect2 id="capiartscconfig"> +<title +>Compilando e Ligando: <application +>artsc-config</application +></title> + +<para +>Para compilar e ligar facilmente programas usando a <acronym +>API</acronym +> C do &arts;, o utilitário <application +>artsc-config</application +> é fornecido o qual conhece quais bibliotecas você precisar ligar e onde os arquivos de inclusão estão. Ele é chamado usando</para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--libs</option +></userinput +> +</screen> + +<para +>para encontrar as bibliotecas e </para> + +<screen +><userinput +><command +>artsc-config</command +> <option +>--cflags</option +></userinput +> +</screen> + +<para +>para encontrar sinalizadores de compilação adicionais para o C. O exemplo acima pode ser compilado usando a linha de comando:</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 +>Referência de Biblioteca</title> + +<para +>[A SER FEITO: gerar a documentação para o artsc.h usando o kdoc] </para> + +</sect2> + +</sect1> +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/artsbuilder.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/artsbuilder.docbook new file mode 100644 index 00000000000..e1aa171ac55 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/artsbuilder.docbook @@ -0,0 +1,917 @@ +<chapter id="artsbuilder"> +<title +>&arts-builder;</title> + +<sect1 id="overview"> +<title +>Visão Geral</title> + +<para +>Antes de tudo, ao tentar executar o &arts-builder;, você deve também estar executando o servidor de som (&artsd;). Normalmente, se você usar o &kde; 2.1, isto já deverá estar ocorrendo. Caso contrário, você pode configurar a inicialização automática do servidor de som no &kcontrol; em <menuchoice +><guilabel +>Som</guilabel +><guilabel +>Servidor de Som</guilabel +></menuchoice +>. </para> + +<para +>Quando você está executando o &arts;, ele sempre roda pequenos módulos. O &arts-builder; é uma ferramenta para criar novas estruturas de pequenos módulos conectados. Você simplesmente clica nos módulos dentro da grade. Para fazer isto, escolha-os a partir do menu <guimenu +>Módulos</guimenu +>, e então clique em algum local no plano verde-cinza. </para> + +<para +>Módulos normalmente possuem portas (onde normalmente sinais de áudio entram ou saem). Para conectar duas portas, clique na primeira, fazendo com que ela fique laranja, e então clique na segunda. Você somente pode conectar uma porta de entrada (no lado superior de um módulo) com uma porta de saída (no lado inferior de um módulo). Se você deseja atribuir um valor fixo à uma porta (ou desconectá-la), faça então um duplo-clique na porta. </para> + +</sect1> + +<sect1 id="artsbuilder-tutorial"> +<title +>Tutorial</title> + +<sect2 id="step-1"> +<title +>Passo 1</title> + +<para +>Inicie o &arts-builder;. </para> + +<para +>Você precisa de um módulo Synth_AMAN_PLAY para ouvir a saída do que está criando. Logo crie um módulo Synth_AMAN_PLAY selecionando <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntese</guisubmenu +> <guisubmenu +>IO de Som</guisubmenu +> <guisubmenu +>Synth_AMAN_PLAY</guisubmenu +></menuchoice +> e clique em um espaço de módulo vazio. Coloque-o abaixo da quinta linha em diante, porque nós iremos adicionar algum material acima. </para> + +<para +>O módulo terá um parâmetro <parameter +>title</parameter +> (porta mais a esquerda) e <parameter +>autoRestoreID</parameter +> (ao lado da porta mais à esquerda) para encontrá-lo. Para preenchê-los, dê um duplo-clique nestas portas, selecione valore constante e digite <userinput +>tutorial</userinput +> na caixa de edição. Clique <guibutton +>OK</guibutton +> para aplicar. </para> + +<para +>Selecione <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Executar estrutura</guimenuitem +></menuchoice +>. Você não ouvirá absolutamente nada. O módulo para tocar precisa de alguma entrada ainda... ;) Se você tiver ouvido o silêncio por enquanto, clique <guibutton +>OK</guibutton +> e vá para o Passo 2. </para> +</sect2> + +<sect2 id="step-2"> +<title +>Passo 2</title> + +<para +>Crie um módulo Synth_WAVE_SIN (a partir de <menuchoice +><guimenu +>Módulos</guimenu +> <guimenuitem +>Síntese</guimenuitem +> <guimenuitem +>Formas de onda</guimenuitem +></menuchoice +>) e coloque-o acima do módulo Synth_AMAN_PLAY (Deixe uma linha de espaço entre eles). </para> + +<para +>Como pode ver, isto produz alguma saída, mas precisa de um <guilabel +>pos</guilabel +> como entrada. Primeiro vamos colocar a saída para as caixas de som.Clique na porta <guilabel +>out</guilabel +> do Synth_WAVE_SIN e então na porta <guilabel +>left</guilabel +> do Synth_AMAN_PLAY. Bingo! Você conectou dois módulos. </para> + +<para +>Todos os osciladores no &arts; não necessitada de uma frequência como entrada, mas uma posição na onda. A posição deve estar entra 0 e 1, o qual mapeia para um objeto Synth_WAVE_SIN padrão para o intervalo 0,2*pi. Para gerar valores oscilando a partir de uma frequência, um módulo Synth_FREQUENCY é usado. </para> + +<para +>Crie um módulo Synth_FREQUENCY (a partir de <menuchoice +> <guimenu +>Módulos</guimenu +> <guimenu +>Síntese</guimenu +> <guimenu +>Oscilação & Modulação</guimenu +> </menuchoice +>) e conecte sua saída <quote +>pos</quote +> à entrada <quote +>pos</quote +> do seu Synth_WAVE_SIN. Especifique a frequência da porta do gerador FREQUENCY como um valor constante de 440. </para> + + +<para +>Selecione <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Executar estrutura</guimenuitem +></menuchoice +>. Você ouvirá uma onda senóide de 440 Hz em uma de suas caixas. Se você estiver ouvindo isto por enquanto, clique <guibutton +>OK</guibutton +> e vá para o Passo 3. </para> + +</sect2> + +<sect2 id="step-3"> +<title +>Passo 3</title> + +<para +>Ok, seria melhor se você ouvisse a onda senóide em ambas as caixas. Conecte também a porta right do Synth_PLAY ao outvalue do Synth_WAVE_SIN. </para> + +<para +>Crie um objeto Synth_SEQUENCE (a partir de <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntese</guisubmenu +> <guisubmenu +>Midi & Sequenciamento</guisubmenu +></menuchoice +>). Isto deve estar no topo da tela. Se você precisar de mais espaço você pode mover os outros módulos selecionando-os (para selecionar múltiplos módulos use &Shift;), e arrastando-os para baixo. </para> + +<para +>Agora conecte a saída frequency do Synth_SEQUENCE a entrada frequency do módulo Synth_FREQUENCY. Então especifique a velocidade de sequência como valor constante de 0.13 (a velocidade é a porta mais à esquerda). </para> + +<para +>Agora vá para a porta mais à direita (sequence) do Synth_SEQUENCE e digite um valor constante de <userinput +>A-3;C-4;E-4;C-4;</userinput +> que especifica uma sequência. Mais sobre isto na Referência do Módulo. </para> + +<note> +<para +>O Synth_SEQUENCE realmente <emphasis +>precisa</emphasis +> de uma sequência e velocidade. Sem isto você talvez obtenha erros no construtor. </para> +</note> + +<para +>Selecione <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Executar Estrutura</guimenuitem +></menuchoice +>. Você ouvirá uma bela sequência em execução. Se você tiver gostado do que ouviu, cliuqe <guibutton +>OK</guibutton +> e vá para o Passo 4. </para> +</sect2> + +<sect2 id="step-4"> +<title +>Passo 4</title> + +<para +>Crie um módulo Synth_PSCALE (a partir de <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntese</guisubmenu +> <guisubmenu +>Envelopes</guisubmenu +></menuchoice +>). Desconecte o outvalue da onda SIN dando um duplo clique e selecionando <guilabel +>não conectado</guilabel +>. Conecte </para> + +<orderedlist +><listitem> +<para +>O outvalue do SIN ao invalue do PSCALE</para> +</listitem> +<listitem> +<para +>O outvalue do PSCALE ao left do AMAN_PLAY</para> +</listitem> +<listitem> +<para +>O outvalue do PSCALE ao right do AMAN_PLAY</para> +</listitem> +<listitem> +<para +>O pos do SEQUENCE ao pos do PSCALE</para> +</listitem> +</orderedlist> + +<para +>Finalmente, configure o top do PSCALE para algum valor, por exemplo 0.1. </para> + +<para +>Como isto funciona agora: O Synth_SEQUENCE fornece informações adicionais sobre a posição da nota musical que está sendo tocada agora, enquanto 0 significa iniciada e 1 significa terminada. O módulo Synth_PSCALE escalonará o fluxo de áudio que é direcionado através dele a partir de um volume 0 (silêncio) à 1 (nível original) e de volta à 0 (silêncio). De acordo com a posição. A posição onde o pico deve ocorrer pode ser fornecida como pos. 0.1 significa que após 10% da nota ter sido tocada, o volume atinge seu máximo, e inicia a diminuir em seguida. </para> + + +<para +>Selecione <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Executar Estrutura</guimenuitem +></menuchoice +>. Você ouvirá uma agradável sequência ser executada. Se você tiver gostado do que ouviu, clique <guibutton +>OK</guibutton +> e vá para o Passo 5. </para> + +</sect2> + +<sect2 id="step-5-starting-to-beam-data-around"> +<title +>Passo 5: Começando a transmitir dados por todos os lados ;)</title> + +<para +>Inicie outro &arts-builder;</para> + +<para +>Coloque um Synth_AMAN_PLAY nele, configure-o para um nome razoável qualquer. Coloque um Synth_BUS_DOWNLINK nele e:</para> + +<orderedlist> +<listitem> +<para +>Configure o bus do Synth_BUS_DOWNLINK para áudio (que é apenas um nome, chame-o de joao se quiser) </para> +</listitem> +<listitem> +<para +>Conecte o left do Synth_BUS_DOWNLINK ao left do Synth_AMAN_PLAY </para> +</listitem> +<listitem> +<para +>Conecte o right do Synth_BUS_DOWNLINK ao right do Synth_AMAN_PLAY </para> +</listitem> +</orderedlist> + +<para +>Inicie a execução da estrutura. Como esperado, você não ouvirá nada, ... não ainda. </para> + +<para +>Retorne à estrutura com o Synth_WAVE_SIN e substitua o módulo Synth_AMAN_PLAY por um Synth_BUS_UPLINK, e configure o nome para audio (ou joao se desejar). Para excluir módulos selecione-os e escolha <menuchoice +><guimenu +>Editar</guimenu +> <guimenuitem +>excluir</guimenuitem +></menuchoice +> no menu (ou pressione a tecla <keycap +>Del</keycap +>). </para> + +<para +>Acione <menuchoice +><guimenu +>Arquivo</guimenu +> <guilabel +>Executar estrutura</guilabel +></menuchoice +>. Você ouvirá a sequência com notas escalonadas, transportadas pelo barramento. </para> + +<para +>Se você deseja saber porque algo como isto pode ser útil atualmente, clique <guibutton +>OK</guibutton +> (no &arts-builder; que estiver executando o Synth_SEQUENCE, você pode deixar o outro em execução) e vá para o Passo 6. </para> +</sect2> + +<sect2 id="step-6-beaming-for-advanced-users"> +<title +>Passo 6: Transmissão para usuários avançados</title> + +<para +>Escolha <menuchoice +><guimenu +>Arquivo</guimenu +> <guimenuitem +>Renomear estrutura</guimenuitem +></menuchoice +> no menu do artsbuilder que contém o Synth_SEQUENCE, e chame-o de tutorial. Clique <guibutton +>OK</guibutton +>. </para> + +<para +>Escolha <menuchoice +><guimenu +>Arquivo</guimenu +> <guimenuitem +>Salvar</guimenuitem +></menuchoice +> </para> + +<para +>Inicie mais outro &arts-builder; e selecione <menuchoice +><guimenu +>Arquivo</guimenu +> <guimenuitem +>Carregar</guimenuitem +></menuchoice +>, e carregue o tutorial novamente. </para> + +<para +>Agora você pode selecionar <menuchoice +><guimenu +>Arquivo</guimenu +> <guimenuitem +>Executar estrutura</guimenuitem +></menuchoice +> em ambos os &arts-builder; que possuem esta estrutura. Você agora ouvirá duas vezes a mesma coisa. Dependendo do momento em que você iniciá-lo o som será mais ou menos agradável. </para> + +<para +>Outra coisa que é bom fazer neste ponto do tempo é: iniciar o &noatun;, e tocar algum <literal role="extension" +>mp3</literal +>. Inicie o &artscontrol;. Vá para <menuchoice +><guimenu +>Ver</guimenu +><guimenuitem +>Ver gerenciador de áudio</guimenuitem +></menuchoice +>. O que você verá é a estrutura de playback do &noatun; e do seu <quote +>tutorial</quote +> tocando alguma coisa. A coisa legal que você pode fazer é isto: duplo-clique no &noatun;. Você agora obterá uma lista de todos os barramentos disponíveis. E veja? Você pode fazer com que o &noatun; envie sua saída para o barramento de áudio da estrutura de playback que seu tutorial fornece. </para> +</sect2> + +<sect2 id="step-7-midi-synthesis"> +<title +>Passo 7: Síntese de midi</title> + +<para +>Finalmente, agora você deve ser capaz de transformar sua onde senóide em um instrumento real. Isto somente faz sentido se você possui algo em mãos que possa enviar eventos &MIDI; para o &arts;. Eu descreverei aqui como você pode usar alguns teclados externos, mas um barramento midi que disponha de sequências como o &brahms; funcionará também. </para> + +<para +>Primeiramente, limpe seu ambiente de trabalho até que você tenha somente um &arts-builder; com a estrutura de onda senóide na estrutura (não executando). Então, vá três vezes para <menuchoice +><guimenu +>Portas</guimenu +><guisubmenu +>Criar sinal de áudio IN</guisubmenu +></menuchoice +>, e três vezes para <menuchoice +><guimenu +>Portas</guimenu +><guisubmenu +>Criar sinal de áudio OUT</guisubmenu +></menuchoice +>. Coloque as portas em algum lugar. </para> + +<para +>Finalmente, vá para <menuchoice +><guimenu +>Portas</guimenu +><guilabel +>Mudar posições e nomes</guilabel +></menuchoice +> e chame as portas de frequência, velocidade, pressionada, esquerda, direita, feito. </para> + +<para +>Finalmente, você pode excluir o módulo Synth_SEQUENCE, e ao invés de usar este módulo conecte a porta de entrada de frequência da estrutura à porta de frequência do Synth_FREQUENCY. Uhmm. Mas e o pos?</para +> <para +>Não não o usaremos, porque com nenhum algoritmo no mundo você pode predizer quando o usuário soltará a nota que ele pressionou no teclado midi. Logo nós ao invés disso usamos um parâmetro de pressionado que apenas indica se o usuário ainda mantém a tecla pressionada. (pressionada = 1: a tecla ainda está pressionada, pressionada = 0: a tecla foi solta) </para> + +<para +>Isto significa que o objeto Synth_PSCALE também deve ser substituído agora. Conecte-o em um Synth_ENVELOPE_ADSR no lugar (a partir de <menuchoice +><guimenu +>Módulos</guimenu +> <guisubmenu +>Síntese</guisubmenu +> <guisubmenu +>Envelopes</guisubmenu +> </menuchoice +>). Conecte: </para> + +<orderedlist> +<listitem> +<para +>O input da estrutura pressinada ao active do ADSR</para> +</listitem> +<listitem> +<para +>O outvalue do SIN ao invalue do ADSR</para> +</listitem> +<listitem> +<para +>O outvalue do ADSR ao output da estrutura esquerda</para> +</listitem +><listitem> +<para +>O outvalue do ADSR ao output da estrutura direita</para> +</listitem> +</orderedlist> + +<para +>Configure os parâmetros attack para 0.1, decay para 0.2, sustain para 0.7 e release para 0.1. </para> + +<para +>Outra coisa que nós precisamos pensar é que a estrutura de instrumento deve saber de alguma maneira quando terminou de tocar e então deve ser interrompida, porque caso contrário ela nunca irá parar mesmo se a nota for solta. Felizmente, o envelope ADSR reconhece quando não haverá mais nada para ouvir, uma vez que de qualquer jeito escala o sinal para zero em algum ponto após a nota ser solta. </para> + +<para +>Isto é indicado pela configuração do done output para 1. Logo conecte isto ao output do feito da estrutura. A estrutura será removida tão logo vá para 1. </para> + +<para +>Renomeie sua estrutura para instrumento_tutorial (a partir do <menuchoice +><guimenu +>Arquivo</guimenu +> <guimenuitem +>Renomear estrutura</guimenuitem +></menuchoice +>. Então salve-a usando o salvar como (o nome padrão oferecido agora deve ser instrumento_tutorial).</para +><para +>Inicie o artscontrol, e vá para o <menuchoice +><guimenu +>Ver</guimenu +> <guimenuitem +>Gerenciador de Midi</guimenuitem +></menuchoice +>, e escolha <menuchoice +><guimenu +>Adicionar</guimenu +><guimenuitem +>Saída de MIDI do Sintetizador aRts</guimenuitem +></menuchoice +>. Finalmente, você deve ser capaz de selecionar seu instrumento (tutorial) aqui. </para> + +<para +>Abra um terminal e digite <userinput +><command +>midisend</command +></userinput +>. Você verá que o <command +>midisend</command +> e o instrumento estão listados agora no gerenciador de &MIDI; do &arts;. Após selecionar ambos e clicar <guibutton +>conectar</guibutton +>, nós finalmente terminamos. Pegue o seu teclado e comece a tocar (é claro que ele deve estar conectado ao seu computador). </para> +</sect2> + +<sect2 id="suggestions"> +<title +>Sugestões</title> + +<para +>Você agora deve ser capaz de trabalhar com o &arts;. Aqui estão algumas dicas do que você pode tentar melhorar em suas estruturas agora: </para> + +<itemizedlist> +<listitem> +<para +>Tente usar coisas além de uma onda SIN. Quando você pluga uma onda TRI, você muito provavelmente achará que o som não é muito legal. Mas tente colocar um filtro SHELVE_CUTOFF logo após a onda TRI para cortar as frequências acima de um valor determinado (tente algo como 1000 Hz, ou mesmo duas vezes a frequência de entrada ou frequência de entrada + 200 Hz ou algo como isto). </para> +</listitem> +<listitem> +<para +>Tente usar mais de um oscilador. O Synth_XFADE pode ser usado para fazer uma transição suave (mixar) de dois sinais, e o Synth_ADD para adicioná-los. </para> +</listitem> +<listitem> +<para +>Tente configurar as frequências dos osciladores para não extamente os mesmos valores, o que fornece oscilações legais. </para> +</listitem> +<listitem> +<para +>Experimente usar mais de um envelope. </para> +</listitem> +<listitem> +<para +>Tente sintetizar instrumentos com diferentes saídas esquerda e direita. </para> +</listitem> +<listitem> +<para +>Tente pós-processar o sinal após ele sair do barramento. Você pode por exemplo misturar uma versão retardada do sinal com o original para obter um efeito de eco. </para> +</listitem> +<listitem> +<para +>Tente usar a configuração velocidade (ela é a força com a qual a nota é pressionada, você pode também dizer volume). O efeito especial é sempre quanto isto não somente modifica o volume do sinal resultante, mas também o som do instrumento (por exemlo a frequência de corte). </para> +</listitem> +<listitem> +<para +>...</para> +</listitem> +</itemizedlist> + +<para +>Se você tiver criado alguma coisa bem legal, por favor considere fornecê-la para a página web do &arts;. Ou para inclusão na próxima versão. </para> +</sect2> + +</sect1> + +<sect1 id="artsbuilder-examples"> +<title +>Exemplos</title> + +<para +>O &arts-builder; vem com diversos exemplos, que podem ser abertos através do <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Abrir Exemplo...</guimenuitem +></menuchoice +>. Alguns deles estão na pasta, outros (que por alguma razão não funcionam com a versão atual) estão à esquerda na pasta todo. </para> +<para +>Os exemplos dividem-se em diversas categorias: </para> + +<itemizedlist> +<listitem> +<para +>Exemplos por si só ilustrando como usar cada um dos módulos embutidos do arts (nomeados <filename +>example_*.arts</filename +>). Estes tipicamente enviam alguma saída para uma placa de som. </para> +</listitem> + +<listitem> +<para +>Instrumentos construídos a partir dos módulos do arts de nível mais baixo (nomeados <filename +>instrument_*.arts</filename +>). Estes seguem a convenção padrão para portas de entrada e saída de modo que eles podem ser usados com o gerenciador &MIDI; no &artscontrol;. </para> +</listitem> + +<listitem> +<para +>Modelos para criar novos módulos (nomeados <filename +>template_*.arts</filename +>). </para> +</listitem> + +<listitem> +<para +>Efeitos que pode ser usados como blocos de construção reutilizáveis (nomeados <filename +>effect_*.arts</filename +>) [ todos em todo ] </para> +</listitem> + +<listitem> +<para +>Elementos de mixagem usados para criar mixadores, incluindo controles gráficos (nomeados <filename +>mixer_element_*.arts</filename +>). [ todos em todo ] </para> +</listitem> + +<listitem> +<para +>Módulos diversos que não se enquadram em nenhuma das categorias acima. </para> +</listitem> +</itemizedlist> + +<variablelist> +<title +>Descrição Detalhada De Cada Módulo:</title> +<varlistentry> +<term +><filename +>example_stereo_beep.arts</filename +></term> +<listitem> +<para +>Gera uma tom de onda senóide de 440Hz no canal esquerdo e um tom de onda senóide de 880Hz no canal direito, e envia-os para a saída da placa de som. Isto é referenciado na documentação do &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sine.arts</filename +></term> +<listitem> +<para +>Gera uma onda senóide de 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pulse.arts</filename +></term> +<listitem> +<para +>Gera uma onda em pulso de 440 Hz com um ciclo de 20%. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_softsaw.arts</filename +></term> +<listitem> +<para +>Gera uma onda em dente de serra de 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_square.arts</filename +></term> +<listitem> +<para +>Gera uma onda quadrada de 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tri.arts</filename +></term> +<listitem> +<para +>Gera uma onda triangular de 440 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_noise.arts</filename +></term> +<listitem> +<para +>Gera um ruído branco. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_dtmf1.arts</filename +></term> +<listitem> +<para +>Gera um tom duplo pela produção de ondas senóides de 697 e 1209 Hz, escalonando-as em 0.5, e adicionando-as juntas. Este é o tom DTMF para o dígito "1" no teclado do telefone. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_atan_saturate.arts</filename +></term> +<listitem> +<para +>Executa uma onda triangular através do filtro de saturação atan. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_autopanner.arts</filename +></term> +<listitem> +<para +>Usa um auto-garimpador para garimpar uma onda senóide de 400 Hz entre as caixas esquerda e direita a uma taxa de 2 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_brickwall.arts</filename +></term> +<listitem> +<para +>Escalona uma onda senóide com um fator de 5 e então executa-a através de um limitador de parede de tijolo. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_bus.arts</filename +></term> +<listitem> +<para +>Baixa a partir de um barramento chamado <quote +>Bus</quote +> e envia para o barramento <quote +>out_soundcard</quote +> com os canais direito e esquerdo invertidos. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_cdelay.arts</filename +></term> +<listitem> +<para +>Baixa a partir de um barramento chamado <quote +>Delay</quote +>, e envia o canal direito com 0.5 segundos de cdelay, e o canal esquerdo sem mudanças. Você pode usar o &artscontrol; para conectar o efeito a um tocador de som e observar os resultados. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_delay.arts</filename +></term> +<listitem> +<para +>Este é o mesmo que <filename +>example_cdelay.arts</filename +> mas usa o efeito delay. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_capture_wav.arts</filename +></term> +<listitem> +<para +>Isto usa o Synth_CAPTURE_WAV para salvar uma onda senóide de 400 Hz como um arquivo de onda. Roda o módulo por uns poucos segundos, e então examinha o arquivo criado no <filename class="directory" +>/tmp</filename +>. Você pode tocar o arquivo com um tocador como o <application +>kaiman</application +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_data.arts</filename +></term> +<listitem> +<para +>Isto usa o módulo Data para gerar um fluxo constante de valor <quote +>3</quote +> e enviá-lo para o módulo Debug para periodicamente exibí-lo. Ele também contém um módulo Nil, ilustrando como ele pode ser usado para não fazer nada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_adsr.arts</filename +></term> +<listitem> +<para +>Mostra como criar um simples instrumento de som usando o módulo de envelope Adsr, repetidamente disparado por uma onda quadrática. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_fm.arts</filename +></term> +<listitem> +<para +>Isto usa o módulo FM Source para gerar uma onda senóide de 440 Hz que é modulada na frequência a uma taxa de 5 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_freeverb.arts</filename +></term> +<listitem> +<para +>Isto conecta o efeito Freeverb a partir de um barramento de baixar para um barramento de enviar. Você pode usar o artscontrol para conectar o efeito para um tocador de som e observar os resultados. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_flanger.arts</filename +></term> +<listitem> +<para +>Isto implementa um efeito simples de flanger (isto parece que não está funcionando, ainda). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_moog.arts</filename +></term> +<listitem> +<para +>Esta estrutura combina os dois canais de uma barramento em um, passa-o através do filtro Moog VCF, e envia-o para o barramento out_soundcard. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pitch_shift.arts</filename +></term> +<listitem> +<para +>Esta estrutura passa os dados do canal esquerdo da placa de som através do efeito Pitch Shift. Ajusta o parâmetro de velocidade para variar o efeito. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_rc.arts</filename +></term> +<listitem> +<para +>Esta estrutura passa o gerador de ruído branco através de um filtro RC e envia-o para a placa de som. Vendo o mostrador do FFT Scope do artscontrol você pode ver como isto varia de um ruído não filtrado para a forma em onda. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_sequence.arts</filename +></term> +<listitem> +<para +>Isto demonstra o módulo Sequence tocando uma sequência de notas. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_shelve_cutoff.arts</filename +></term> +<listitem> +<para +>Esta estrutura passa um gerador de ruído branco através do filtro Shelve Cutoff e envia para a placa de som. Vendo o mostrador do FFT Scope do artscontrol você pode ver como isto varia de um ruído não filtrado para a forma em onda. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_equalizer.arts</filename +></term> +<listitem> +<para +>Isto demonstra o módulo Std_Equalizer. Ele imcrementa as frequências baixas e altas em 6 dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_tremolo.arts</filename +></term> +<listitem> +<para +>Isto demonstra o efeito Tremolo. Ele modula os canais esquerdo e direito usado uma vibração de 10 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_xfade.arts</filename +></term> +<listitem> +<para +>Este exemplo mixa ondas senóides de 440 e 880 Hz usando uma transição suave. Ajusta o valor da entrada percentual da transição de -1 para 1 para controlar a mixagem dos dois sinais. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_pscale.arts</filename +></term> +<listitem> +<para +>Isto ilustra o módulo Pscale (eu não estou certo se isto é um exemplo significativo). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><filename +>example_play_wav.arts</filename +></term> +<listitem> +<para +>Isto ilustra o módulo Play Wave. Você precisará inserir o caminho completo para um arquivo <literal role="extension" +>.wav</literal +> como parâmetro filename. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>example_multi_add.arts</term> +<listitem> +<para +>Isto mostra o módulo Multi Add que aceita qualquer número de entradas. Ele soma três módulos Data que produzem entradas de 1, 2 e 3, e exibe o resultado 6. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/detail.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/detail.docbook new file mode 100644 index 00000000000..3cac13d1e46 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/detail.docbook @@ -0,0 +1,1387 @@ +<!-- <?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 +>O &arts; em Detalhes</title> + +<sect1 id="architecture"> +<title +>Arquitetura</title> + +<mediaobject> +<imageobject> +<imagedata fileref="arts-structure.png" format="PNG"/> +</imageobject> +<textobject +><phrase +>A estrutura do &arts;.</phrase +></textobject> +</mediaobject> +</sect1> + +<sect1 id="modules-ports"> +<title +>Módulos & Portas</title> + +<para +>A idéia do &arts; é que a sintetização pode ser feita usando pequenos módulos, que fazem somente uma coisa, e então recombiná-los em estruturas complexas. Os pequenos módulos normalmente possuem portas de entrada, onde eles podem obter alguns sinais ou parâmetros, e portas de saídas, onde eles produzem alguns sinais. </para> + +<para +>Um módulo (Synth_ADD) por exemplo simplesmente pegam dois sinais em sua entrada e adiciona-os juntos. O resultado é disponibilizado no sinal de saída. Os locais onde os módulos fornecem seus sinais de entrada/saída são chamados portas. </para> + +</sect1> + +<sect1 id="structures"> +<title +>Estruturas</title> + +<para +>Uma estrutura é uma combinação de módulos conectados, alguns dos quais podem possuir parâmetros codificados diretamente em suas portas de entrada, outros que podem ser conectados, e outros que não são conectados de nenhuma maneira. </para> + +<para +>O que você pode fazer com o &arts-builder; é descrever estruturas. Você descreve quais módulos deseja conectar com outros módulos. Quando tiver terminado, você pode salvar a descrição da estrutura para um arquivo, ou dizer ao &arts; para criar uma estrutura que você descreveu (Executar). </para> + +<para +>Então, provavelmente você ouvirá algum som, se você fez tudo da maneira certa. </para> +</sect1> + +<!-- TODO + +<sect1 id="streams"> +<title +>Streams</title> + +</sect1> + +--> + +<sect1 id="latency"> +<title +>Latência</title> + +<sect2 id="what-islatency"> +<title +>O que é latência?</title> + +<para +>Suponhamos que você tenha um aplicativo chamado <quote +>mousepling</quote +> (que deve fazer um som <quote +>pling</quote +> se você clicar um botão). A latência é o tempo entre seu dedo clicar o botão do mouse e você ouvir o pling. A latência nesta configuração é composta ela mesma de determinadas latências, que possuem diferentes causas. </para> + +</sect2> + +<sect2 id="latenbcy-simple"> +<title +>Latência em Aplicativos Simples</title> + +<para +>Neste aplicativo simples, a latência ocorre neste locais: </para> + +<itemizedlist> + +<listitem> +<para +>O tempo até o kernel notificar o servidor X11 que o botão do mouse foi pressionado. </para> +</listitem> + +<listitem> +<para +>O tempo até o servidor X11 notificar seu aplicativo que o botão do mouse foi pressionado. </para> +</listitem> + +<listitem> +<para +>O tempo até o aplicativo mousepling decidir que este é o botão certo para tocar um pling. </para> +</listitem> + +<listitem> +<para +>O tempo que leva o aplicativo mousepling para dizer ao servidor de som que deve ser tocado um pling. </para> +</listitem> + +<listitem> +<para +>O tempo que leva para o pling (que o servidor de som inicia misturando a outra saída que está ocorrendo) para sair dos dados em buffer, até ele realmente chegar na posição onde a placa de som irá tocar. </para> +</listitem> + +<listitem> +<para +>O tempo que leva para o som pling para sair das caixas de som e chegar em seu ouvido. </para> +</listitem> +</itemizedlist> + +<para +>Os primeiros três ítens são latências externas ao &arts;. Eles são interessantes, mas além do escopo deste documento. No entanto esteja alerta que eles existem, logo mesmo que você tenha otimizado tudo para valores realmente baixos, você não necessariamente obterá exatamente o resultado que você calculou. </para> + +<para +>Dizer ao servidor para tocar alguma coisa envolve normalmente uma chamada &MCOP; simples. Existem medidores de performance que confirmam que, em uma mesma máquina com soquetes unix, dizer para o servidor tocar alguma coisa pode ser feito cerca de 9000 vezes em um segunto com a implementação atual. Eu espero que a maioria do tempo gasto seja responsabilidade do kernel, alternando de um aplicativo para outro. É claro que este valor muda de acordo com o tipo exato de parâmetros. Se você transferir uma imagem inteira com uma chamada, isto será mais lento do que se você transferir somente um valor longo. Para o código de retorno o mesmo é verdadeiro. No entanto para strings ordinários (como o nome do arquivo <literal role="extension" +>wav</literal +> a ser tocado) isto não deve ser problema. </para> + +<para +>Em suma, nós podemos aproximar este tempo de 1/9000 seg, que é abaixo de 0,15 ms. Nós veremos que isto não é relevante. </para> + +<para +>A seguir é o tempo entre o servidor iniciar a tocar e a placa de som receber algum som. O servidor necessita realizar um armazenamento em buffer, de modo que outros aplicativos que estiverem rodando, como o seu servidor X11 ou o aplicativo <quote +>mousepling</quote +>, não causem falhas no som que você vai ouvir. A maneira como isto é feito no &Linux; é que existem um determinado número de fragmentos de um tamanho. O servidor recarregará os fragmentos, e a placa de som tocará os fragmentos. </para> + +<para +>Vamos supor que existem três fragmentos. O servidor carrega o primeiro, a placa de som inicia a tocá-lo. O servidor carrega o segundo. O servidor carrega o terceiro. O servidor terminou, outros aplicativos podem fazer algo agora. </para> + +<para +>Quando a placa de som terminar o primeiro fragmento, ela inicia a tocar o segundo e o servidor inicia o carregamento do próximo. E assim por diante. </para> + +<para +>A latência máxima que você obtém com tudo isto é (número de fragmentos)*(tamanho de cada fragmento)/(taxadaamostra * (tamanho de cada amostra)). Suponhamos que nós usamos uma taxa de amostra de 44kHz estéreo, e 7 fragmentos de 1024 bytes (os padrões atuais do aRts), nós obteremos 40 ms. </para> + +<para +>Estes valores podem ser ajustados de acordo com suas necessidades. No entanto, o uso da <acronym +>CPU</acronym +> aumenta com latências menores, uma vez que o servidor de som precissa carregar o buffer mais frequentemente, e em pequenas partes. É também muito difícil obter melhores valores sem fornecer ao servidor de som prioridade em tempo real, caso contrário você frequentemente obterá sons falhados. </para> + +<para +>No entanto, é realístico fazer algo como 3 fragmentos com 256 bytes cada, que tornarão este valor 4,4 ms. Com 4,4 ms de retardo o uso da <acronym +>CPU</acronym +> disponível do &arts; deve ser de cerca de 7,5%. Com 40 ms de retardo, ele deverá ser de cerca de 3% (de um PII-350, e este valor pode depender de sua placa de som, versão do kernel e outros). </para> + +<para +>Então existe o tempo que leva para o som pling percorrer a distância entra a caixa de som e seu ouvido. Suponhamos que sua distância das caixas seja de 2 metros. O som atravessa o ar na velocidade de 300 metros por segundo. Assim nós poderemos aproximar este tempo em 6 ms. </para> + +</sect2> + +<sect2 id="latency-streaming"> +<title +>Latência em Aplicativos de Fluxo</title> + +<para +>Aplicativos de fluxo são aqueles que produzem seu som eles próprios. Consideremos um jogo, que gera um fluxo constante de sons, e devem agora ser adaptados para tocar coisas através do &arts;. Para ter um exemplo: quando eu pressiono uma tecla, o personagem do jogo que eu estou controlando salta, e um som de boing é tocado. </para> + +<para +>Antes de tudo, você precisa saber como o &arts; controla fluxos. É bem semelhante à entrada e saída da placa de som. O jogo envia alguns pacotes com trechos para o servidor de som. Digamos três pacotes. Assim que o servidor estiver recebido o primeiro pacote, ele envia uma confirmação para o jogo que este pacote foi recebido. </para> + +<para +>O jogo cria outro pacote de som e envia-o para o servidor. Então o servidor inicia o recebimento do segundo pacote de som, e assim por diante. A latência aqui parece semelhante ao caso simples: </para> + +<itemizedlist> +<listitem> +<para +>O tempo até o kernel notificar o servidor X11 que uma tecla foi pressionada. </para> +</listitem> + +<listitem> +<para +>O tempo até o servidor X11 notificar o jogo que uma tecla foi pressionada. </para> +</listitem> + +<listitem> +<para +>O tempo até o jogo decidir que esta tecla é a que deve ser tocado um boing. </para> +</listitem> + +<listitem> +<para +>O tempo até o pacote de som no qual o jogo iniciou a colocar o som boing chega ao servidor de som. </para> +</listitem> + +<listitem> +<para +>O tempo que leva para o boing (que o servidor de som inicia misturando a outra saída que está ocorrendo) para sair dos dados em buffer, até ele realmente chegar na posição onde a placa de som irá tocar. </para> +</listitem> + +<listitem> +<para +>O tempo que leva para o som boing para sair das caixas de som e chegar em seu ouvido. </para> +</listitem> + +</itemizedlist> + +<para +>As latências externas, como acima, estão fora do escopo deste documento. </para> + +<para +>Obviamente, a latência do fluxo depende do tempo que leva para todos os pacotes que serão usados para o fluxo seja tocados. Logo isto é (número de pacotes)*(tamanho de cada pacote)/(taxadeamostra * (tamanho de cada amostra)) </para> + +<para +>Como pode ver é a mesma fórmula que se aplica aos fragmentos. No entanto para jogos, não faz sentido criar pequenos retardos como acima. Eu diria que uma configuração realística para jogos deve ser 2048 bytes por pacote, usando 3 pacotes. A latência resultante será de 35ms. </para> + +<para +>Isto é baseado no seguinte: assumimos que o jogo renderiza 25 quadros por segundo (para a tela). É provavelmente seguro considerar que você não perceberá uma diferença de saída de som de um quadro. Assim o retardo de 1/25 segundos para o fluxo é aceitável, o que significa que 40ms deve ser satisfatório. </para> + +<para +>A maioria das pessoas também não executam seus jogos com prioridade de tempo real, e o perigo de falhas no som não deve ser negligenciado. Fluxos com 3 pacotes de 256 bytes é possível (eu tentei isto) mas causa muito uso da <acronym +>CPU</acronym +> para fluxo. </para> + +<para +>Para latências no lado servidor, você pode calcular exatamente como acima. </para> + +</sect2> + +<sect2 id="cpu-usage"> +<title +>Algumas considerações sobre uso da <acronym +>CPU</acronym +></title> + +<para +>Existem muitos fatores que influenciam o uso da <acronym +>CPU</acronym +> em um cenário complexo, com alguns aplicativos de fluxo e alguns outros, como plugins no servidor, etc. Para nomear alguns: </para> + +<itemizedlist> +<listitem> +<para +>Uso bruto da <acronym +>CPU</acronym +> por cálculos necessários. </para> +</listitem> + +<listitem> +<para +>Gastos com agendamento interno do &arts; - como o &arts; decide quando e qual módulo deve calcular o quê. </para> +</listitem> + +<listitem> +<para +>Gastos para conversão de inteiro para flutuante. </para> +</listitem> + +<listitem> +<para +>Gastos do protocolo &MCOP;. </para> +</listitem> + +<listitem> +<para +>Kernel: alternar processo/contexto. </para> +</listitem> + +<listitem> +<para +>Kernel: gastos com comunicação. </para> +</listitem> +</itemizedlist> + +<para +>Para uso bruto da <acronym +>CPU</acronym +> para cálculos, se você toca dois fluxos simultaneamente, você precisa fazer adições. Se você aplica um filtro, alguns cálculos são envolvidos. Para ter um exemplo simplificado, adicionar dois fluxos envolve talvez quatro ciclos de <acronym +>CPU</acronym +> por adição; em um processador de 350Mhz, isto é 44100*2*4/350000000 = 0,1% de uso da <acronym +>CPU</acronym +>. </para> + +<para +>O agendamento interno do &arts;: o &arts; necessita decidir qual plugins calcula o quê quando. Isto leva tempo. Pegue um perfil se estiver interessado nele. Geralmente o que pode ser dito é: quanto menor tempo real que você executa (&ie; os maiores blocos que podem ser calculados na hora) menor gasto com agendamento você tem. Calcular blocos com amostras acima de 128 na hora (como usar tamanhos de fragmentos de 512 bytes) o gasto com agendamento provavelmente não será algo a se considerar. </para> + +<para +>Gastos com conversão de inteiro para flutuante: o &arts; usa internamente números flutuantes como formato de dados. Eles são fáceis de manipular e nos processadores recentes não são mais lentos que operações com inteiros. No entanto, se existirem cliente que trocam dados que não são flutuantes (como um jogo que deve fazer sua saída de som através do &arts;), eles necessitam ser convertidos. O mesmo se aplica se você deseja repetir sons em sua placa de som. A placa de som precisa de inteiros, logo você precisa converter. </para> + +<para +>Aqui estão os números para um Celeron, aproximadamente tiques por amostra, com -O2 +egcs 2.91.66 (obtidos por Eugen Smith <email +>hamster@null.ru</email +>). Isto é obviamente altamente dependente do processador: </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 +>Isto significa um uso de 1% da <acronym +>CPU</acronym +> para conversão e 5% para interpolação em um processador de 350 MHz. </para> + +<para +>Gastos com o protocolo &MCOP;: o &MCOP; faz, via de regra, 9000 invocações por segundo. Muito disto não é culpa do &MCOP;, mas relacionam-se com duas causas de kernel nomeadas abaixo. No entanto, isto fornece uma base para realizar cálculos do custo do fluxo. </para> + +<para +>Cada pacote de dados transferido do fluxo pode ser considerado uma invocação do &MCOP;. É claro que grandes pacotes são mais lentos que 9000 pacotes/s, mas isto é apenas uma idéia. </para> + +<para +>Suponhamos que você use tamanhos de pacotes de 1024 bytes. Assim, para transferir um fluxo com 44kHz estéreo, você precisa transferir 44100*4/1024 = 172 pacotes por segundo. Suponhamos que você possa com 100% de uso da CPU transferir 9000 pacotes, então você obtém (172*100)/9000 = 2% de uso da <acronym +>CPU</acronym +> para realizar o fluxo com pacotes de 1024 bytes. </para> + +<para +>Isto é uma aproximação. No entanto, elas mostram que você terá um desempenho melhor (se você puder ter recursos para a latência), usando por exemplo pacotes de 4096 bytes. Nós podemos criar uma fórmula compacta aqui, calculando o tamanho do pacote que causa 100% de uso da <acronym +>CPU</acronym +> como 44100*4/9000 = 19,6 de amostra, e assim obter uma fórmula rápida: </para> + +<para +>uso da <acronym +>CPU</acronym +> para fluxo em percentual = 1960/(seu tamanho de pacote) </para> + +<para +>o que fornece-nos um uso da <acronym +>CPU</acronym +> de 0,5% quando enviando fluxo com pacotes de 4096 bytes. </para> + +<para +>Alternação de processo/contexto do kernel: isto é parte do gasto do protocolo &MCOP;. Alternar entre dois processos leva tempo. Existe o mapeamento de novas posições de memória, o inválidação do cache, ou outro motivo qualquer (se existir um perito em kernel lendo isto - diga-me quais são as causas exatamente). Ou seja: isto leva tempo. </para> + +<para +>Em não estou certo de quantas alternações de contexto o &Linux; pode realizar por segundo, mas este número não é infinito. Assim, eu suponho que a sobrecarga do protocolo &MCOP; seja um pouco devido a alternação de contexto. No início do &MCOP;, eu fiz testes para usar a mesma comunicação dentro de um processo, e isto foi bem mais rápido (quatro vezes mais rápido ou mais). </para> + +<para +>Kernel: gastos de comunicação: Isto é parte do gasto do protocolo &MCOP;. Transferir dados entre processos é atualmente feito através de soquetes. Isto é conveniente, uma vez que métodos select() comuns podem ser usados para determinar quando uma mensagem chegou. Isto pode também ser facilmente combinado com outras fontes de E/S (entrada/saída) como E/S de áudio, servidor X11 ou qualquer outra fonte. </para> + +<para +>No entanto, estas chamadas de leitura e escrita certamente custam ciclos do processador. Para pequenas invocações (como na transferência de um evento midi) isto não é provavelmente tão ruim, mas para grandes invocações (como a transferência de vídeos com diversos megabytes) isto é claramente um problema. </para> + +<para +>Adicionar o uso da memória compartilhada para o &MCOP; onde for apropriado é provavelmente a melhor solução. No entanto, isto deve ser faito de maneira transparente para o programador do aplicativo. </para> + +<para +>Pegue um perfil ou faça outros testes para descobrir o quão exatamente o fluxo de áudio atual é impactado pelo não uso da memória compartilhada. No entanto, não é tão ruim, uma vez que o fluxo de áudio (tocando um mp3) pode ser feito com um uso total de 6% da <acronym +>CPU</acronym +> pelo &artsd; e <application +>artscat</application +> (e 5% pelo decodificador mp3). No entanto, isto inclui tudo desde os cálculos necessários até os gastos do soquete, assim eu diria que nesta configuração você pode pelo menos economizar 1% usando memória compartilhada. </para> + +</sect2> + +<sect2 id="hard-numbers"> +<title +>Alguns Números Brutos</title> + +<para +>Estes números foram feitos com a versão de desenvolvimento atual. Eu gostaria também de experimentar alguns casos reais, assim isto não é o que os aplicativos do dia a dia devem usar. </para> + +<para +>Eu escrevi um aplicativo chamado streamsound que envia dados em fluxo para o &arts;. Aqui ele está rodando com prioridade de tempo real (sem problemas), e um pequeno plugin do lado servidor (escalonamento de volume e clipping): </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 um deles está enviando fluxo com 3 fragmentos de 1024 bytes (18 ms). Existes três clientes diferentes rodando simultaneamente. Eu sei que isto parece um pouco demais, mas como eu disse: pegue um perfil e descubra qual o custo do tempo, e se gostar, melhore-o. </para> + +<para +>No entanto, eu não pensei em usar fluxos que sejam realísticos ou façam sentido. Para tomar isto mais extremo, eu experimentei o que aconteceria com a mais baixa latência possível. Resultado: você pode fazer um fluxo sem interrupções com um aplicativo cliente, se você usar 2 fragmentos de 128 bytes entre o aRts e a placa de som, e entre o aplicativo cliente e o aRts. Isto significa que você tem uma latência máxima total de 128*4/44100*4 = 3ms, onde 1,5 ms é gerado devido a E/S da placa de some e 1,5 ms é gerado pela comunicação com o &arts;. Ambos os aplicativos precisam rodar em tempo real. </para> + +<para +>Mas: isto custo uma grande quantidade de <acronym +>CPU</acronym +>. Este exemplo custou cerca de 45% do meu P-II/350. Eu também começaria a ter problemas, se você iniciasse outro aplicativo, movesse janelas na sua tela do X11 ou realizasse acessos de E/S ao disco. Tudo isso são custos do kernel. O problema é que o agendamento de dois ou mais aplicativos com prioridade de tempo real custa uma enorme quantidade de esforço, também, ainda mais se eles se comunicam, notificam outros aplicativos, &etc;. </para> + +<para +>Finalmente, um exemplo da vida real. Um &arts; com o artsd e um artscat (um cliente de fluxo) rodando 16 fragmentos de 4096 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 +>Barramentos</title> + +<para +>Barramentos são conexões construídas dinamicamente que transferem áudio. Basicamente, existems alguns uplinks e alguns downlinks. Todos os sinais a partir dos uplinks são adicionados e enviados para os downlinks. </para> + +<para +>Barramentos como os atualmente implementados operam em estéreo, logo você somente pode transferir dados estéreo pelos barramentos. Se você deseja usar dados monos, bem, transfira-os somente em um canal e configure o outro para zero ou outro valor. O que você precisa fazer é criar um ou mais objetos Synth_BUS_UPLINK e dar-lhes um nome de barramento, para o qual eles devem falar (⪚ <quote +>audio</quote +> ou <quote +>bateria</quote +>). Simplesmente atravesse dados por eles. </para> + +<para +>Então, você precisará criar um ou mais objetos Synth_BUS_DOWNLINK, e dizer-lhes o nome do barramento (<quote +>audio</quote +> ou <quote +>bateria</quote +> ... se ele corresponder, os dados serão obtidos através dele), e os dados misturados serão expelidos novamente. </para> + +<para +>Os uplinks e downlinks pode residir em estruturas diferentes.Você pode ter uma estrutura em um &arts-builder; diferente rodando e iniciando um uplink e receber dados de outro com um downlink. </para> + +<para +>O que é legal a respeito dos barramentos é que eles são totalmente dinâmicos. Clientes podem conectar-se às saídas e entradas em tempo de execução. E não ocorre nenhuma interferência ou ruído quando isto acontece. </para> + +<para +>É claro, você não deve conectar a saída a um cliente tocando um sinal, uma vez que provavelmente ele não deve estar com seu nível no zero ao pludar-se ao barramento, e então ele irá gerar um ruído. </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 +>Comerciante</title> + +<para +>O &arts;/&MCOP; se sustentam pesadamente na divisão das coisas em pequenos componentes. Isto torna as coisas mais flexíveis, de modo que você possa extender o sistema facilmente adicionando novos componentes, que implementam novos efeitos, formatos de arquivos, osciladores, elementos GUI, ... Como quase tudo é um componente, quase tudo pode ser extendido facilmente, sem mudar os códigos fonte existentes. Novos componentes pode ser simplesmente carregados dinamicamente para incrementar aplicativos já existentes. </para> + +<para +>No entanto, para fazer este trabalho, duas coisas são necessárias: </para> + +<itemizedlist> + +<listitem> +<para +>Componentes deve anunciar-se a si próprios - eles deve descrever que grandes coisas eles oferecem, de modo que os aplicativos sejam capazes de usá-los. </para> +</listitem> + +<listitem> +<para +>Aplicativos devem ativamente porcurar por componentes que eles podem usar, ao invés de usar sempre a mesma coisa para alguma tarefa. </para> +</listitem> + +</itemizedlist> + +<para +>A combinação disto: componentes que dizem <quote +>eu estou aqui, eu sou legal, use-me</quote +>, e aplicativos (ou se você desejar, outros componentes) que saem e procuram quais componentes eles podem usar para realizar alguma coisa, é chamada de comércio. </para> + +<para +>Os componentes &arts; descrevem a si mesmos especificando valores que eles <quote +>suportam</quote +> para propriedades. Uma propriedade típica para um componente de carregamento de arquivo pode ser a extensão dos arquivos que ele pode processar. Valores típicos podem ser <literal role="extension" +>wav</literal +>, <literal role="extension" +>aiff</literal +> ou <literal role="extension" +>mp3</literal +>. </para> + +<para +>De fato, cada componente pode optar por oferecer muitos valores diferentes para uma propriedade. Assim um componente simples pode oferecer leitura tanto para o <literal role="extension" +>wav</literal +> como para arquivos <literal role="extension" +>aiff</literal +>, especificando que ele suporta estes valores para a propriedade <quote +>Extension</quote +>. </para> + +<para +>Para fazer isso, um componente deve colocar um arquivo <literal role="extension" +>.mcopclass</literal +> no local apropriado, contendo as propriedades que ele suporta, para nosso exemplo, ele pode se parecer com isto (e deve ser instalado em <filename +><replaceable +>diretoriocomponente</replaceable +>/Arts/WavPlayObject.mcopclass</filename +>): </para> + +<programlisting +>Interface=Arts::WavPlayObject,Arts::PlayObject,Arts::SynthModule,Arts::Object +Author="Stefan Westerfeld <stefan@space.twc.de>" +URL="http://www.arts-project.org" +Extension=wav,aiff +MimeType=audio/x-wav,audio/x-aiff +</programlisting> + +<para +>É importante que o nome do arquivo <literal role="extension" +>.mcopclass</literal +> também informe como a interface do componente é chamada. O comerciante não procura por conteúdo em tudo, se o arquivo (como o daqui) é chamado <filename +>Arts/WavPlayObject.mcopclass</filename +>, a interface do componente é chamada <interfacename +>Arts::WavPlayObject</interfacename +> (módulos mapeam para pastas). </para> + +<para +>Para procurar por componentes, existem duas interfaces (que estão definidas no <filename +>core.idl</filename +>, logo você deve possuí-las em cada aplicativo), chamadas <interfacename +>Arts::TraderQuery</interfacename +> e <interfacename +>Arts::TradeOffer</interfacename +>. Para você ir <quote +>às compras</quote +> de componentes como este: </para> + +<orderedlist> +<listitem> +<para +>Crie um objeto de consulta: </para> +<programlisting +>Arts::TraderQuery query; +</programlisting> +</listitem> + +<listitem> +<para +>Especifique o que deseja. Como você viu acima, os componentes descrevem a si mesmos usando propriedades, para as quais eles oferecem determinados valores. Assim a especificação do que você deseja é feita selecionando componentes que suportam um determinado valor para um propriedade. Isto é feito usando o método supports de um TraderQuery: </para> + +<programlisting +>query.supports("Interface","Arts::PlayObject"); + query.supports("Extension","wav"); +</programlisting> +</listitem> + +<listitem> +<para +>Finalmente, realize a consulta usando o método query. Então, você (com um pouco de sorte) obterá algumas ofertas: </para> + +<programlisting +>vector<Arts::TraderOffer> *offers = query.query(); +</programlisting> +</listitem> + +<listitem> +<para +>Agora você pode examinar o que encontrou. O importante é o método interfaceName do TradeOffer, que lhe dirá o nome do componente, que corresponde à consulta. Você pode também encontrar as propriedades pelo getProperty. O seguinte código simplesmente interagirá com todos os componentes, imprimirá seus nomes de interface (que podem ser usados para criação), e escluirá os resultados da consulta posteriormente: </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 este tipo de serviço de comércio ser útil, é importante que algum modo exista um acordo sobre quais tipos de propriedades os componentes devem normalmente definir. É essencial que mais ou menos todos os componentes em uma determinada área use o mesmo conjunto de propriedades para descreverem a si mesmos (e o mesmo conjunto de valores onde aplicável), de modo que os aplicativos (ou outros componentes) sejam capazes de encontrá-los. </para> + +<para +>Author (tipo string, opcional): Isto pode ser usada para em última instância fazer com que o mundo saiba que você escreveu algo. Você pode escrever qualquer coisa que desejar aqui, sendo que um endereço eletrônico é logicamente útil. </para> + +<para +>Buildable (tipo booleano, recomendado): Isto indica se o componente é utilizável com ferramentas <acronym +>RAD</acronym +> (como o &arts-builder;) que usa componentes atribuindo propriedades e conectando portas. É recomendado configura este valor para verdadeiro para a maioria dos componentes de processamento de sinal (como filtros, efeitos, osciladores, ...) e para todas as outras coisas que podem ser usadas em <acronym +>RAD</acronym +> como forma, mas não para material interno como por exemplo o <interfacename +>Arts::InterfaceRepo</interfacename +>. </para> + +<para +>Extension (tipo string, usado quando relevante): Tudo relacionado com os arquivos deve considerar usar isto. Você deve colocar a versão em caixa baixa da extensão do arquivo sem o <quote +>.</quote +> aqui, assim algo como <userinput +>wav</userinput +> deve ser o suficiente. </para> + +<para +>Interface (tipo string, necessário): Isto deve incluir a lista completa das interfaces (úteis) que seu componente suporta, provavelmente incluindo a <interfacename +>Arts::Object</interfacename +> e se aplicável a <interfacename +>Arts::SynthModule</interfacename +>. </para> + +<para +>Language (tipo string, recomendado): Se você deseja que seu componente seja carregado dinamicamente, você precisa especificar a linguagem aqui. Atualmente, o único valor permitido é <userinput +>C++</userinput +> o que significa que o componente foi escrito com a <acronym +>API</acronym +> normal do C++. Se você fizer isso, você também precisará configurar a propriedade <quote +>Library</quote +> abaixo. </para> + +<para +>Library (tipo string, usado quando relevante): Componentes escritos em C++ podem ser carregados dinamicamente. Para fazer isso, você deve compilá-los em uma biblioteca carregada dinamicamente pelo módulo libtool (<literal role="extension" +>.la</literal +>). Aqui você pode especificar o nome do arquivo <literal role="extension" +>.la</literal +> que contém seu componente. Lembre de usar REGISTRO_IMPLEMENTAÇÃO (como sempre). </para> + +<para +>MimeType (tipo string, usado quando relevante): Tudo que lida com arquivos deve considerar usar isto. Você deve colocar a versão em caixa baixa do tipo mime padrão aqui, por exemplo <userinput +>audio/x-wav</userinput +>. </para> + +<para +>&URL; (tipo string, opcional): Se você deseja que as pessoas saibam onde elas podem encontrar uma nova versão do componente (ou uma página web ou qualquer coisa), você pode fazer isto aqui. Isto deve ser uma &URL; padrão &HTTP; ou &FTP;. </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 +>Espaço de nomes no &arts;</title> + +<sect2 id="namespaces-intro"> +<title +>Introdução</title> + +<para +>Cada declaração de espaço de nomes corresponde a uma declaração de <quote +>módulo</quote +> no &IDL; do &MCOP;. </para> + +<programlisting +>// mcop idl + +module M { + interface A + { + } +}; + +interface B; +</programlisting> + +<para +>Neste caso, o código gerado em C++ para o fragmento &IDL; deve se parecer com isto: </para> + +<programlisting +>// cabeçalho C++ + +namespace M { + /* declaração de A_base/A_skel/A_stub e similar*/ + class A { // Classe de referência Smartwrapped + /* [...] */ + }; +} + +/* declaração de B_base/B_skel/B_stub e similar */ +class B { + /* [...] */ +}; +</programlisting> + +<para +>Assim quando referenciando as classes a partir do exemplo acima em seu código C++, você deverá escrever <classname +>M::A</classname +>, mas somente B. No entanto, você pode é claro usar <quote +>using M</quote +> em algum lugar como qualquer espaço de nomes em C++. </para> + +</sect2> + +<sect2 id="namespaces-how"> +<title +>Como o &arts; usa o espaço de nomes</title> + +<para +>Existe um espaço de nomes global chamado <quote +>Arts</quote +>, que todos os programas e bibliotecas que se baseiam no próprio &arts; usam para colocar suas declarações. Isto significa que ao escrever código C++ que depende do &arts;, você normalmente deve prefixar cada classe que usar com <classname +>Arts::</classname +>, como a seguir: </para> + +<programlisting +>int main(int argc, char **argv) +{ + Arts::Dispatcher dispatcher; + Arts::SimpleSoundServer server(Arts::Reference("global:Arts_SimpleSoundServer")); + + server.play("/var/foo/somefile.wav"); +</programlisting> + +<para +>A outra alternativa é escrever usando uma vez, como isto: </para> + +<programlisting +>using namespace Arts; + +int main(int argc, char **argv) +{ + Dispatcher dispatcher; + SimpleSoundServer server(Reference("global:Arts_SimpleSoundServer")); + + server.play("/var/foo/somefile.wav"); + [...] +</programlisting> + +<para +>Em arquivos &IDL;, você não tem exatamente uma opção. Se você está escrevendo código que se baseia no &arts; propriamente dito, você terá que colocá-lo em módulos do &arts;. </para> + +<programlisting +>// Arquivo IDL para código aRts: +#include <artsflow.idl> +module Arts { // coloque-o no espaço de nome Arts + interface Synth_TWEAK : SynthModule + { + in audio stream invalue; + out audio stream outvalue; + attribute float tweakFactor; + }; +}; +</programlisting> + +<para +>Se você escrever código que não se baseia no próprio &arts;, você não deve colocá-lo no espaço de nomes <quote +>Arts</quote +>. No entanto, você pode criar seu próprio espaço de nomes se desejar. De qualquer maneira, você terá que prefixas classes que você usa do &arts;. </para> + +<programlisting +>// Arquivo IDL para código que não se baseia no aRts: +#include <artsflow.idl> + +// escrever sem declaração de módulo, e então as classes geradas +// não usarão um espaço de nomes: +interface Synth_TWEAK2 : Arts::SynthModule +{ + in audio stream invalue; + out audio stream outvalue; + attribute float tweakFactor; +}; + +// no entando, você pode também escolher seu próprio espaço de nomes, se dejar, se você +// escrever um aplicativo "PowerRadio", você pode por exemplo fazer algo como isto: +module PowerRadio { + struct Station { + string name; + float frequency; + }; + + interface Tuner : Arts::SynthModule { + attribute Station station; // no need to prefix Station, same module + out audio stream left, right; + }; +}; +</programlisting> + +</sect2> + +<sect2 id="namespaces-implementation"> +<title +>Mecanismos internos: Como a Implementação Funciona</title> + +<para +>Frequentemente, nas interfaces, moldes, assinaturas de método e similares, o &MCOP; precisa referenciar nomes de tipos de interfaces. Eles são representados como string nas estruturas de dados comuns do &MCOP;, enquanto o espaço de nomes é sempre representado completamente no estilo C++. Isto significa que os strings devem conter <quote +>M::A</quote +> e <quote +>B</quote +>, seguindo os exemplos acima. </para> + +<para +>Observe que isto se aplica mesmo se dentro do texto &IDL; os qualificadores de espaço de nomes não forem fornecidos, uma vez que o contexto torna claro qual espaço de nomes a interface <interfacename +>A</interfacename +> esta usando. </para> + +</sect2> +</sect1> + +<sect1 id="threads"> +<title +>Linhas de execução no &arts;</title> + +<sect2 id="threads-basics"> +<title +>Fundamentos</title> + +<para +>Usar linhas de execução não é possível em todas as plataformas. Isto é porque o &arts; foi originalmente escrito sem usar nenhum tipo de linha de execução. Para quase todos os problemas, para cada solução em linha de execução do problema, existe uma solução que não usa as linhas de execução e que faz a mesma coisa. </para> + +<para +>Por exemplo, ao invés de colocar a saída de áudia em uma linha de execução separada, e torná-la em bloco, o &arts; usa saída de áudio sem estar em blocos, e decide quando escrever o próximo fragmento de dados usando o <function +>select()</function +>. </para> + +<para +>No entanto, o &arts; (nas versões mais recentes) fornece ao menos suporte para pessoas que desejam implementar seus objetos usando linhas de execução. Por exemplo, se você já tiver um código para um tocador <literal role="extension" +>mp3</literal +>, e o código espera que o decodificador <literal role="extension" +>mp3</literal +> se execute em uma linha de execução separada, isto é normalmente a coisa mais fácil para manter este desenho. </para> + +<para +>A implementação do &arts;/&MCOP; foi construída compartilhando o estado entre objetos separados de uma maneira óbvia e não-óbvia. Uma pequena lista de estados compartilhados inclui: </para> + +<itemizedlist> +<listitem +><para +>O objeto Dispatcher que faz a comunicação &MCOP;. </para> +</listitem> + +<listitem> +<para +>O contador Reference (Smartwrappers). </para> +</listitem> + +<listitem> +<para +>O IOManager que faz um temporizador e relógios fd. </para> +</listitem> + +<listitem> +<para +>O ObjectManager que cria objetos e carrega plugins dinamicamente. </para> +</listitem> + +<listitem> +<para +>O FlowSystem que chama o calculateBlock em situações apropriadas. </para> +</listitem> +</itemizedlist> + +<para +>Todos os objetos acima não esperam ser usados simultaneamente (&ie; chamados a partir de linhas de execução separadas ao mesmo tempo). Geralmente existem duas maneiras de resolver isto: </para> + +<itemizedlist> +<listitem> +<para +>Obrigar a chamada de qualquer função sobre estes objetos obter um travamento antes de usá-los. </para> +</listitem> + +<listitem> +<para +>Criar estes objetos realmente seguros para linhas de execução e/ou criar instâncias por linha de execução deles. </para> +</listitem> +</itemizedlist> + +<para +>O &arts; segue a primeira abordagem: você precisará um travamento sempre que você conversar com qualquer um destes objetos. A segundo abordagem é mais difícil de fazer. Um código que tenta atingir isto está disponível em <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 +>, mas por enquanto, a abordagem minimalista provavelmente funcionará melhor, e causará menos problemas com os aplicativos existentes. </para> + +</sect2> +<sect2 id="threads-locking"> +<title +>Quando/como obter a trava?</title> + +<para +>Você pode obter/liberar a trava com as duas funções: </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 +>Geralmente, você não precisa obter a trava (e você não deverá tentar fazer isso), se ela já está presa. Uma lista das condições de quando este é o caso é: </para> + +<itemizedlist> +<listitem> +<para +>Você recebeu uma chamada de retorno do IOManager (timer ou fd). </para> +</listitem> + +<listitem> +<para +>Você obteve chamada através de alguma solicitação &MCOP;. </para> +</listitem> + +<listitem> +<para +>Você é chamando a partir do NotificationManager. </para> +</listitem> + +<listitem> +<para +>Você é chamado a partir do FlowSystem (calculateBlock) </para> +</listitem> +</itemizedlist> + +<para +>Existem algumas exceções destas funções, as quais você somente pode chamar na linha de execução principal, e por esta razão você nunca precisará de uma trava para chamá-las: </para> + +<itemizedlist> +<listitem> +<para +>Construtor/destrutor do 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 +>Mas é isto. Para tudo o mais que é de algum modo relacionado com o &arts;, você precisará de obter uma trava, e liberá-la quando tiver terminado. Sempre. Aqui está um exemplo simples: </para> + +<programlisting +>class SuspendTimeThread : Arts::Thread { +public: + void run() { + /* + * você precisa desta trava porque: + * - construir uma referência precisa de uma trava (como global: irá para + * o gerenciador de objeto, que deve por sua vez precisar do objeto + * GlobalComm para procurar aonde conectar-se) + * - atribuir um smartwrapper precisa de uma trava + * - construir um objeto a partir do reference precisa de uma trava (porque ele + * pode precisar conectar-se a um servidor) + */ + Arts::Dispatcher::lock(); + Arts::SoundServer server = Arts::Reference("global:Arts_SoundServer"); + Arts::Dispatcher::unlock(); + + for(;;) { /* + * você precisa de uma trava aqui, porque + * - dereferenciar um smartwrapper precisa de uma trava (porque ele pode + * fazer uma criação relaxada) + * - fazer uma invocação MCOP precisa de uma trava + */ + Arts::Dispatcher::lock(); + long seconds = server.secondsUntilSuspend(); + Arts::Dispatcher::unlock(); + + printf("seconds until suspend = %d",seconds); + sleep(1); + } + } +} +</programlisting> + + +</sect2> + +<sect2 id="threads-classes"> +<title +>Classes relacionadas às linhas de execução</title> + +<para +>As seguintes classes relacionadas a linhas de execução estão atualmente disponíveis: </para> + +<itemizedlist> +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Thread.html" +><classname +> Arts::Thread</classname +></ulink +> - que encapsula uma linha de execução. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__Mutex.html" +> <classname +>Arts::Mutex</classname +></ulink +> - que encapsula um mutex. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__ThreadCondition.html" +> <classname +>Arts::ThreadCondition</classname +></ulink +> - que fornece suporte para levantar linhas de execução que estão esperando por uma determinada condição para tornar-se verdadeira. </para> +</listitem> + +<listitem> +<para +><ulink url="http://www.arts-project.org/doc/headers/Arts__SystemThreads.html" +><classname +>Arts::SystemThreads</classname +></ulink +> - que encapsula a camada de nível de execução do sistema operacional (que oferece algumas funções úteis para os programadores de aplicativos). </para> +</listitem> +</itemizedlist> + +<para +>Veja os links para documentação. </para> + +</sect2> +</sect1> + +<sect1 id="references-errors"> +<title +>Referências e Manipulação de Erros</title> + +<para +>As referências do &MCOP; são um dos conceitos mais centrais na programação &MCOP;. Esta seção tentará descrever como exatamente referências são usadas, e especialmente também tentará cobrir os casos de falha (quebras do servidor). </para> + +<sect2 id="references-properties"> +<title +>Propriedades básicas das referências</title> + +<itemizedlist> +<listitem> +<para +>Um referência &MCOP; não é um objeto, mas uma referência para um objeto: Mesmo que a declaração a seguir <programlisting> + Arts::Synth_PLAY p; +</programlisting +> pareça uma definição de um objeto, ela somente declara uma referência para um objeto. Como programador em C++, você deve também pensar nela como Synth_PLAY *, um tipo de ponteiro para um objeto Synth_PLAY. Isto quer dizer especialmente que p pode ser a mesma coisa que um ponteiro NULL. </para> +</listitem> + +<listitem> +<para +>Você pode criar uma referência NULL atribuindo-a explicitamente </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); +</programlisting> +</listitem> + +<listitem> +<para +>Invocar coisas em uma referência NULL gera um core dump </para> +<programlisting +>Arts::Synth_PLAY p = Arts::Synth_PLAY::null(); + string s = p.toString(); +</programlisting> +<para +>causará um core dump. Comparando isto a um ponteiro, isto é essencialmente o mesmo que <programlisting> + QWindow* w = 0; + w->show(); +</programlisting +> que todo programador C++ saberia evitar. </para> +</listitem> + +<listitem> +<para +>Objetos não inicializados tentam criar relaxadamente ele mesmo no primeiro uso </para> + +<programlisting +>Arts::Synth_PLAY p; + string s = p.toString(); +</programlisting> +<para +>é um pouco diferente que dereferenciar um ponteiro NULL. Você não disse o objeto o que ele é, e agora você tenta usá-lo. A suposição aqui é que você deseja ter uma nova instância local do objeto Synth::PLAY. É claro que você deve ter desejado algo como isso (como criar o objeto em algum outro local, ou usar um objeto remoto existente). No entanto, é um atalho conveniente para criar objetos. A criação relaxada não funcionará uma vez que você atribua algo mais (como uma referência null). </para> + +<para +>O equivalente em termos de C++ deve ser <programlisting> + QWidget* w; + w->show(); +</programlisting +> que obviamente em C++ocasiona falhas de segmentação. Assim isto é diferente aqui. Esta criação relaxada é um truque especialmente porque não é necessário que uma implementação para sua interface exista. </para> + +<para +>Por exemplo, considere algo abstrato como um Arts::PlayObject. Existem certamente objetos concretos como PlayObjects para tocar mp3s ou wavs, mas <programlisting> + Arts::PlayObject po; + po.play(); +</programlisting +> certamente falhará. O problema é que apesar da criação relaxada dar um pontapé inicial, e tentar criar um PlayObject, ela falha, porque existem somente coisas como Arts::WavPlayObject e semelhantes. Assim, use a criação relaxada somente quando tiver certeza que uma implementação existe. </para> +</listitem> + +<listitem> +<para +>Referências podem apontar para o mesmo objeto </para> + +<programlisting +>Arts::SimpleSoundServer s = Arts::Reference("global:Arts_SimpleSoundServer"); + Arts::SimpleSoundServer s2 = s; +</programlisting> + +<para +>cria duas referências para o mesmo objeto. Isto não copia nenhum valor, e não cria dois objetos. </para> +</listitem> + +<listitem> +<para +>Todos objetos são referências contadas. Assim uma vez que um objeto não é mais referenciado, ele é excluído. Não existe maneira de excluir explicitamente um objeto, no entanto, você pode usar algo como isto <programlisting> + Arts::Synth_PLAY p; + p.start(); + [...] + p = Arts::Synth_PLAY::null(); +</programlisting +> para fazer que o objeto Synth_PLAY vá embora e termine. Especialmente, nunca deve ser necessário usar um novo e excluir ao mesmo tempo com referências. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="references-failure"> +<title +>A causa da falha</title> + +<para +>Com referências podem apontar para objetos remotos, os servidores contendo estes objetos podem cair. O que acontece então? </para> + +<itemizedlist> + +<listitem> +<para +>Uma queda de servidor não muda se uma referência é uma referência nula. Isto significa que se <function +>foo.isNull()</function +> era <returnvalue +>true</returnvalue +> antes do servidor cair então ela também será <returnvalue +>true</returnvalue +> após o servidor cair (o que está claro). Isto também significa que se <function +>foo.isNull()</function +> era <returnvalue +>false</returnvalue +> antes do servidor cais (foo referenciada a um objeto) então ela também será <returnvalue +>false</returnvalue +> após o servidor cair. </para> +</listitem> + +<listitem> +<para +>Invocar métodos em uma referência válida permanece seguro. Suponhamos que o servidor contendo o objeto calc caia. Chamar ainda coisas como <programlisting> + int k = calc.subtract(i,j) +</programlisting +> será seguro. Obviamente a subtração terá que retornar alguma coisa aqui, o que não poderá acontecer porque o objeto remoto não existe mais. Neste caso (k == 0) será verdadeiro. Geralmente, operações tentam retornar algo <quote +>neutro</quote +> como resultado, como 0,0, uma referência nula para objetos ou strings vazios, quando o objeto não mais existe. </para> +</listitem> + +<listitem> +<para +>Verificar <function +>error()</function +> revele se alguma coisa funcionou. </para> + +<para +>No caso acima, <programlisting> + int k = calc.subtract(i,j) + if(k.error()) { + printf("k não é i-j!\n"); + } +</programlisting +> imprimirá <computeroutput +>k não é i-j</computeroutput +> se a invocação remota não funcionar. Caso contrário, <varname +>k</varname +> é realmente o resultado da operação de subtração conforme executada pelo objeto remoto (sem queda do servidor). No entando, para métodos fazendo coisas como excluir um arquivo, você não pode saber com certeze se isto realmente ocorreu. É claro que isto aconteceu se <function +>.error()</function +> é <returnvalue +>false</returnvalue +>. No entanto, se <function +>.error()</function +> é <returnvalue +>true</returnvalue +>, existem duas possibilidades: </para> + +<itemizedlist> +<listitem> +<para +>O arquivo foi excluído, e o servidor caí logo após excluí-lo, mas antes de transferir o resultado. </para> +</listitem> + +<listitem> +<para +>O servidor caiu antes de ser capaz de excluir o arquivo. </para> +</listitem> +</itemizedlist> +</listitem> + +<listitem> +<para +>Usar invocações aninhadas é perigoso em programas resistentes à queda </para> + +<para +>Usar algo como <programlisting> + window.titlebar().setTitle("foo"); +</programlisting +> não é uma boa idéia. Suponhamos que você saiba que a janela contéum uma referência válida de Window. Suponhamos que você saiba que <function +>window.titlebar()</function +> retornará uma referência a uma barra de título porque o objeto Window foi implementado corretamente. No entanto, a sentença acima ainda não é segura. </para> + +<para +>O que pode acontecer é que o servidor contendo o objeto Window cairá. Então, independente de quão boa a implementação da Window seja, você obterá uma referência nula como resultado da operação window.titlebar(). E então é claro que invocar o setTitle em uma referência nula levará a uma queda também. </para> + +<para +>Assi uma variante segura disto será <programlisting> + Titlebar titlebar = window.titlebar(); + if(!window.error()) + titlebar.setTitle("foo"); +</programlisting +> adicione a manipulação apropriada de erro se desejar. Se você não confiar na implementação do Window, você pode então usar <programlisting> + Titlebar titlebar = window.titlebar(); + if(!titlebar.isNull()) + titlebar.setTitle("foo"); +</programlisting +> sendo que ambas as sentenças são seguras. </para> +</listitem> +</itemizedlist> + +<para +>Existem outras condições de falha, como uma desconexão de rede (suponhamos que você remova o cabo entre seu servidor e cliente enquanto seu aplicativo roda). No entanto este efeito é o mesmo que uma queda de servidor. </para> + +<para +>Além de tudo, esta é claro uma consideração de política de quão estritamente você tenta evitar erros de comunicação no seu aplicativo. Você deve seguir o método <quote +>se o servidor cai, nós precisamos depurar o servidor até ele nunca cair novamente</quote +>, que significa que você não precisa se incomodar com estes problemas. </para> + +</sect2> + +<sect2 id="references-internals"> +<title +>Mecanismos internos. Contagem de Referência Distribuída</title> + +<para +>Um objeto, para existir, deve pertencer a alguém. Se isto não ocorrer, ele cessará de existir (mais ou menos) imediatamente. Internamente, o dono é indicado pela chamada <function +>_copy()</function +>, que incrementa uma contagem de referência, e libera de volta pela chamada <function +>_release()</function +>. Assim que a contagem de referência atingir o zero, uma exclusão será feita. </para> + +<para +>Como variante do temo, o uso remoto é indicado pelo <function +>_useRemote()</function +>, e dissolvido pelo <function +>_releaseRemote()</function +>. Estas funções levam a uma lista a qual o servidor invoca (e assim possui o objeto). Isto é usado no caso deste servidor desconectar (&ie; uma queda, ou falha de rede), para remover referências que ainda estão nos objetos. Isto é feito em <function +>_disconnectRemote()</function +>. </para> + +<para +>Agora existe um problema. Considere um valore de retorno. Normalmente, o valor de retorno não terá mais como dono o da função de chamada. No entanto isto também não terá como dono o chamador, até a mensagem que contém o objeto seja recebida. Assim existe um tempo de objeto <quote +>sem dono</quote +>. </para> + +<para +>Agora, ao enviar um objeto, algo razoável é que tão logo ele seja recebido, ele possua um dono novamente, a menos que, novamente, o recebedor morra. No entanto isto significa que um cuidade especial precisa ser tomado com o objeto pelo menos ao enviar, provavelmente também ao receber, de modo que ele não morra de qualquer jeito. </para> + +<para +>A maneiro como o &MCOP; faz isto é através do <quote +>etiquetamento</quote +> de objetos que estão em processo de ser copiados através da rede. Antes de uma cópia iniciar, <function +>_copyRemote</function +> é chamado. Isto evita que o objeto seja descartado por enquanto (5 segundos). Uma vez que o recebedor chame <function +>_useRemote()</function +>, a etiqueta é removida novamente. Assim todos os objetos que são enviados pela rede são etiquetados antes da transferência. </para> + +<para +>Se o recebedor recebe um objeyo que está em seu servidor, é claro que ele não irá fazer um <function +>_useRemote()</function +> nele. Para este caso especial, <function +>_cancelCopyRemote()</function +> existe para remover a etiqueta manualmente. Além deste, existe também um removedor de etiqueta baseado em temporizador (no caso de queda, falha de rede). Isto é feito pela classe <classname +>ReferenceClean</classname +>. </para> + +</sect2> + +</sect1> + +<sect1 id="detail-gui-elements"> +<title +>Elementos &GUI;</title> + +<para +>Elementos &GUI; estão atualmente em estado experimental. No entanto, esta seção descreverá o que supostamente acontecerá aqui, de modo que se você é um desenvolvedor, você será capaz de entender como o &arts; lidará com &GUI;s no futuro. Existe algum código que também já está aqui. </para> + +<para +>Elementos &GUI; devem ser usados para permitir estruturas de sintetização interagir com o usuário. No caso mais simples, o usuário deverá ser capaz de modificar alguns parâmetros de uma estrutura diretamente (como um fator de ganho que é usado antes da saída final do módulo). </para> + +<para +>Em configurações mais complexas, alguém pode imaginar o usuário modificando parâmetros de grupos de estruturas e/ou estruturas ainda não rodadas, como a modificação do envelope <acronym +>ADSr</acronym +> do instrumento &MIDI; atualmente ativo. Outra coisa será configurar o nome do arquivo de algum instrumento baseado em amostra. </para +> + +<para +>Por outro lado, o usuário pode querer monitorar o que o sintetizador está fazendo. Podem existir osciloscópios, analizadores de espectro, medidores de volume e <quote +>experiências</quote +> que decifram a curva de transferência de frequência de algum módulo de filtro fornecido. </para> + +<para +>Finalmente, os elementos &GUI; devem ser capazes de controlar toda a estrutura que está rodando dentro do &arts; e como. O usuário deve ser capaz de atribuir instrumentos à canais midi, iniciar processadores de efeitos novos, configurar seu mixer principal (que é construído ele mesmo de estruturas do &arts;) para ter um canal a mais e usar outra estratégia para seus equalizadores. </para> + +<para +>Como você pode ver - os elementos <acronym +>GUI</acronym +> devem trazer todas as possibilidades de estúdio virtual que o &arts; deve simular para o usuário. É claro, eles devem também interagir facilmente com entradas midi (como os sliders debem mover se eles obtém entradas &MIDI; que também mudam como este parâmetro), e provavelmente até mesmo os eventos gerados por eles mesmos, para permitir que a interação com o usuário seja gravada através de um sequenciador. </para> + +<para +>Tecnicamente, a idéia é ter uma classe base &IDL; para todos os widgets (<classname +>Arts::Widget</classname +>), e derivar um determinado número de widgets normalmente usados a partir dela (como <classname +>Arts::Poti</classname +>, <classname +>Arts::Panel</classname +>, <classname +>Arts::Window</classname +>, ...). </para> + +<para +>Então, alguém pode implementar estes widgets usando um conjunto de ferramentas de programação, por exemplo o &Qt; ou Gtk. Finalmente, efeitos devem construir suas &GUI;s de widgets existentes. Por exemplo, um efeito freeverb poderia construir sua &GUI; a partir de cinco <classname +>Arts::Poti</classname +> e um <classname +>Arts::Window</classname +>. Assim SE existir uma implementação &Qt; para estes widgets básicos, o efeito será capaz de se exibir usando o &Qt;. Se existir uma implementação Gtk, ele também funcionará para o Gtk (e mais ou menos com aparência/funcionalidade semelhante). </para> + +<para +>Finalmente, como nós estamos usando &IDL; aqui, o &arts-builder; (ou outras ferramentas) serão capazes de conectar &GUI;s visualmente, ou auto-gerar &GUI;s fornecendos dicas para parâmetros, somente baseando-se em suas interfaces. Deverá ser relativamente simples escrever uma classe <quote +>criar &GUI; a partir da descrição</quote +>, que pega uma descrição de &GUI; (contendo vários parâmetros e widgets), e cria um objeto &GUI; a partir dela. </para> + +<para +>Baseado no &IDL; e no modelo de componentes do &arts;/&MCOP;, deve ser fácil extender os possíveis objetos que podem ser usados pelo &GUI; assim como é fáxil adicionar uma implementação de plugin como um novo filtro do &arts;. </para> + +</sect1> + +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/digitalaudio.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/digitalaudio.docbook new file mode 100644 index 00000000000..d0fe3eb41c6 --- /dev/null +++ b/tde-i18n-pt_BR/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 +>Introdução ao Áudio Digital</title> + +<para +>amostragem digital, filtros, efeitos, &etc;</para> + +</appendix> + + + diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/faq.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/faq.docbook new file mode 100644 index 00000000000..8e5a6c685d2 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/faq.docbook @@ -0,0 +1,1310 @@ +<!-- <?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 +>Perguntas e respostas</title> + +<para +>Esta seção responde algumas das perguntas frequentemente feitas sobre o &arts;. </para> + +<qandaset id="faq-general"> +<title +>Perguntas Gerais</title> + +<qandaentry> +<question> +<para +>O &kde; suporta minha placa de som para saída de áudio? </para> +</question> + +<answer> +<para +>O &kde; usa o &arts; para tocar sons, e o &arts; usa os drivers de som do kernel do &Linux;, tanto os <acronym +>OSS</acronym +> como os <acronym +>ALSA</acronym +> (usando emulação <acronym +>OSS</acronym +>). Se sua placa de som é suportada seja pelo <acronym +>ALSA</acronym +> ou pelo <acronym +>OSS</acronym +> e estiver corretamente configurada (&ie; qualquer outro aplicativo &Linux; pode gerar som), ele funcionará. Existem no entanto alguns problemas com alguns hardwares específicos, por favor leia a <link linkend="faq-hardware-specific" +>seção para problemas com hardwares específicos</link +> se você tiver problemas com o artsd em sua máquina. </para> +<para +>Entretanto, suporte para diversas outras plataformas também tem sido adicionado. Aqui está uma lista completa de como a versão mais recente do &arts; pode tocar som. Se você tiver uma plataforma não suportada, por favor considere portar o &arts; para sua plataforma. </para> + +<informaltable> +<tgroup cols="2"> +<thead> +<row> +<entry +>Método de E/S (entrada e saída) de áudio do &arts;</entry> +<entry +>Comentário</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>paud</entry> +<entry +>Suporte para Dispositivo de Áudio Pessoal AIX</entry> +</row> + +<row> +<entry +>alsa</entry> +<entry +>Drivers ALSA-0.5 e ALSA-0.9 do Linux</entry> +</row> + +<row> +<entry +>libaudioio</entry> +<entry +>Suporte para biblioteca genérica LibAudioIO que funciona no Solaris</entry> +</row> + +<row> +<entry +>nas</entry> +<entry +>Servidor de som NAS, útil para Terminais X com suporte ao NAS</entry> +</row> + +<row> +<entry +>null</entry> +<entry +>Dispositivo de áudio nulo, descarta o som silenciosamente</entry> +</row> + +<row> +<entry +>oss</entry> +<entry +>Suporte ao OSS (do inglês, Sistema de Som Aberto) (funciona no Linux, diversos BSDs e outras plataformas com os drivers OSS instalados)</entry> +</row> + +<row> +<entry +>toss</entry> +<entry +>Suporte ao OSS em linhas de execução, que funciona melhor em alguns casos onde o suporte ao OSS padrão não funciona bem</entry> +</row> + +<row> +<entry +>sgi</entry> +<entry +>Suporte ao Mídia Direta SGI para IRIX</entry> +</row> + +<row> +<entry +>sun</entry> +<entry +>Suporte ao Solaris</entry> +</row> + +</tbody> +</tgroup> +</informaltable> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Eu não consigo tocar arquivos <literal role="extension" +>wav</literal +> com o &artsd;! </para> +</question> + +<answer> +<para +>Verifique se o &artsd; está linkado ao <filename +>libaudiofile</filename +> (<userinput +><command +>ldd</command +> <parameter +>artsd</parameter +></userinput +>). Caso contrário, baixe o tdesupport, recompile tudo, e então funcionará. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Eu ouço som quando eu logo como <systemitem class="username" +>root</systemitem +> mas nenhum outro usuário tem som! </para> +</question> + +<answer> +<para +>As permissões do arquivo <filename class="devicefile" +>/dev/dsp</filename +> afetam quais usuários terão som. Para permitir que todos o usem, faça isto: </para> + +<procedure> +<step> +<para +>Logue como <systemitem class="username" +>root</systemitem +>. </para> +</step> + +<step> +<para +>Abra uma janela do &konqueror;. </para> +</step> + +<step> +<para +>Vá para a pasta <filename class="directory" +>/dev</filename +>. </para> +</step> + +<step> +<para +>Clique no arquivo <filename +>dsp</filename +> com o botão <mousebutton +>direito</mousebutton +> do mouse, e selecione propriedades. </para> +</step> + +<step> +<para +>Clique na aba <guilabel +>Permissões</guilabel +>. </para> +</step> + +<step> +<para +>Habilite as caixas de verificação <guilabel +>Leitura</guilabel +> e <guilabel +>Escrita</guilabel +> em todas as seções. </para> +</step> + +<step> +<para +>Clique em <guibutton +>OK</guibutton +>. </para> +</step> +</procedure> + +<para +>Você pode obter o mesmo efeito na janela do terminal usando o comando <userinput +><command +>chmod</command +> <option +>666</option +> <parameter +>/dev/dsp</parameter +></userinput +>. </para> + +<para +>Para restringir o acesso ao som para usuários específicos, você pode usar as permissões de grupo. Em algumas distribuições &Linux;, por exemplo o Debian/Potato, o <filename class="devicefile" +>/dev/dsp</filename +> já está como pertencente ao grupo chamado <systemitem class="groupname" +>audio</systemitem +>, de modo que tudo o que precisa fazer é adicionar os usuários a este grupo. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Isto ajuda para o &artsd;, mas e sobre o &kmix;, &kmid;, &kscd;, &etc;? </para> +</question> +<answer> + +<para +>Existem vários outros dispositivos que fornecem funcionalidades acessadas por aplicativos multimídia. Você pode tratá-los da mesma maneira, seja tornando-os acessíveis para todos, ou usando grupos para controlar o acesso. Aqui está uma lista, que pode ainda estar incompleta (se existirem também diversos dispositivos em uma forma tipo <filename class="devicefile" +>midi0</filename +>, <filename class="devicefile" +>midi1</filename +>, ..., então somente a versão 0 é listada aqui): </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 +>O que eu posso fazer se o artsd não inicia ou trava ao rodar?</para> +</question> + +<answer> +<para +>Primeiro de tudo: tente usar as configurações padrão no &kcontrol; (ou se você está iniciando manualmente, não forneça opções adicionais além talvez de <userinput +><option +>-F</option +><parameter +>10</parameter +> <option +>-S</option +><parameter +>4096</parameter +></userinput +> para latência). Especialmente <emphasis +>o full duplex é conhecido por não funcionar</emphasis +> com diversos drivers, logo tente desabilitá-lo. </para> + +<para +>Uma boa maneira de descobrir porque o &artsd; não inicia (ou trava ao rodar) é iniciá-lo manualmente. Abra uma janela do &konsole;, e faça o seguinte: </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 +>Você pode também adicionar a opção <option +>-l0</option +>, que imprimirá mais informações sobre o que está acontecendo, como isto: </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 +>Fazendo isso, você provavelmente obterá algumas informações úteis sobre porque ele não inicia. Ou, se ele trava ao fazer isto ou aquilo, você pode fazer isto ou aquilo, e ver <quote +>como</quote +> ele trava. Se você desejar relatar um erro, produzir um rastro de execução com o <command +>gdb</command +> e/ou um <command +>strace</command +> pode ajudar a encontrar o problema. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Eu posso mudar a localização do &artsd; (mover os arquivos compilados para outra pasta)?</para> +</question> + +<answer> +<para +>Você não pode mudar a localização do &arts;. O problema é que o &artswrapper; possui a localização do &artsd; compilado devido a razões de segurança. Você pode no entanto usar o arquivo <filename +>.mcoprc</filename +> (entradas TraderPath/ExtensionPath) para pelo menos fazer com que o &artsd; encontre seus componentes. Veja o <link linkend="the-mcoprc-file" +>capítulo sobre o arquivo <filename +>.mcoprc</filename +></link +> para detalhes sobre como fazer isto. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Eu posso compilar o &arts; com o gcc-3.0?</para> +</question> + +<answer> +<para +>Resposta curta: não, o &arts; não funcionará se você compilá-lo com o gcc-3.0. </para> + +<para +>Resposta longa: Na versão oficial, existem dois erros do gcc-3.0 que afetam o &arts;. O primeiro, o erro c++/2733 do gcc-3.0 é relativamente inofensivo (e tem apresentado problemas com a sentença asm). Ele quebra a compilação do convert.cc. Isto foi concertado no gcc-3.0 do CVS, e não será mais um problema com o gcc-3.0.1 e superior. Um trabalho a respeito também foi adicionado à versão CVS do KDE/aRts. </para> +<para +>O segundo erro do gcc-3.0, o c++/3145 (que é geração de código errado para alguns casos de herança virtual múltipla) é crítico. Aplicativos como o &artsd; simplesmente travarão na inicialização quando compilados com o gcc-3.0. Apesar de algum progresso ter sido feito no ramdo gcc-3.0 do CVS quando escrevia este documento, o &artsd; ainda trava muito frequentemente, imprevisivelmente. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>Que aplicativos rodam sob o &arts;?</para> +</question> +<answer> + +<para +>Obviamente, todos os aplicativos incluídos com o &kde; são compatíveis com o &arts;. Isto inclui: </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 +>Jogos do &kde; como o &kpoker; e o &ktuberling;</para +></listitem> +</itemizedlist> + +<para +>Alguns aplicativos do &kde; que ainda não foram incluídos na versão do &kde; (⪚ no kdenonbeta) também suportam o &arts;, incluindo: </para> + +<itemizedlist> +<listitem +><para +>&brahms;</para +></listitem> +<listitem +><para +><application +>Kaboodle</application +></para +></listitem> +<listitem +><para +><application +>Kdao</application +></para +></listitem> +</itemizedlist> + +<para +>Os seguintes aplicativos não-&kde; são também conhecidos por funcionar com o &arts;: </para> + +<itemizedlist> +<listitem +><para +><application +>xmms</application +> (com o plug-in do &arts;)</para +></listitem> +<listitem +><para +>Real Networks <application +>RealPlayer</application +> 8.0 (funciona com o &artsdsp;; suporte nativo ao &arts; está sendo considerado)</para +></listitem> +</itemizedlist> + +<para +>Os seguintes aplicativos são conhecidos por <emphasis +>não</emphasis +> funcionarem com o &arts;: </para> + +<itemizedlist> +<listitem +><para +>nenhum</para +></listitem> +</itemizedlist> + +<para +>Veja também as respostas e perguntas na seção em <link linkend="faq-non-arts" +>aplicativos não-&arts;</link +>. </para> + +<para +>Esta seção está incompleta -- Se você tiver informações sobre aplicativos que suportam ou não suportam, por favor envie-as ao autor de modo que ele possa incluí-las aqui. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-non-arts"> +<title +>Aplicativos Não-&arts;</title> + +<qandaentry> +<question> +<para +>Tão logo o &kde; esteja rodando, nenhum outro aplicativo pode acessar meu dispositivo de som! </para> +</question> +<answer> +<para +>Uma vez que o servidor de som &arts; usado pelo &kde; está rodando, ele está usando o dispositivo de som. Se o servidor ficar ocioso por 60 segundos, ele auto-suspendará e liberará o dispositivo automaticamente. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Você disse que ele suspende após 60 segundos, isto não funciona para mim! </para> +</question> +<answer> +<para +>Se você iniciar o artsd a partir do painel de controle do KDE, o padrão é para suspender após 60 segundos. Se você iniciar o artsd a partir da linha de comando, você precisa usar a opção -s para especificar o tempo para auto-suspensão, caso contrário, seu padrão é desabilitar o recurso de auto-suspensão. </para> +<para +>Atualmente ele não suspende quando usa o full duplex. Desligue o full duplex a partir do &kcontrol; e ele suspenderá. Desabilitar o full duplex é geralmente uma boa idéia de qualquer jeito se você usa somente o &arts; para tocar áudio e não para gravar. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Como eu possa rodar aplicativos antigos não-&arts;? </para> +</question> + +<answer> +<para +>Execute-os usando o &artsdsp;. Por exemplo, se você normalmente rodaria: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>mpg123</command +> <option +>foo.mp3</option +></userinput +></screen> + +<para +>ao invés disso use:</para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>mpg123 foo.mp3</option +></userinput +></screen> + +<para +>Isto redirecionará a saída de som para o &arts;. Este método não necessita de mudanças nos aplicativos. Se alguma coisa der errado no entanto, saiba que nem todos os recursos da placa de som são suportados, assim alguns aplicativos podem não funcionar. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Eu não posso rodar o &artsdsp; com qualquer aplicativo, ele sempre trava! </para> +</question> +<answer> +<para +>Você precisa de uma versão recente da biblioteca glibc; o &artsdsp; não funcionará de maneira confiável em algumas distribuições antigas do &Linux;. Por exemplo, no Debian 2.1 (que é baseado no glibc 2.0) ele não funciona, enquanto no Debian 2.2 (que é baseado no glibc 2.1.3) ele funciona. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Existem limitações teóricas com alguns aplicativos que os impedirão de funcionar sempre com o &artsdsp;? </para> +</question> +<answer> +<para +>Não. Usar o &artsdsp; pode causar um pouco mais de latência e uso da <acronym +>CPU</acronym +> que usando a <acronym +>API</acronym +> do &arts; diretamente. Por outro lado, qualquer aplicativo que não funcione deve ser considerado um erro do &artsdsp;. A técnica usada pelo &artsdsp; deve, se implementada corretamente, permitir <emphasis +>qualquer</emphasis +> aplicativo funcionar com ele (incluindo aplicativos complexos como o <application +>Quake</application +> 3). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>O que eu posso fazer se um aplicativo não funciona com o &artsdsp;? </para> +</question> +<answer> +<para +>Você pode esperar que o &artsd; suspenda ou usar o comando <userinput +><command +>artsshell</command +> <option +>suspend</option +></userinput +> para pedir ao servidor que ele se suspenda. Você somente será capaz de suspender o servidor se nenhum aplicativo &arts; estiver atualmente o usando, e nenhum aplicativo &arts; será capaz de rodar quando o servidor estiver suspenso. </para> + +<para +>Se o servidor estiver ocupado, uma maneira bruta mas efetica de obter o rid dele é: </para> + + +<screen +><prompt +>%</prompt +> <userinput +><command +>killall</command +> <option +>artsd</option +> ; <command +>killall</command +> <option +>artswrapper</option +></userinput> +<lineannotation +>Agora inicie seu próprio aplicativo.</lineannotation> +<prompt +>%</prompt +> <userinput +><command +>kcminit</command +> <option +>arts</option +></userinput +> +</screen> + +<para +>Qualquer aplicativo &arts; atualmente em execução deverá cair, no entanto, uma vez que você mate o servidor. </para> +</answer> +</qandaentry> +<qandaentry> +<question> +<para +>E os aplicativos escritos para o &kde; 1.x? </para> +</question> +<answer> +<para +>Se você estiver rodando aplicativos do &kde; 1.x, que produzem som através do servidor de áudio do &kde; 1, você precisará rodar o <application +>kaudioserver</application +> para fazê-los funcionar. Você pode iniciar o <application +>kaudioserver</application +> da mesma maneira que outros aplicativos não-&arts;: </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>kaudioserver</option +></userinput +> +</screen> + +<para +>Você precisará ter instalado o kaudioserver (a partir do código de onde você obteve seus aplicativos do &kde; 1.x) - ele fica no &kde; 1.x, não no &kde; 2. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>E os aplicativos usando o daemon do som do enlightened, <acronym +>ESD</acronym +>? </para> +</question> +<answer> +<para +>A observação é semelhante a feita com o <application +>kaudioserver</application +>. Como os aplicativos precisarão de um servidor esd rodando, você pode iniciar o <command +>esd</command +> através do &artsdsp;, e cada aplicativo compatível com o <acronym +>ESD</acronym +> deve funcinar bem, como isto: </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsdsp</command +> <option +>esd</option +></userinput +> +</screen> +<para +>Versões mais novas do aRts ( +>= 1.2.0) também pode usar o daemon de som enlightened ao invés de acessar diretamente a placa de som. Na linha de comando, você pode usar a opção -a, como </para> +<screen +><prompt +>%</prompt +> <userinput +><command +>artsd</command +> <option +>-a esd</option +></userinput +> +</screen> +<para +>para ter suporte ao EsounD, e no KDE, você pode usar o kcontrol para fazer com que o artsd use o esd através de Som -> Servidor de Som -> E/S de Som. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-latency"> +<title +>Latência</title> + +<qandaentry> +<question> +<para +>Eu algumas vezes escuto pausas curtas ao ouvir uma música, isto é um erro? </para> +</question> +<answer> +<para +>Isto não é propriamente um erro, mas causado pelo fato do kernel do &Linux; não ser muito bom no agendamento em tempo real. Existem situações onde o &arts; não será capaz de manter uma execução constante. Você pode, no entanto, habilitar permissões de tempo real (através do &kcontrol;), e usar uma configuração de latência maior 9como <guilabel +>250ms</guilabel +> ou <guilabel +>não se preocupar</guilabel +>), o que deverá melhorar a situação. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Qual o efeito da configuração do tempo de resposta? </para> +</question> +<answer> +<para +>O texto de ajuda para esta configuração no &kcontrol; pode ser mau entendido. Um valor menor significa que o &arts; levará menos tempo para responder a eventos externos (&ie; o tempo que ele leva entre fechar uma janela e ouvir o som tocado pelo &artsd;). Isto também usará mais recursos da <acronym +>CPU</acronym +>, e causará uma maior probabilidade de saídas.</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>Existe alguma coisa que eu possa fazer para evitar pausas? </para> +</question> +<answer> +<para +>Para usuários de discos rígidos <acronym +>IDE</acronym +>, você pode usar o comando <command +>hdparm</command +> para colocar seu drive <acronym +>IDE</acronym +> no modo <acronym +>DMA</acronym +>. Um alerta: isto não funciona para todo hardware, e pode fazer com que o disco rígido reinicie ou em casos raros, perca dados. Leia a documentação do comando <command +>hdparm</command +> para mais detalhes. Eu tenho usado com sucesso o seguinte comando: </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 +>Você precisa rodar isto após cada boot, assim você pode desejar colocá-lo no script de inicialização do sistema (como fazer isto é específico da distribuição, no Debian &Linux; ele é colocado normalmente no <filename +>/etc/rc.boot</filename +>). </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>A prioridade de tempo real parece não ter nenhum efeito para mim? </para> +</question> +<answer> +<para +>Verifique se o artswrapper está realmente instalado com suid <systemitem class="username" +>root</systemitem +>, como deveria estar. Muitas distribuições (o SuSE7.x por exemplo) não fazem isto. Você pode verificar isto usando: ls -l $(which artswrapper). Bom: <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 +> Ruim: <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 +> Se você não tiver o the s, você pode obtê-lo usando: <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 +>Se você tornar o &artswrapper; SUID <systemitem class="username" +>root</systemitem +>, ele provavelmente melhorará a qualidade da reprodução do seu áudio reduzindo intervalos na música. No entanto, isto também aumento o risco que um erro no código ou um usuário malicioso possa travar ou talvez danificar sua máquina. Além disso, em máquinas com vários usuários, priorizar áudio de alta qualidade pode resultar na deterioração do desempenho para os usuários que estão tentando fazer um uso mais <quote +>produtivo</quote +> da máquina.</para> + +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>Porque o &artsd; toma tanto tempo da <acronym +>CPU</acronym +>? </para> +</question> +<answer> +<para +>Verifique suas configurações de tempo de resposta. No entanto, a versão atual ainda não é realmente otimizada. Isto melhorará, e até agora nenhuma previsão real pode ser feita do quão rápido o &artsd; pode ou não ser. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-network"> +<title +>Transparência de Rede</title> + +<qandaentry> +<question> +<para +>O que eu preciso para transparência de rede? </para> +</question> +<answer> +<para +>Habilite-a nas configurações do <guilabel +>Servidor de Som</guilabel +> no &kcontrol; (<guilabel +>habilite o servidor X11 para informações seguras</guilabel +> e <guilabel +>transparência de rede</guilabel +>). Então copie seu <filename +>.mcoprc</filename +> para todas as máquinas que planeja usar transparência de rede. Logue novamente. Certifique-se de que as máquinas que interagirem conhecem as outras pelo nome (&ie; elas devem possuir nomes resolvíveis ou estarem no <filename +>/etc/hosts</filename +>). </para> + +<para +>Isto deve ser tudo o que você precisa fazer. No entanto, se isto ainda não funcionar aqui vão mais alguns detalhes adicionais. O processo do servidor de som &arts;, o &artsd;, somente deve rodar em uma máquina, a que tiver a placa de som onde o som será tocado. Ele pode ser iniciado automaticamente no login pelo &kde; (se você configurar isto no &kcontrol;), ou manualmente usando 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 +>O parâmetro <option +>-n</option +> é para a transparência de rede, enquanto os outros configuram a latência. </para> + +<para +>Se arquivo <filename +>.mcoprc</filename +> deve ter esta entrada: </para> + +<screen +><userinput +>GlobalComm=Arts::X11GlobalComm</userinput +> +</screen> + +<para +>em todas as máquinas envolvidas, para que a transparência de rede funcione. Isto é que é habilitado pela configuração <guilabel +>servidor X11 para informações seguras</guilabel +> do painel de controle. </para> + +<para +>Finalmente, em qualquer versão do &kde; da série 2.0.x, existe um erro que se manifesta se você não possui um conjunto de nomes de domínio. Clientes do &artsd; tentam encontrar onde conectar através da combinação <systemitem class="systemname" +><replaceable +>máquina</replaceable +>.<replaceable +>domínio</replaceable +></systemitem +>. Se seu nome de domínio for vazio, ele tentará conectar à <systemitem class="systemname" +><replaceable +>máquina</replaceable +></systemitem +>. (observe o ponto a mais). Adicionando uma entrada como esta no <filename +>/etc/hosts</filename +> (&ie; <userinput +>orion.</userinput +> se seu nome de máquina é <systemitem class="systemname" +>orion</systemitem +>) contornará o problema. </para> +</answer> +</qandaentry> + + +<qandaentry> +<question> +<para +>Como eu depuro a transparência de rede se ela não funcionar? </para> +</question> +<answer> +<para +>Considerando que você possui o código fonte do &kde;, vá para <filename class="directory" +>tdelibs/arts/examples</filename +>, e rode <userinput +><command +>make</command +> <option +>check</option +></userinput +> para compilar alguns programas, incluindo <application +>referenceinfo</application +>. Então rode </para> + +<screen +><prompt +>%</prompt +> <userinput +><command +>./referenceinfo</command +> <option +>global:Arts_SimpleSoundServer</option +></userinput +> +</screen> + +<para +>A saída indicará o nome de máquina e porta que está sendo usado pelo &arts;. Por exemplo, <computeroutput +>tcp:orion:1698</computeroutput +> o que significa que qualquer cliente que tente usar a transparência de rede deve saber como chegar à maquina <systemitem class="systemname" +>orion</systemitem +>. </para> +</answer> +</qandaentry> + +</qandaset> + +<qandaset id="faq-hardware-specific"> +<title +>Perguntas específicas de hardware</title> + +<qandaentry> +<question> +<para +>Com qual hardware o artsd não funciona bem? </para> +</question> +<answer> +<para +>Parece que existem alguns poucos drivers linux que não funcionam bem com o aRts em algumas versões do kernel. Por favor leia esta lista antes de relatar um erro. Se você achar que alguma informação nesta lista está incompleta, por favor não hesite em informar-nos. <informaltable +> <tgroup cols="4"> +<thead> +<row> +<entry +>Driver Linux / Placa de som</entry> +<entry +>Falha sob</entry> +<entry +>Funciona sob</entry> +<entry +>Comentários</entry> +</row> +</thead> + +<tbody> +<row> +<entry +>driver i810 (Intel 810 + Áudio AC97)</entry> +<entry +>2.4.9</entry> +<entry +>2.4.18, 2.2.20, driver oss comercial, alsa-0.5.12a com emulação OSS</entry> +<entry +>driver causa sobrecarga da cpu (veja abaixo)</entry> +</row> + +<row> +<entry +>chipset maestro 3/4</entry> +<entry +>2.4.9</entry> +<entry +>?</entry> +<entry +>driver causa algumas vezes sobrecarga da cpu (veja abaixo)</entry> +</row> + +<row> +<entry +>drivers aureal8820, aureal8830 do sourceforge</entry> +<entry +>2.4.17</entry> +<entry +>?</entry> +<entry +>driver dispara assertivas / causa sobrecarga da cpu (veja abaixo)</entry> +</row> + +<row> +<entry +>OSS 3.9.4g Comercial com Aureal Vortex</entry> +<entry +>?</entry> +<entry +>?</entry> +<entry +>travamento do sistema</entry> +</row> + +<row> +<entry +>ymfpci</entry> +<entry +>2.4.0, 2.4.12</entry> +<entry +>2.4.17</entry> +<entry +>driver dispara assertiva (veja abaixo)</entry> +</row> + + + +</tbody> +</tgroup> +</informaltable> +</para> +</answer> +</qandaentry> + + + +<qandaentry> +<question> +<para +>Porque existem problemas específicos de hardware e como vê-los? </para> +</question> +<answer> +<para +>O problema mais comum é que o driver não fornece ao aRts informações suficientes ou suficientemente precisas ao escrever dados de som. A maioria dos drivers OSS fornecem as informações corretas, mas nem todos. </para> +<para +>Você deve saber que alguns outros aplicativos (como o xmms) podem não precisar destes dados, e assim funcionarem corretamente com seu hardware. No entanto, o &arts; precisa destes dados, assim o artsd deve falhar. Isto ainda assim é um erro no driver, e não no &arts;. </para> +<para +>Existem dois tipos de comportamento que o artsd expõe ao ser rodado em um driver incorreto. Ele pode continuamente tentar obter novos dados, mas nunca consegí-los, o que eventualmente leva a consumir todos os recursos da CPU e reportar uma <emphasis +>sobrecarga da cpu</emphasis +> e terminar. O outro problema é que o artsd pode receber informações incorretas para processar. o artsd então <emphasis +>interromperá com uma assertiva</emphasis +> como: <screen +>artsd: audiosubsys.cc:458: void Arts::AudioSubSystem::handleIO(int): +Assertion `len == can_write' failed. +Aborted +</screen> +</para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>O que está errado no driver se eu detecto um problema de sobrecarga da cpu? </para> +</question> +<answer> +<para +>Normalmente, o artsd usa o select() para descobrir onde escrever novos dados. Então, ele usa um ioctl(...GETOSPACE...) para descobrir quantos dados escrever. Finalmente, ele escreve os dados. </para> +<para +>Um problema ocorre se o artsd é despertado sempre ou se existem quantidades mínimas de dados para escrever. A documentação do OSS especifica que o select() somente acorda um processo se existir pelo menos um fragmento para escrever. No entanto, se o artsd é acordado e não existirem dados para escrever, ou muito pouco dado, por exemplo, uma amostra, então ele ficará escrevendo pequenos pedaços de dados de áudio, o que pode ser muito custoso, e eventualmente sobrecarregar a cpu. </para> +<para +>Para corrigir isto, o driver deve acordar o artsd somente se existir um fragmento completo para escrever. </para> +</answer> +</qandaentry> + +<qandaentry> +<question> +<para +>O que está errado no driver se eu detecto a assertiva? </para> +</question> +<answer> +<para +>Normalmente, o artsd usa o select() para descobrir onde escrever novos dados. Então, ele usa um ioctl(...GETOSPACE...) para descobrir quantos dados escrever. Finalmente, ele escreve os dados. </para> +<para +>Se o artsd não puder escrever tantos dados quanto os indicados pelo ioctl, ele falhará na assertiva. Para corrigir isto, o driver deve fornecer a quantidade correta de espaço livre. </para> +</answer> +</qandaentry> +</qandaset> + +<qandaset id="faq-other"> +<title +>Outras Considerações</title> + +<qandaentry> +<question> +<para +>Eu não posso usar o &arts-builder;. Ele cai ao executar um módulo! </para> +</question> +<answer> +<para +>A causa mais provável é que você está usando estruturas ou módulos antigos que não são mais suportados pela versão 2 do &kde;. Infelizmente a documentação que existe na web referente ao &arts; 0.3.4.1 está um pouco desatualizada. A maioria das quedas frequentemente reportadas é: que executando uma estrutura no &arts-builder; resulta na mensagem de erro <errorname +>[artsd] Synth_PLAY: sub-sistema de áudio já está sendo usado.</errorname +> </para> + +<para +>Você deve usar um Synth_AMAN_PLAY ao invés do módulo Synth_PLAY e o problema terminará. Veja também o arquivo de ajuda do &arts-builder; (clique <keycap +>F1</keycap +> no &arts-builder;). </para> + +<para +>Versões recentes do &arts-builder; (&kde; 2.1 beta 1 e posteriores) vem com um conjunto de exemplos que você pode usar. </para> +</answer> +</qandaentry> + +</qandaset> + +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/future.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/future.docbook new file mode 100644 index 00000000000..cbbc9321893 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/future.docbook @@ -0,0 +1,401 @@ +<!-- <?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 +>Trabalho Futuro</title> + +<para +>Esta seção descreve parte do trabalho no &arts; que está em progresso. O desenvolvimento evolui rapidamente, assim estas informações já devem estar desatualizadas. Você deve verificar o arquivo de lista TODO e os arquivos da <link linkend="mailing-lists" +>lista de discussão</link +> para ver quais novas funcionalidades estão sendo planejadas. Sinta-se à vontade para envolver-se em novos projetos e implementações. </para> + +<para +>Este é um rascunho que tenta fornecer-lhe uma visão geral de como novas tecnologias serão integradas ao &arts;. Específicamente, isto cobre o seguinte: </para> + +<itemizedlist> +<listitem +><para +>Como a interface funciona.</para +></listitem> +<listitem +><para +>Codecs - decodificação de fluxos mp3 ou wav em uma forma que eles possam ser usados como dados.</para +></listitem> +<listitem +><para +>Vídeo.</para +></listitem> +<listitem +><para +>Linhas de execução.</para +></listitem> +<listitem +><para +>Sincronização.</para +></listitem> +<listitem +><para +>Expansão/mascaramento dinâmico.</para +></listitem> +<listitem +><para +>Composição dinâmica.</para +></listitem> +<listitem +><para +>&GUI;</para +></listitem> +<listitem +><para +>&MIDI;</para +></listitem> +</itemizedlist> + +<para +>Estes são os trabalhos em progresso. No entanto, isto deve ser a base se você deseja ver novas tecnologias no &arts;. Isto deve fornecer uma idéia geral de como estes problemas serão abordados. No entanto, sinta-se à vontade para corrigir qualquer coisa que veja aqui. </para> + +<para +>Coisas que usarão a tecnologia do &arts; (logo por favor, coordene seus esforços): </para> + +<itemizedlist> +<listitem> +<para +><application +>KPhone</application +> (voz sobre <acronym +>IP</acronym +>) </para> +</listitem> + +<listitem> +<para +>&noatun; (reprodutor de vídeo / áudio) </para> +</listitem> + +<listitem> +<para +>&artscontrol; (programa de controle do servidor de som, para escopos) </para> +</listitem> + +<listitem> +<para +><application +>Brahms</application +> (sequenciador de música) </para> +</listitem> + +<listitem> +<para +><application +>Kaiman</application +> (tocador de mídia do &kde;2 - compatível com o kmedia2) </para> +</listitem> + +<listitem> +<para +><application +>mpglib</application +>/<application +>kmpg</application +> (tecnologia para reprodução de áudio e vídeo <acronym +>mpg</acronym +>) </para> +</listitem> + +<listitem> +<para +><application +>SDL</application +> (camada de mídia direta para jogos ainda não iniciada mas talvez bem legal) </para> +</listitem> + +<listitem> +<para +><application +>electric ears</application +> (o autor contactou-me - estado desconhecido) </para> +</listitem> +</itemizedlist> + +<sect1 id="interfaces-how"> +<title +>Como a Interface Funciona</title> + +<!-- I think this is now obsolete and documented elsewhere ? --> + +<para +>As interfaces &MCOP; são a base do conceito do &arts;. Elas são a transparência de rede equivalente para classes C++. Sempre que possível você deve orientar seu desenho em função destas interfaces. As interfaces consistem de quatro partes: </para> + +<itemizedlist> +<listitem +><para +>Fluxos síncronos</para +></listitem> +<listitem +><para +>Fluxos assíncronos</para +></listitem> +<listitem +><para +>Métodos</para +></listitem> +<listitem +><para +>Atributos</para +></listitem> +</itemizedlist> + +<para +>Eles podem ser misturados de qualquer jeito que desejar. As novas tecnologias devem ser definidas em termos de interfaces. Leia as seções sobre fluxos assíncronos e síncronos, bem como as sobre interfaces KMedia2, que são bons exemplos de como as coisas funcionam. </para> + +<para +>Interfaces são especificadas em código <literal role="extension" +>.idl</literal +> e rodam através do compilador <command +>mcopidl</command +>. Você deriva a classe <classname +><replaceable +>Nomeinterface</replaceable +>_impl</classname +> para implementá-las, e usa <function +>REGISTER_IMPLEMENTATION(NomeInterface_impl)</function +> para inserir sua implementação de objeto no sistema de objetos &MCOP;. </para> + +</sect1> + +<sect1 id="codecs"> +<title +>Codecs - Decodificando Dados</title> + +<para +>As interfaces kmedia2 permitem que você ignore que arquivos wav, mp3s e seja o que for consistem de fluxos de dados. Ao invés disso, você somente implementas métodos para reproduzí-los. </para> + +<para +>Assim, você pode escrever uma rotina de carregamento wave da mesma maneira que você pode reproduzir arquivos wave (com PlayObject), mas ninguém mais usa seu código. </para> + +<para +>Fluxos assíncronos devem ser a alternativa. Você define uma interface que permite passar blocos de dados para ela, e obter blocos de dados dela. Isto se parece assim no &MCOP;: </para> + +<programlisting +>interface Codec { + in async byte stream indata; + out async byte stream outdata; +}; +</programlisting> + + +<para +>É claro que codecs também podem fornecer atributos para emitir dados adicionais, como informações do formato. </para> + +<programlisting +>interface ByteAudioCodec { + in async byte stream indata; + out async byte stream outdata; + readonly attribute samplingRate, bits, channels; +}; +</programlisting> + +<para +>Este <interfacename +>ByteAudioCodec</interfacename +> por exemplo pode ser conectado a um objeto <interfacename +>ByteStreamToAudio</interfacename +> para criar áudio flutuante real. </para> + +<para +>É claro, outros tipos de Codec podem envolver diretamente emitir dados de vídeo, como </para> + +<programlisting +>interface VideoCodec { + in async byte stream indata; + out video stream outdata; /* note: video streams do not exist yet */ +}; +</programlisting> + +<para +>Provavelmente, um conceito de codec deve ser empregado ao invés do modo <quote +>você sabe como reproduzir e eu não</quote +> por exemplo o uso atual do <interfacename +>WavPlayObject</interfacename +>. No entanto, alguém precisa sentar e realizar alguns testes antes de uma <acronym +>API</acronym +> poder ser finalizada. </para> + +</sect1> + +<sect1 id="video"> +<title +>Vídeo</title> + +<para +>Minha idéia é fornecer vídeo como fluxos assíncronos de algum tipo de dado nativo do &MCOP; que contenha imagens. Este tipo de dado ainda será criado. Fazendo isso, plugins que lidam com imagens de vídeo podem ser conectados da mesma maneira que plugins de áudio podem ser conectados. </para> + +<para +>Existem algumas coisas que são importantes que não sejam deixadas de fora, especificamente: </para> + +<itemizedlist> +<listitem> +<para +>Existem espaços de cores <acronym +>RGB</acronym +> e <acronym +>YUV</acronym +>. </para> +</listitem> +<listitem> +<para +>O formato deve ser algo vocacionado para fluxo. </para> +</listitem> +<listitem> +<para +>Sincronização é importante. </para> +</listitem> +</itemizedlist> + +<para +>Minha idéia é deixar possível reimplementar a classe <classname +>VideoFrame</classname +> de modo que eu possa armazenar material no segmento de memória compártilhada. Fazendo isso, cada fluxo de vídeo entre processos diferentes serão possíveis sem muito sacrifício. </para> + +<para +>No entanto, a situação padrão para vídeo é que as coisas estão no mesmo processo, da decodificação à renderização. </para> + +<para +>Eu fiz uma implementação de fluxo de vídeo experimental, que você pode baixar <ulink url="http://space.twc.de/~stefan/kde/download/video-quickdraw.tar.gz" +>aqui</ulink +>. Isto precisará ser integrado ao &MCOP; após alguns testes. </para> + +<para +>Um componente de renderização deve ser fornecido que suporte XMITSHM (com <acronym +>RGB</acronym +> e <acronym +>YUV</acronym +>). Martin Vogt me disse que ele está trabalhado em algo deste tipo. </para> + +</sect1> + +<sect1 id="threading"> +<title +>Linhas de execução</title> + +<para +>Atualmente, o &MCOP; é todo em linha simples de execução. Talvez para vídeo nós não sejamos capazes de manternos em uma linha simples. Ok. Existem algumas coisas que devem ser tratadas com cuidado: </para> + + +<itemizedlist> +<listitem +><para +>SmartWrappers - eles não são seguros para linhas de execução devido a contagem de referência não segura e coisas semelhantes. </para> +</listitem> +<listitem> +<para +>Dispatcher / I/O - também não é seguro para linhas de execução. </para> +</listitem> +</itemizedlist> + +<para +>No entanto, o que eu posso imaginar é tornar os módulos selecionados seguros para linhas de execução, tanto para fluxo síncrono como assíncrono. De que modo - com um sistema de fluxo ciente da linha de execução, você pode agendar o fluxo do sinal sobre dois ou mais processadores. Isto também auxiliaria o áudio principalmente em situações de multiprocessamento. </para> + +<para +>Como isto funcionaria: </para> + + +<itemizedlist> +<listitem> +<para +>O Sistema de Fluxo decide quais módulos devem calcular o que - o que é: </para> + <itemizedlist> + <listitem +><para +>quadros de vídeo (com método process_indata)</para +></listitem> + <listitem +><para +>fluxos de áudio síncrono (calculateBlock)</para +></listitem> + <listitem +><para +>outros fluxos assíncronos, principalmente fluxos de byte</para +></listitem> + </itemizedlist> +</listitem> +<listitem> +<para +>Os módulos podem calcular estas coisas em suas próprias linhas de execução. Para áudio, faz sentido reusar linhas (⪚ renderizar em quatro linha de execução para quatro processadores, não importa se 100 módulos estiverem rodando). Para vídeo e descompressão de bytes, seria mais confortável ter uma implementação em blocos em sua própria linha, que é sincronizada com o resto do &MCOP; pelo sistema de fluxo. </para> +</listitem> + +<listitem> +<para +>Módulos não devem usar funcionalidades do &MCOP; (como invocações remotas) durante a operação em linha de execução. </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="synchronization"> +<title +>Sincronização</title> + +<para +>Vídeo e &MIDI; (e áudio) devem requerer sincronização. Basicamente, isto é estampa de tempo. A idéia que eu tenho é anexar estampa de tempo aos fluxos assíncronos, adicionando uma estampa de tempo para cada pacote. Se você enviar dois quadros de vídeo, simplesmente crie dois pacotes (eles serão grandes de qualquer jeito), assim você pode ter duas estampas de tempo diferentes. </para> + +<para +>Áudio deve implicitamente ter estampas de tempo, uma vez que ele é síncrono. </para> + +</sect1> + +<sect1 id="dynamic-composition"> +<title +>Composição Dinâmica</title> + +<para +>Deve ser possível dizer: Um efeito FX é composto de seus módulos simples. O FX deve parecer um módulo &MCOP; normal (veja mascaramento), mas de fato consiste de outros módulos. </para> + +<para +>Isto é necessário para o &arts-builder;. </para> + +</sect1> + +<sect1 id="gui"> +<title +>&GUI;</title> + +<para +>Todos os componentes de &GUI; serão módulos &MCOP;. Eles devem ter atributos como tamanho, rótulo, cor, ... . Um construtor <acronym +>RAD</acronym +> (&arts-builder;) deve ser capaz de compô-los visualmente. </para> + +<para +>A &GUI; deve ser salvável salvando os atributos. </para> + +</sect1> + +<sect1 id="midi-stuff"> +<title +>&MIDI;</title> + +<para +>O material de &MIDI; será implementado como fluxos assíncronos. Existem duas opções, uma é usar estruturas normais do &MCOP; para definir os tipos e outra é introduzir outros tipos customizados. </para> + +<para +>Eu acho que estruturas normais deve ser o bastante, que é algo como: </para> + +<programlisting +>struct MidiEvent { + byte b1,b2,b3; + sequence<byte> sysex; +} +</programlisting> + +<para +>Fluxos assíncronos devem suportar tipos de fluxo customizados. </para> + +</sect1> + +</chapter> + + diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/glossary.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/glossary.docbook new file mode 100644 index 00000000000..4e0ffbdf889 --- /dev/null +++ b/tde-i18n-pt_BR/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 +>Sigla, do inglês, para Arquitetura de Som &Linux; Avançada; um driver de placa de som para &Linux; atualmente não incluído no código fonte do kernel padrão. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-arts"> +<glossterm +>&arts;</glossterm> +<glossdef> +<para +>Sigla, do inglês, para Sintetizador de Tempo Real Análogo; o nome do conjunto de ferramentas/biblioteca/arquitetura de multimídia usado pelo projeto &kde; (observe a capitalização) </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-bsd"> +<glossterm +><acronym +>BSD</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Distribuição de Software Berkeley; aqui refere-se a qualquer um dos diversos sistemas operacionais compatíveis com o &UNIX; derivados do <acronym +>BSD</acronym +> &UNIX;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-corba"> +<glossterm +><acronym +>CORBA</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Arquitetura de Gerenciamento de Requisições a Objetos Comuns; um padrão para implementar execução remota orientada à objeto. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-cvs"> +<glossterm +><acronym +>CVS</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Sistema de Versões Simultâneas; um sistema de gerenciamento de configuração de software usado por muitos projetos de software incluindo o &kde; e o &arts;. </para> +</glossdef> +</glossentry> + +<glossentry id="glos-fft"> +<glossterm +><acronym +>FFT</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Transformação de Fourier Rápida; um algoritmo, criado por Fourier, um matemático francês, para conversão de dados a partir do tempo para o domínio de frequência; frequentemente usado no processamento de sinais. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-full-duplex"> +<glossterm +>Full Duplex</glossterm> +<glossdef> +<para +>A habilidade da placa de som gravar e tocar áudio simultaneamente. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gpl"> +<glossterm +><acronym +>GPL</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Licença Pública Geral <acronym +>GNU</acronym +>; uma licença de software criada pela Free Software Foundation (Fundação do Software Livre) que define os termos para o lançamento de software livre. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-gui"> +<glossterm +>&GUI;</glossterm> +<glossdef> +<para +>Sigla, do inglês, para Interface Gráfica com o Usuário </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-idl"> +<glossterm +><acronym +>IDL</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Linguagem de Definição de Interface; um linguagem de programação independente de formato para especificação de interfaces (métodos e dados). </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-kde"> +<glossterm +>&kde;</glossterm> +<glossdef> +<para +>Sigla, do inglês, para Ambiente de Trabalho K; um projeto para desenvolver um ambiente de trabalho gráfico livre para sistemas compatíveis com o &UNIX;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-lgpl"> +<glossterm +><acronym +>LGPL</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Licença Pública Geral Lesser <acronym +>GNU</acronym +>; uma licença de software criada pela Free Software Foundation (Fundação do Software Livre) que define os termos para lançamento de software livre; menos restritiva que a <acronym +>GPL</acronym +> e frequentemente usada por bibliotecas de software. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-mcop"> +<glossterm +>&MCOP;</glossterm> +<glossdef> +<para +>Sigla, do inglês, para Protocolo de Comunicação Multimídia; o protocolo usado para comunicação entre os módulos de software do &arts;; semelhante ao <acronym +>CORBA</acronym +> mas simplificado e otimizado para multimídia. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-midi"> +<glossterm +>&MIDI;</glossterm> +<glossdef> +<para +>Sigla, do inglês, para Interface Digital de Instrumento Multimídia; um protocolo padrão para comunicação entre instrumentos musicais eletrônicos; frequentemente usado também para referir-se ao formato de arquivo para armazenar comandos &MIDI;. </para> +</glossdef> +</glossentry> + +<glossentry id="gloss-oss"> +<glossterm +><acronym +>OSS</acronym +></glossterm> +<glossdef> +<para +>Sigla, do inglês, para Sistema de Som Aberto; os drivers de som incluídos com o kernel do &Linux; (algumas vezes chamados de <acronym +>OSS</acronym +>/Livre) ou uma versão comercial vendida por 4Front Technologies. </para> +</glossdef> +</glossentry> + +</glossary> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/helping.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/helping.docbook new file mode 100644 index 00000000000..714f1d7ca1f --- /dev/null +++ b/tde-i18n-pt_BR/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 +>Contribuindo com o &arts;</title> + +<sect1 id="how-to-help"> +<title +>Como Eu Posso Ajudar</title> + +<para +>O projeto &arts; pode se beneficiar da ajuda de desenvolvedores para tornar os aplicativos multimídia existentes compatíveis com o &arts;, escrever novos aplicativos multimídia, e incrementar os recursos do &arts;. No entanto, você não precisa ser um desenvolvedor para contribuir. Nós podems também nos beneficiar de testadores para submeter relatórios de erros, tradutores para traduzir o texto e documentação do aplicativo para outros idiomas, artistas para desenhar bitmaps (especialmente para os módulos do <application +>artsbuilder</application +>), músicos para criar modos de amostras para o &arts;, e escritores para escrever ou analisar a documentação. </para> +</sect1> + +<sect1 id="mailing-lists"> +<title +>Listas de Discussão</title> + +<para +>A maioria das discossões sobre o desenvolvimento do &arts; ocorrem em duas listas. Elas são o local para discutir novos recursos e idéias de implementação ou pedir ajuda quando problemas acontecem. </para> + +<para +>A lista de discussão de Multimídia do &kde; é para questões gerais sobre multimídia no &kde; incluindo o &arts; bem como aplicativos multimídia como o &noatun; e &aktion;. Você pode inscrever-se a partir da página web em <ulink url="http://www.kde.org/mailinglists.html" +>http://www.kde.org/mailinglists.html</ulink +> ou enviar uma mensagem eletrônica com o assunto <userinput +>subscribe <replaceable +>seu-endereço-eletrônico</replaceable +></userinput +> para <email +>kde-multimedia-request@kde.org</email +>. A lista também é arquivada em <ulink url="http://lists.kde.org" +>http://lists.kde.org</ulink +>. </para> + +<para +>A lista de discussão do &arts; é para questões específicas do &arts;, incluindo uso não-&kde; do &arts;. Para inscrever-se, envie uma mensagem eletrônica contendo o corpo da mensagem <userinput +>subscribe <replaceable +>seu-endereço-eletrônico</replaceable +></userinput +> para <email +>arts-request@space.twc.de</email +>. A lista é arquivada em <ulink url="http://space.twc.de/~stefan/arts-archive" +>http://space.twc.de/~stefan/arts-archive</ulink +>. </para> + +</sect1> + +<sect1 id="coding-standards"> +<title +>Padrões de Codificação</title> + +<para +>Para obter uma leitura consistente em todas as fontes, é importante manter o mesmo estilo de código, em todos arquivos de código fonte do &arts;. Por favor, se você acabou de escrever um módulo, tente escrever/formatar seu código de acordo, assim ficará mais fácil para as diferentes pessoas manter a árvore de código fonte, e mais fácil copiar partes de código de um arquivo para outro. </para> + +<variablelist> +<varlistentry> +<term +>Nomeando funções membro</term> +<listitem> +<para +>Estilo &Qt;/&Java;. Ou seja, capitalização nas quebras de palavra, e a primeira letra sempre sem capitalização, sem sublinhados. </para> +<para +>Isto significa, por exemplo:</para> + +<programlisting +>createStructureDesc() + updateWidget(); + start(); </programlisting> + +</listitem> +</varlistentry> + +<varlistentry> +<term +>Membros de classe</term> +<listitem> +<para +>Membros de classe não são capitalizados, assim como uma barra de menu ou botão. </para> + +<para +>Onde estão acessando funções, o padrão deve ser o do &MCOP;, que é, ao ter um membro longo <function +>foo</function +>, que deve ser visível diretamente, você cria: </para> + +<programlisting +>foo(long new_value); + long foo(); </programlisting> + +<para +>funções para obter ou configurar o valor. Neste caso, o valor real de <function +>foo</function +> deve ser armazenado em <returnvalue +>_foo</returnvalue +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Nomes de classe</term> +<listitem> +<para +>Todas as classes devem ter capitalizadas as letras iniciais das palavras, o que significa <classname +>ModuleView</classname +>, <classname +>SynthModule</classname +>. Todas as classes que se originam de bibliotecas devem usar o espaço de nomes do &arts;, como <classname +>Arts::Soundserver</classname +>. </para> +<para +>A implementação de classes &MCOP; deve ser chamada <classname +>Classe_impl</classname +>, como <classname +>SoundServer_impl</classname +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Parâmetros</term> +<listitem> +<para +>Os parâmetros são sempre em minúsculas. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Variáveis locais</term> +<listitem> +<para +>Variáveis locais são sempre em minúsculas, e devem ter nomes como <varname +>i</varname +>, <varname +>p</varname +>, <varname +>x</varname +>, &etc; onde apropriado. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Largura da tabulação (largura do Shift)</term> +<listitem> +<para +>Uma tabulação deve ser tão longa quanto 4 espaços. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Espaços em expressões.</term> +<listitem> +<para +>Você normalmente não precisa usar espaços em expressões. Você pode entretanto usá-los entre o operador e seus operandos. No entanto, se você colocar um espaço antes de um operador (por exemplo o +), você também deve colocar um espaço após o operador. A única exceção a isto são expressões estilo lista (com ,), onde você deve colocar um espaço após a "," mas não antes. Não há problemas se omitir o espaço aqui também. </para> +<para +>Os exemplos a seguir demonstram o bom uso de espaços: </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 +>Os exemplos a seguir demonstram como <emphasis +>não</emphasis +> usar espaços. Para chamadas de função, após if, while, for, switch e assim por diante, nenhum espaço deve ser escrito. </para> +<programlisting +>{ + // RUIM: se você escreveu uma lista, espaços em branco somente após a "," + int a , b , c , d , e , f; + + // RUIM: uso não simétrico de espaços para o operador = + a= 5; + + // RUIM: se é considerada uma função, e não é seguida por um espaço + if (a == 5) { + } + + // RUIM: não escreva um espaço após while + while (a--) + b++; + + // RUIM: nomes de funções não são seguidos por um espaço + arts_debug ("%d\n", c); + + // RUIM: não são nomes de membro + Arts::Object o = Arts::Object::null (); +} +</programlisting> +</listitem> +</varlistentry> + + +<varlistentry> +<term +>Nomes de arquivos fonte</term> +<listitem> +<para +>Arquivos fonte não devem ter capitalização no nome. Eles devem ter o nome da classe quando implementam uma classe única. Sua extensão é <literal role="extension" +>.cc</literal +> se eles referem-se a código independente para &Qt;/&GUI;, e <literal role="extension" +>.cpp</literal +> se eles referem-se a código dependente do &Qt;/&GUI;. Arquivos de implementação para interfaces devem ser chamados <filename +><replaceable +>foo</replaceable +>_impl</filename +>, se Foo foi o nome da interface. </para> + +<para +>Arquivos &IDL; devem ser chamados de uma maneira descritiva para a coleção de interfaces que eles contém, também tudo em minúsculas. Especialmente não é uma boa idéia chamar um arquivo &IDL; como a classe propriamente dita, assim como o negociador mcopclass e inserir entradas de informação conflitantes. </para> +</listitem> +</varlistentry> +</variablelist> +</sect1> + +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/mcop.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/mcop.docbook new file mode 100644 index 00000000000..12cc9e4ebe3 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/mcop.docbook @@ -0,0 +1,1974 @@ +<!-- <?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 Objeto e Fluxo</title> + +<sect1 id="mcop-overview"> + +<title +>Visão Geral</title> + +<para +>O &MCOP; é o padrão que o &arts; usa para: </para> + +<itemizedlist> +<listitem> +<para +>Comunicação entre objetos. </para> +</listitem> + +<listitem> +<para +>Transparência de rede. </para> +</listitem> + +<listitem> +<para +>Descrever interfaces de objetos. </para> +</listitem> + +<listitem> +<para +>Independência de linguagem. </para> +</listitem> +</itemizedlist> + +<para +>Um aspecto importante do &MCOP; é a <emphasis +>linguagem de descrição de interface</emphasis +>, &IDL;, na qual muitas interfaces e <acronym +>API</acronym +>s do &arts; são definidas de uma maneira independente de linguagem. </para> + +<para +>Para usar interfaces &IDL; a partir do C++, é pelo compilador &IDL; para código C++. Ao implementar uma interface, você deriva a partir da classe esqueleto que o compilador &IDL; gerou. Ao usar uma interface, você faz isso como se estivesse usando um envólucro. Desta maneira, o &MCOP; pode usar um protocolo se o objeto com que você está falando não é local - você obtém transparência de rede. </para> + +<para +>Este capítulo busca descrever os recursos básicos do modelo de objeto que resulta a partir do uso do &MCOP;, o protocolo, como usar o &MCOP; em C++ (ligação com a linguagem), e assim por diante. </para> + +</sect1> + +<sect1 id="interfaces"> + +<title +>Interfaces e &IDL;</title> + +<para +>Muitos dos serviços fornecidos pelo &arts;, como os módulos e o servidor de som, são definidos em termos de <acronym +>interfaces</acronym +>. Interfaces são especificadas em um formato independente de linguagem: &IDL;. </para> + +<para +>Isto permite que muitos dos detalhes da implementação como o formato de fluxos de dados multimídia, transparência de rede, e dependências de linguagem de programação, sejam ocultas a partir da especificação da interface. Uma ferramenta, o &mcopidl;, traduz a definição de interface para uma linguagem de programação específica (atualmente somente o C++ é suportado). </para> + +<para +>A ferramenta gera uma classe esqueleto com todo código correspondente e funcionalidade básica. Você deriva a partir desta classe para implementar os recursos que deseja. </para> + +<para +>O &IDL; usado pelo &arts; é semelhante ao usado pelo <acronym +>CORBA</acronym +> e <acronym +>DCOM</acronym +>. </para> + +<para +>Arquivos &IDL; podem conter: </para> + +<itemizedlist> +<listitem> +<para +>Diretivas #include estilo-C para outros arquivos &IDL;. </para> +</listitem> + +<listitem> +<para +>Definições de enumerações e tipos de estrutura, como em C/C++. </para> +</listitem> + +<listitem> +<para +>Definições de interfaces. </para> +</listitem> +</itemizedlist> + +<para +>Interfaces &IDL; são definidas de maneira bem semelhante às classes C++ ou estruturas C, apesar de com algumas restrições. Como no C++, interfaces pode ter subclasses de outras interfaces usando herança. Definições de interface podem incluir três coisas: fluxos, atributos e métodos. </para> + +<sect2 id="streams"> + +<title +>Fluxos</title> + +<para +>Fluxos definem dados de multimídia, um dos mais importantes componentes de um módulo. Fluxos são definidos no seguinte formato: </para> + +<para +>[ async ] in|out [ multi ] <replaceable +>type</replaceable +> stream <replaceable +>nome</replaceable +> [ , <replaceable +>nome</replaceable +> ] ; </para> + +<para +>Fluxos possuem uma direção definida em referência ao módulo, como indicado pelos qualificadores obrigatórios in ou out. O argumento type define o tipo de dado, que pode ser qualquer um dos tipos descritos mais tarde pelos atributos (nem todos são atualmente suportados). Muitos módulos usam o tipo de fluxo audio, que é um apelido para flutuante uma vez que este é o formato de dados interno para fluxo de áudio. Fluxo múltiplos do mesmo tipo podem ser definidos na mesma definição usando nomes separados por vírgulas. </para> + +<para +>Fluxos são por padrão síncronos, o que significa que eles são contínuos e fornecem dados em uma taxa constante, como um áudio <acronym +>PCM</acronym +>. O qualificador async especifica um fluxo assíncrono, que é usado por fluxos de dados não contínuos. O exemplo mais comum de um fluxo assíncrono são mensagens &MIDI;. </para> + +<para +>A chave multi, somente válida para fluxos de entrada, indica que a interface suporta um número variável de entradas. Isto é útil para implementar dispositivos como mixadores que podem aceitar um grande número de fluxos de entrada. </para> + +</sect2> +<sect2 id="attributes"> + +<title +>Atributos</title> + +<para +>Atributos são dados associados com uma instância de uma interface. Eles são declarados como variáveis membro em C++, e podem usar qualquer um dos tipos primitivos booleano, byte, longo, string ou flutuante. Você pode também usar estruturas definidas pelo usuários ou tipos de enumeração bem como sequências delimitadas de variáveis usando a sintaxe sequência<tipo>. Atributos podem opcionalmente ser marcados como somente leitura. </para> + +</sect2> +<sect2 id="methods"> + +<title +>Métodos</title> + +<para +>Como em C++, métodos podem ser definidos em interfaces. Os parâmetros do métodos são restritos aos mesmos tipos dos atributos. A chave oneway indica um método que retorna imediatamente e é executado de maneira assíncrona. </para> + +</sect2> + +<sect2 id="standardinterfaces"> + +<title +>Interfaces Padrão</title> + +<para +>Diversas interfaces de módulos padrão já estão definidas para você no &arts;, como a <interfacename +>StereoEffect</interfacename +>, e <interfacename +>SimpleSoundServer</interfacename +>. </para> + +</sect2> + +<sect2 id="example"> +<title +>Exemplo</title> + +<para +>Um exemplo simples de um módulo obtido do &arts; é o módulo de retardo constante, encontrado no arquivo <filename +>tdemultimedia/arts/modules/artsmodules.idl</filename +>. A definição de interface é listada abaixo. </para> + +<programlisting +>interface Synth_CDELAY : SynthModule { + attribute float time; + in audio stream invalue; + out audio stream outvalue; +}; +</programlisting> + +<para +>Este módulo é herdeiro do <interfacename +>SynthModule</interfacename +>. Esta interface, definida em <filename +>artsflow.idl</filename +>, define métodos padrão implementados em todos os módulos de sintetização de música. </para> + +<para +>O efeito CDELAY retarda um fluxo de áudio estéreo de um valor de tempo especificado como um parâmetro de ponto flutuante. A definição de interface possui um atributo do tipo flutuante para armazenar o valor de retardo. Isto define dois fluxos de entrada de áudio e dois fluxos de saída de áudio (tipicamente para efeitos estéreo). Nenhum método é necessário além dos que ele herda. </para> + +</sect2> + +</sect1> + +<sect1 id="more-about-streams"> +<title +>Mais Sobre Fluxos</title> + +<para +>Esta seção aborda alguns tópicos adicionais relacionados com fluxos. </para> + +<sect2 id="stream-types"> +<title +>Tipos de Fluxo</title> + +<para +>Existem vários requisitos para como um módulo pode fazer um fluxo. Para ilustrar isto, considere estes exemplos: </para> + +<itemizedlist> +<listitem> +<para +>Escalonar um sinal por um fator de dois. </para> +</listitem> + +<listitem> +<para +>Executar uma conversão de frequência de amostra. </para> +</listitem> + +<listitem> +<para +>Descomprimir um sinal codificado em tempo de execução. </para> +</listitem> + +<listitem> +<para +>Ler eventos &MIDI; de <filename class="devicefile" +>/dev/midi00</filename +> e inserí-los em um fluxo. </para> +</listitem +> +</itemizedlist> + +<para +>O primeiro caso é o mais simples: ao receber 200 amostras de entrada o módulo produz 200 amostras de saída. Ele somente produz saída quando ele recebe entrada. </para> + +<para +>O segundo caso produz número diferente de amostras de saída ao receber 200 amostras de entrada. Isto depende de que conversão é executada, mas o número é conhecido a seguir. </para> + +<para +>O terceiro caso é mais complicado. A partir dos dados recebidos você não pode adivinhar quanto dados os 200 bytes de entrada gerarão (provavelmente muito mais de 200 bytes, mas...). </para> + +<para +>O último caso é um módulo que se torna ativo por ele mesmo, e algumas vezes produz dados. </para> + +<para +>No &arts;-0.3.4, somente fluxos do primeiro tipo serão manipulados, e a maioria das coisas funciona bem. Este é provavelmente o que você precisa mais ao escrever módulos que processam áudio. O problema com os outros, e mais complexos tipos de fluxo, é que eles são difíceis de programar, e que você não precisa destes recursos na maioria das vezes. É por isto que nós fazemos isto com dois tipos de fluxo diferentes: síncronos e assíncronos. </para> + +<para +>Fluxos síncronos possuem estas características: </para> + +<itemizedlist> +<listitem> +<para +>Os módulos devem ser capazes de calcular dados de qualquer tamanho, fornecida a entrada suficiente. </para> +</listitem> + +<listitem> +<para +>Todos os fluxos possuem a mesma taxa de amostragem. </para> +</listitem> + +<listitem> +<para +>A função <function +>calculateBlock()</function +> será chamada quando dados suficientes estiverem disponíveis, e o módulo pode confiar nos ponteiros que apontam para os dados. </para> +</listitem +> + +<listitem> +<para +>Não existe alocação ou desalocação a ser feita. </para> +</listitem> +</itemizedlist> + +<para +>Fluxos assíncronos, por outro lado, possuem este comportamento: </para> + +<itemizedlist> +<listitem> +<para +>Módulos podem algumas vezes produzir dados, ou com taxa de amostragem variável, ou somente se eles tiverem entrada a partir de algum descritor arquivado. Eles não se limitam pela regra que <quote +>deve ser capaz de satisfazer requisitos de qualquer tamanho</quote +>. </para> +</listitem> + +<listitem> +<para +>Fluxos assíncronos de um módulo podem ter taxas de amostragem completamente diferentes. </para> +</listitem> + +<listitem> +<para +>Fluxos de saída: existem funções explícitas para alocar pacotes, enviar pacotes - e um mecanismo de eleição adicional que lhe dirá quando você deve criar mais algum dado. </para> +</listitem> + +<listitem> +<para +>Fluxos de entrada: você obtém uma chamada quando recebe um novo pacote - você deve dizer quando você está processando todos os dados deste pacote, o que não deve acontecer de uma vez (você pode informar isto mais tarde, e se todos foram processados um pacoto, se será liberado/reusado) </para> +</listitem> +</itemizedlist> + +<para +>Ao você declarar fluxos, você usa a chave <quote +>async</quote +> para indicar que deseja criar um fluxo assíncrono. Assim, por exemplo, consideremos que você deseja converter um fluxo assíncrono de bytes para um fluxo síncrono de amostras. Sua interface pode parecer-se com isto: </para> + +<programlisting +>interface ByteStreamToAudio : SynthModule { + async in byte stream indata; // o fluxo de amostra de entrada assíncrono + + out audio stream left,right; // fluxos de amostra de saída síncronos +}; +</programlisting> + +</sect2> + +<sect2 id="async-streams"> +<title +>Usando Fluxos Assíncronos</title> + +<para +>Suponhamos que você decida escrever um módulo para produzir som de maneira assíncrona. Sua interface pode parecer-se com isto: </para> + +<programlisting +>interface SomeModule : SynthModule +{ + async out byte stream outdata; +}; +</programlisting> + +<para +>Como enviar os dados? O primeiro método é chamado <quote +>empurrar e entregar</quote +>. Com fluxos assíncronos você envia dados como pacotes. Ou seja, você envia pacotes individuais com bytes como no exemplo acima. O processo atual é: alocar um pacote, preenchê-lo, enviá-lo. </para> + +<para +>Aqui está em termos de código: Primeiro, nós alocamos um pacote: </para> + +<programlisting +>DataPacket<mcopbyte> *packet = outdata.allocPacket(100); +</programlisting> + +<para +>Nós o preenchemos: </para> + +<programlisting +>// molde de modo que fgets esteja satisfeito que ele seja um ponteiro (char *) +char *data = (char *)packet->contents; + +// como pode ver, você pode restringir o tamanho do pacote após a alocação +// se desejar +if(fgets(data,100,stdin)) + packet->size = strlen(data); +else + packet->size = 0; +</programlisting> + +<para +>Agora o enviamos: </para> + +<programlisting +>packet->send(); +</programlisting> + +<para +>Este é um exemplo bem simples, mas se você deseja enviar pacotes extamanete tão rápido quanto o recebedor possa processá-los, você precisa de outra abordagem, o método <quote +>puxar e entregar</quote +>. Você pede para enviar pacotes tão rápido quanto o recebedor esteja pronto para processá-lo. Você inicia com uma determinada quantidade de pacotes que enviou. Assim que o recebedor processar um pacote após o outro, você começa a recarregar com novos dados, e enviá-los novamente. </para> + +<para +>Você inicia isto chamando o setPull. Por exemplo: </para> + +<programlisting +>outdata.setPull(8, 1024); +</programlisting> + +<para +>Isto significa que você deseja enviar pacotes pelos dados de saída. Você deseja iniciar enviando 8 pacotes de uma vez, e assim que o recebedor processar alguns deles, você deseja receber mais. </para> + +<para +>Então, você precisa implementar um método que preencha os pacotes, que pode ser algo como isto: </para> + +<programlisting +>void request_outdata(DataPacket<mcopbyte> *packet) +{ + packet->size = 1024; // não deve ser mais de 1024 + for(int i = 0;i < 1024; i++) + packet->contents[i] = (mcopbyte)'A'; + packet->send(); +} +</programlisting> + +<para +>É isto. Quando você não tiver mais qualquer dado, você pode começar a enviar pacotes com tamanho zero, que interromperá o processo de puxar. </para> + +<para +>Observe que é essencial fornecer ao método o nome exato <methodname +>request_<replaceable +>nomedofluxo</replaceable +></methodname +>. </para> + +<para +>Nós apenas discutimos o envio de dados. O recebimento de dados é bem mais simples. Suponhamos que você tenha um filtro ToLower simples, que simplesmente converte todas as letras para minúsculas: </para> + +<programlisting +>interface ToLower { + async in byte stream indata; + async out byte stream outdata; +}; +</programlisting> + +<para +>Isto é realmente simples de implementar; aqui está toda a implementação: </para> + +<programlisting +>class ToLower_impl : public ToLower_skel { +public: + void process_indata(DataPacket<mcopbyte> *inpacket) + { + DataPacket<mcopbyte> *outpacket = outdata.allocPacket(inpacket->size); + + // converte para letras minúsculas + char *instring = (char *)inpacket->contents; + char *outstring = (char *)outpacket->contents; + + for(int i=0;i<inpacket->size;i++) + outstring[i] = tolower(instring[i]); + + inpacket->processed(); + outpacket->send(); + } +}; + +REGISTER_IMPLEMENTATION(ToLower_impl); +</programlisting> + +<para +>Novamente, é essencial nomear o método como <methodname +>process_<replaceable +>nomedofluxo</replaceable +></methodname +>. </para> + +<para +>Como pode ver, para cada pacote de chegada você obtém uma chamada para uma função (a chamada <function +>process_indata</function +> em seu caso). Você precisa chamar o método <methodname +>processed()</methodname +> de um pacote para indicar que você já o processou. </para> + +<para +>Aqui está uma dica de implementação: se o processamento demorar muito 9&ie; se você deseja esperar pela saída da placa de som ou algo parecido). não chame o processo imediatamente, mas armazene todo pacote de dados e chame processed somente tão logo você realmente tenha processado o pacote. Deste modo, remetentes possuem a chance de saber quanto tempo ele realmente leva para fazer seu trabalho. </para> + +<para +>Como sincronização não é tão agradável com fluxos assíncronos, você deve usar fluxos síncronos sempre que possível, e fluxos assíncronos somente quando necessário. </para> + +</sect2> + +<sect2 id="default-streams"> +<title +>Fluxos Padrão</title> + +<para +>Suponhamos que você tenha 2 objetos, por exemplo um AudioProducer e um AudioConsumer. O AudioProducer tem um fluxo de saída e o AudioConsumer tem um de entrada. Cada vez que você desejar conectá-los, você usará estes 2 fluxos. O primeiro uso dos padrões é para permitir que você crie conexões sem especificar as portas neste caso. </para> + +<para +>Agora suponhamos que os objetos acima possam manipular estéreo, e cada um tenha uma porta <quote +>left</quote +> e <quote +>right</quote +>. Você gostaria ainda de conectá-los tão facilmente quanto antes. Mas como pode o sistema de conexão saber que porta de saída conectar a qual porta de entrada? Não existe maneira de mapear corretamente os fluxos? Os padrões são então usados para especificar diversos fluxos, com uma ordem. Assim, quando você conectar um objeto com 2 fluxos de saída padrão a outro com 2 fluxos de entrada padrão, você não precisa especificar as portas, e o mapeamento será feito corretamente. </para> + +<para +>É claro, isto não se limita ao estéreo. Qualquer número de fluxos pode ser estabelecido como padrão se necessário, e a função de conexão verificará se o número de padrões de 2 objetos correspondem (na direção necessária) se você não especificar as portas a usar. </para> + +<para +>A sintaxe é a seguinte: no &IDL; você pode usar a chave default na declaração do fluxo, ou em uma linha simples. Por exemplo: </para> + +<programlisting +>interface TwoToOneMixer { + default in audio stream input1, input2; + out audio stream output; +}; +</programlisting> + +<para +>Neste exemplo, o objeto irá esperar que duas portas de entrada sejam conectadas por padrão. A ordem é a especificada na linha default, assim um objeto como este: </para> + +<programlisting +>interface DualNoiseGenerator { + out audio stream bzzt, couic; + default couic, bzzt; +}; +</programlisting> + +<para +>Criará conexões a partir de <quote +>couic</quote +> para <quote +>input1</quote +>, e <quote +>bzzt</quote +> para <quote +>input2</quote +> automaticamente. Observe que uma vez que existe somente uma saída para o mixador, ela será tornada padrão neste caso (veja abaixo). A sintaxe usada no gerador de ruído é útil para declarar uma ordem diferente da estabelecida na declaração, ou selecionar somente algumas portas como padrão. A direção das portas nesta linha serão descobertas pelo &mcopidl; assim não as especifique. Você pode misturar portas de entrada e saída na mesma linha, somente a ordem é importante. </para> + +<para +>Existem algumas regras que serão seguidas ao usar herança: </para> + +<itemizedlist> +<listitem> +<para +>Se uma lista padrão é especificada no &IDL;, então a usa. Portas pai podem ser colocadas na lista também, sejam elas padrão no pai ou não. </para> +</listitem> + +<listitem> +<para +>Caso contrário, herda os padrões do pai. A ordem é parente1 padrão1, parente1 padrão2 ..., parente2 padrão 1... Se existir um ancestral comum usando 2 ramos pai, um lista <quote +>pública virtual</quote +> mesclada é feita na qual o padrão é a primeira ocorrência da lista. </para> +</listitem> + +<listitem> +<para +>Se ainda não existir um padrão e um fluxo simples em uma direção, use-o como padrão para esta direção. </para> +</listitem> +</itemizedlist> + +</sect2> + +</sect1> +<sect1 id="attribute-change-notify"> +<title +>Notificações de mudança de atributos</title> + +<!-- TODO: This should be embedded better into the context - I mean: the + context should be written ;-). --> + +<para +>Notificações de mudança de atributos são uma maneira de saber quando um atributo muda. Elas são um pouco semelhantes aos sinais e slots do &Qt; ou Gtk. Por exemplo, se você tiver um elemento &GUI;, um índice deslizante, que configura um número entre 0 e 100, você normalmente terá um objeto que faz algo com este número (por exemplo, ele pode estar controlando o volume de algum sinal de áudio). Assim você desejaria que sempre que o índice fosse movido, o objeto que escalona o volume fosse notificado. Uma conexão entre o remetente e o destinatário. </para> + +<para +>O &MCOP; lida com isto sendo capaz de fornecer notificações quando atributos mudam. O que quer que seja declarado como <quote +>atributo</quote +> no &IDL; pode emitir estas notificações, e deve fazer isso, sempre que for modificado. O que quer que seja declarado como <quote +>atributo</quote +> também pode receber estas notificações de mudaça. Assim, por exemplo, se você possui duas interfaces &IDL;, como estas: </para> + +<programlisting +>interface Slider { + attribute long min,max; + attribute long position; + }; + interface VolumeControl : Arts::StereoEffect { + attribute long volume; // 0..100 + }; +</programlisting> + +<para +>Você pode conectá-las usando notificações de mudanças. Isto funciona usando a operação de conexão do sistema de fluxo normal. Neste caso, o código C++ para conectar dois objetos se parecerá com isto: </para> + +<programlisting +>#include <connect.h> +using namespace Arts; +[...] +connect(slider,"position_changed",volumeControl,"volume"); +</programlisting> + +<para +>Como pode ver, cada atributo oferece dois fluxos diferentes, um para enviar as notificações de mudança, chamado <function +><replaceable +>nomeatributo</replaceable +>_changed</function +>, e um para receber notificações de mudança, chamado <function +>nomeatributo</function +>. </para> + +<para +>É importante saber que as notificações de mudança e fluxos assíncronos são compatíveis. Eles também são transparentes à rede. Assim você pode conectar uma notificação de mudança de um atributo flutuante de um widget que a &GUI; possua com um fluxo assíncrono de um módulo sintetizador sendo executado em outro computador. Isto, é claro, implica que as notificações de mudança <emphasis +>não são síncronas</emphasis +>, ou seja, após você ter enviado a notificação de mudança, ela pode levar algum tempo até ela ser efetivamente recebida. </para> + +<sect2 id="sending-change-notifications"> + +<title +>Enviando notificações de mudança</title> + +<para +>Ao implementar objetos que possuam atributos, você precisa enviar notificações de mudança sempre que um atributo muda. O código para fazer isto se parece com isto: </para> + +<programlisting +>void KPoti_impl::value(float newValue) + { + if(newValue != _value) + { + _value = newValue; + value_changed(newValue); // <- envia notificação de mudança + } + } +</programlisting> + +<para +>É altamente recomendável usar um código como este para todos os objetos que você implementar, assim estas notificações de mudança podem ser usadas por outras pessoas. Você deve também no entanto esvaziar as notificação enviadas frequentemente, assim se você estiver realizando um processamento de sinal, é provavelmente melhor você manter um monitoramento ao enviar sua última notificação, de modo que você não envie uma com cada amostra que você processar. </para> + +</sect2> + +<sect2 id="change-notifications-apps"> +<title +>Aplicações para notificações de mudança</title> + +<para +>Será especialmente útil o uso de notificações de mudança juntamente com escopos (coisas que visualizam dados de áudio por exemplo), elementos gui, widgets de controle, e monitoramento. Código usando isto existe em <filename class="directory" +>tdelibs/arts/tests</filename +>, e na implementação experimental da artsgui, que você pode encontrar em <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 +>O arquivo <literal role="extension" +>.mcoprc</literal +></title> + +<para +>O arquivo <literal role="extension" +>.mcoprc</literal +> (em cada pasta pessoal do usuário) pode ser usado para configurar o &MCOP; de diversas maneiras. Atualmente, os parâmetros possíveis são os seguintes: </para> + +<variablelist> + +<varlistentry> +<term +>GlobalComm</term> +<listitem> +<para +>O nome de uma interface a ser usada para comunicação global. A comunicação global é usada para encontrar outros objetos e obter o cookie secreto. Múltiplos clientes/servidores &MCOP; que devem ser capazes de conversar um com os outros precisam ter um objeto GlobalComm que é capaz de compartilhar informações entre eles. Atualmente, os valores possíveis são <quote +>Arts:TmpGlobalComm</quote +> para comunicar através da pasta <filename class="directory" +>/tmp/mcop-<replaceable +>nomeusuário</replaceable +></filename +> (que somente funcionará em um computador local) e <quote +>Arts::X11GlobalComm</quote +> para comunicar através das propriedades da janela raiz no servidor X11. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>TraderPath</term> + +<listitem> +<para +>Especifica onde procurar por informações de negociação. Você pode listar mais de uma pasta aqui, e separá-las com vírgulas, como </para> +</listitem> + +</varlistentry> + +<varlistentry> +<term +>ExtensionPath</term> + +<listitem> +<para +>Especifica quais extensões de pasta (na forma de bibliotecas compartilhadas) são carregadas. Valores múltiplos podem ser especificados separados por vírgula. </para> +</listitem> + +</varlistentry> +</variablelist> + +<para +>Um exemplo que usa tudo acima é: </para> + +<programlisting +># $HOME/.mcoprc file +GlobalComm=Arts::X11GlobalComm + +# se você for um desenvolvedor, isto deve ser acessado para adicionar uma pasta em +# seu diretório pessoal para o negociador/extensão de caminho seja capaz de adicionar +# componentes sem instalá-los +TraderPath="/opt/kde2/lib/mcop","/home/marcus/mcopdevel/mcop" +ExtensionPath="/opt/kde2/lib","/home/marcus/mcopdevel/lib" +</programlisting> + +</sect1> + +<sect1 id="mcop-for-corba-users"> +<title +>&MCOP; para Usuários do <acronym +>CORBA</acronym +></title> + +<para +>Se você já usou o <acronym +>CORBA</acronym +> antes, você verá que o &MCOP; é quase a mesma coisa. De fato, o &arts; antes da versão 0.4 usava o <acronym +>CORBA</acronym +>. </para> + +<para +>A idéia básica do <acronym +>CORBA</acronym +> é a mesma: você implementa objetos (componentes). Usando os recursos do &MCOP;, seus objetos não estão somente disponíveis como classes normais a partir do mesmo processo (através das técnicas padrão do C++) - eles também estão disponíveis para servidores remotos de maneira transparente. Para isto funcionar, a primeira coisa que você precisa fazer é especificar a interface de seus objetos em um arquivo &IDL; - da mesma maneira que o &IDL; do <acronym +>CORBA</acronym +>. Existem somente algumas poucas diferenças. </para> + +<sect2 id="corba-missing"> +<title +>Recursos do <acronym +>CORBA</acronym +> Que Estão Faltando No &MCOP;</title> + +<para +>No &MCOP; não existe parâmetros <quote +>in</quote +> e <quote +>out</quote +> nas invocações de método. Parâmetros são sempre de entrada, o código de retorno é sempre de saída, o que significa que a interface: </para> + +<programlisting +>// CORBA idl +interface Account { + void deposit( in long amount ); + void withdraw( in long amount ); + long balance(); +}; +</programlisting> + +<para +>é escrita como </para> + +<programlisting +>// MCOP idl +interface Account { + void deposit( long amount ); + void withdraw( long amount ); + long balance(); +}; +</programlisting> + +<para +>no &MCOP;. </para> + +<para +>Não existe suporte à exceção. O &MCOP; não possui exceções - ele usa algo diferente para manipulação de erro. </para> + +<para +>Não existem tipos de união de typedefs. Eu não sei se isto é realmente uma fraqueza, uma vez que isto não é algo tão essencial assim. </para> + +<para +>Não existe suporte para passagem de interfaces ou referências de objetos </para> + +</sect2> + +<sect2 id="corba-different"> +<title +>Recursos do <acronym +>CORBA</acronym +> Que São Diferentes No &MCOP;</title> + +<para +>Você declara sequências como <quote +><replaceable +>tipo</replaceable +>sequence</quote +> no &MCOP;. Não existe necessidade de um typedef. Por exemplo, ao invés de: </para> + +<programlisting +>// CORBA idl +struct Line { + long x1,y1,x2,y2; +}; +typedef sequence<Line> LineSeq; +interface Plotter { + void draw(in LineSeq lines); +}; +</programlisting> + +<para +>você escreverá </para> + +<programlisting +>// MCOP idl +struct Line { + long x1,y1,x2,y2; +}; +interface Plotter { + void draw(sequence<Line> lines); +}; +</programlisting> + +</sect2> + +<sect2 id="no-in-corba"> +<title +>Recursos do &MCOP; Que Não Existem No <acronym +>CORBA</acronym +></title> + +<para +>Você pode declarar fluxos, que então serão avalidados pelo ambiente de trabalho do &arts;. Fluxos são declarados de maneira semelhante aos atributos. Por exemplo: </para> + +<programlisting +>// MCOP idl +interface Synth_ADD : SynthModule { + in audio stream signal1,signal2; + out audio stream outvalue; +}; +</programlisting> + +<para +>Isto diz que seu objeto aceitará dois fluxos de entrada síncrona de áudio chamados signal1 e signal2. Síncrona significa que estes fluxos enviarão x amostras por segunto (ou outro tempo), assim o agendador sempre garantirá que seja fornecido uma quantidade balanceada de dados de entrada (⪚ 200 amostras de signal1 existirão e 200 amostras de signal2 existirão). Você garantirá que se seu objeto for chamado com estas 200 amostras de signal1 + signal2, ele será capaz de produzir exatamente 200 amostras para o outvalue. </para> + +</sect2> + +<sect2 id="mcop-binding"> +<title +>A Conexão de Linguagem com o C++ do &MCOP;</title> + +<para +>Isto difere do <acronym +>CORBA</acronym +> na maior parte: </para> + +<itemizedlist> +<listitem> +<para +>Strings usam a classe <classname +>sting</classname +> do <acronym +>STL</acronym +> do C++. Quando armazenado em sequências, eles são armazenados como <quote +>plano</quote +>, o que significa que eles são considerados um tipo primitivo. Assim, eles precisam de cópia. </para> +</listitem> + +<listitem> +<para +>longs são long de plano (esperado ser de 32 bits). </para> +</listitem> + +<listitem> +<para +>As sequências usam a classe <classname +>vector</classname +> do C++ do <acronym +>STL</acronym +>. </para> +</listitem> + +<listitem> +<para +>As estruturas são todas derivadas da classe <classname +>Type</classname +> do &MCOP;, e são geradas no compilador de &IDL; do &MCOP;. Quando forem armazenadas em sequências, elas não serão armazenadas <quote +>planas</quote +> , mas sim como referências porque, caso contrário, iriam ocorrer várias cópias. </para> +</listitem> +</itemizedlist> +</sect2> + +<sect2 id="implementing-objects"> +<title +>Implementando Objetos do &MCOP;</title> + +<para +>Após passar as interfaces pelo compilador de &IDL;, você precisa de derivar da classe <classname +>_skel</classname +>. Por exemplo, considere que definiu a sua interface da seguinte forma: </para> + +<programlisting +>// IDL do MCOP: ola.idl +interface Ola { + void Ola(string s); + string concatenar(string s1, string s2); + long somar2(long a, long b); +}; +</programlisting> + +<para +>Você pode passar isso pelo compilador de &IDL;, invocando o comando <userinput +><command +>mcopidl</command +> <parameter +>ola.idl</parameter +></userinput +>, o que por sua vez irá gerar o <filename +>ola.cc</filename +> e o <filename +>ola.h</filename +>. Para o implementar, você precisa de definir uma classe C++ que herde do esqueleto: </para> + +<programlisting +>// Arquivo de inclusão de C++ - inclua o ola.h em algum lugar +class Ola_impl : virtual public Ola_skel { +public: + void ola(const string& s); + string concatenar(const string& s1, const string& s2); + long somar2(long a, long b); +}; +</programlisting> + +<para +>Finalmente, você terá de implementar os métodos como C++ normal </para> + +<programlisting +>// arquivo de implementação de C++ + +// como pode ver, as strings são passadas como referências de const string +void Ola_impl::ola(const string& s) +{ + printf("Ola '%s'!\n",s.c_str()); +} + +// quando têm um valor a devolver são passadas como cadeias de caracteres normais +string Ola_impl::concatenar(const string& s1, const string& s2) +{ + return s1+s2; +} + +long Ola_impl::somar2(long a, long b) +{ + return a+b; +} +</programlisting> + +<para +>Logo que faça isso, você terá um objeto que poderá comunicar-se usando o &MCOP;. Basta criar um (usando as funcionalidades normais do C++ para criar um objeto): </para> + +<programlisting +> Servidor do Ola_impl; +</programlisting> + +<para +>E assim que forneça a alguém a referência </para> + +<programlisting +>string referencia = servidor._toString(); + printf("%s\n",referencia.c_str()); +</programlisting> + +<para +>e vá para o ciclo de inatividade do &MCOP; </para> + +<programlisting +>Dispatcher::the()->run(); +</programlisting> + +<para +>As pessoas poderão acessar isso usando </para> + +<programlisting +>// este código poderá rodar em qualquer lado - não necessariamente no mesmo +// processo (poderá também rodar em um computador/arquitetura diferentes) + + Ola *h = Ola::_fromString([a referência do objeto impressa acima]); +</programlisting> + +<para +>e invocar os métodos: </para> + +<programlisting +>if(h) + h->ola("teste"); + else + printf("O acesso falhou?\n"); +</programlisting> + +</sect2> +</sect1> + +<sect1 id="mcop-security"> +<title +>Considerações de Segurança do &MCOP;</title> + +<para +>Uma vez que os servidores de &MCOP; irão atender os pedidos numa porta <acronym +>TCP</acronym +>, potencialmente todos (se você estiver na Internet) poderão tentar ligar-se aos serviços do &MCOP;. Por isso, é importante autenticar os clientes. O &MCOP; usa o protocolo md5-auth. </para> + +<para +>O protocolo md5-auth faz o seguinte para garantir que só os clientes selecionados (confiáveis) poderão ligar-se a um servidor: </para> + +<itemizedlist> +<listitem> +<para +>Ele considera que você fornece a todos os clientes um cookie secreto. </para> +</listitem> + +<listitem> +<para +>Toda vez que um cliente se conecta, ele verifica se o cliente conhece esse cookie secreto, sem o transferir de fato (de modo que nem quem esteja escutando o tráfego de rede possa descobrir). </para> +</listitem> + +</itemizedlist> + +<para +>Para fornecer a cada cliente esse cookie secreto, o &MCOP; irá (normalmente) colocá-lo na pasta <filename class="directory" +>mcop</filename +> (em <filename class="directory" +>/tmp/mcop-<envar +>USER</envar +>/secret-cookie</filename +>). Claro, você poderá copiá-lo para outros computadores. Contudo, se o fizer, use um mecanismo de transferência seguro, como o <command +>scp</command +> (do <application +>ssh</application +>). </para> + +<para +>A autenticação dos clientes usa os seguintes passos: </para> + +<procedure> +<step> +<para +>[SERVIDOR] gera um cookie novo (aleatório) R </para> +</step> + +<step> +<para +>[SERVIDOR] envia-o para o cliente </para> +</step> + +<step> +<para +>[CLIENTE] lê o "cookie secreto" S de um arquivo </para> +</step> + +<step> +<para +>[CLIENTE] embaralha os cookies R e S para um cookie embaralhado M usando o algoritmo MD5 </para> +</step> + +<step> +<para +>[CLIENTE] envia o M para o servidor </para> +</step> + +<step> +<para +>[SERVIDOR] verifica que, ao embaralhar o R e o S obterá o mesmo resultado que o cookie M recebido do cliente. Em caso afirmativo, a autenticação foi bem-sucedida. </para> +</step> + +</procedure> + +<para +>Este algoritmo deverá ser seguro, uma vez que </para> + +<orderedlist> +<listitem> +<para +>Os cookies secretos e os aleatórios são <quote +>aleatórios o bastante</quote +> e </para> +</listitem> + +<listitem> +<para +>O algoritmo de dispersão do MD5 não permite descobrir o <quote +>texto original</quote +>, que é o cookie secreto S e o cookie aleatório R (o qual é conhecido, de qualquer forma), a partir do cookie embaralhado M. </para> +</listitem> +</orderedlist> + +<para +>O protocolo &MCOP; irá iniciar todas as conexões novas com um processo de autenticação. Basicamente, assemelha-se ao seguinte: </para> + +<procedure> + +<step> +<para +>O servidor envia uma mensagem ServerHello que descreve os protocolos de autenticação conhecidos. </para> +</step> + +<step> +<para +>O cliente envia uma mensagem ClientHello que inclui a informação de autenticação. </para> +</step> + +<step> +<para +>O servidor envia uma mensagem AuthAccept. </para> +</step> +</procedure> + +<para +>Para verificar se a segurança funciona de fato, nós deveremos ver como é que as mensagens se processam nas ligações não-autenticadas: </para> + +<itemizedlist> +<listitem> +<para +>Antes de a autenticação ser bem sucedida, o servidor não irá receber outras mensagens da conexão. Em vez disso, se o servidor por exemplo estiver esperando uma mensagem <quote +>ClientHello</quote +> e obtiver uma mensagem de mcopInvocation, irá interromper a conexão. </para> +</listitem> + +<listitem> +<para +>Se o cliente não enviar uma mensagem de &MCOP; totalmente válida (sem o código especial do &MCOP; no cabeçalho da mensagem) na fase de autenticação, mas sim outra coisa qualquer, a conexão será interrompida. </para> +</listitem> + +<listitem> +<para +>Se o cliente tentar enviar uma mensagem muito grande (> 4096 bytes na fase de autenticação, o tamanho da mensagem é truncado para 0 bytes, o que fará com que não seja aceita para a autenticação). Isto é para evitar que os clientes não-autenticados enviem mensagens de ⪚ 100 megabytes, o que faria com que fosse recebida e com que o servidor estourasse com falta de memória. </para> +</listitem> + +<listitem> +<para +>Se o cliente enviar uma mensagem ClientHello corrompida (uma, onde a decodificação falhe), a conexão é mais uma vez quebrada. </para> +</listitem> + +<listitem> +<para +>Se o cliente não enviar nada de nada, então ocorrerá a expiração de tempo-limite (ainda a ser implementado). </para> +</listitem> +</itemizedlist> + +</sect1> + +<sect1 id="mcop-protocol"> +<title +>Especificação do Protocolo &MCOP;</title> + +<sect2 id="mcop-protocol-intro"> +<title +>Introdução</title> + +<para +>Existem semelhanças conceituais com o <acronym +>CORBA</acronym +>, mas pretende expandí-las de todas as formas necessárias para as operações multimídia em tempo-real. </para> + +<para +>Oferece um modelo de objetos multimídia, o qual poderá ser usado para: a comunicação entre os componentes num espaço de endereçamento (um processo) e entre componentes que existam em tarefas, processos ou mesmo máquinas diferentes. </para> + +<para +>Tudo junto, será desenhado para uma performance extremamente alta (de modo que tudo seja otimizado para ser extremamente rápido), o que é adequado para as aplicações multimídia bastante comunicativas. Por exemplo, a transmissão de vídeos é uma das aplicações do &MCOP;, onde a maioria das implementações de <acronym +>CORBA</acronym +> 'cairiam de joelhos'. </para> + +<para +>As definições das interfaces conseguem lidar com os seguintes aspectos nativamente: </para> + +<itemizedlist> +<listitem> +<para +>Fluxos contínuos de dados (como os dados de áudio). </para> +</listitem> + +<listitem> +<para +>Eventos de fluxos de dados (como os eventos do &MIDI;). </para> +</listitem> + +<listitem> +<para +>Contagem de referências real. </para> +</listitem> +</itemizedlist> + +<para +>e os truques mais importantes do <acronym +>CORBA</acronym +>, como </para> + +<itemizedlist> +<listitem> +<para +>Invocações de métodos síncronas. </para> +</listitem> + +<listitem> +<para +>Invocações de métodos assíncronas. </para> +</listitem> + +<listitem> +<para +>Construção de tipos de dados definidos pelo usuário. </para> +</listitem> + +<listitem> +<para +>Herança múltipla. </para> +</listitem> + +<listitem> +<para +>Passagem de referências de objetos. </para> +</listitem> +</itemizedlist> + +</sect2> + +<sect2 id="mcop-protocol-marshalling"> +<title +>A Codificação das Mensagens do &MCOP;</title> + +<para +>Objetivos/idéias de desenho: </para> + +<itemizedlist> + +<listitem> +<para +>A codificação deverá ser simples de implementar. </para> +</listitem> + +<listitem> +<para +>A decodificação necessita que o destinatário saiba qual é o tipo que ele deseja decodificar. </para> +</listitem> + +<listitem> +<para +>O destinatário esperará usar toda a informação - por isso, só são ignorados os dados no protocolo ao nível em que: </para> + +<itemizedlist> +<listitem> +<para +>Se você souber que vai receber um bloco de bytes, não precisa procurar em cada byte por um marcador de fim. </para> +</listitem> + +<listitem> +<para +>Se você souber que vai receber uma cadeia de caracteres, não precisa ler até encontrar o byte zero para descobrir o seu tamanho, contudo, </para> +</listitem> + +<listitem> +<para +>Se você souber que vai receber uma sequência de cadeias de caracteres, você precisa saber o tamanho de cada uma delas para descobrir o fim da sequência, uma vez que as cadeias de caracteres possuem tamanho variável. Mas se você usar as cadeias de caracteres para algo útil, você terá de fazer isso de qualquer jeito, por isso não se perde nada. </para> +</listitem> +</itemizedlist> + +</listitem> + +<listitem> +<para +>O mínimo de sobrecarga possível. </para> +</listitem> +</itemizedlist> + +<!-- TODO: Make this a table --> + +<para +>A codificação dos diferentes tipos é mostrada na tabela em baixo: </para> + +<informaltable> +<tgroup cols="3"> +<thead> +<row> +<entry +>Tipo</entry> +<entry +>Processo de Codificação</entry> +<entry +>Resultado</entry> +</row> +</thead> + +<tbody> +<row> +<entry +><type +>void</type +></entry> +<entry +>Os tipos <type +>void</type +> são codificados, omitindo-os, de modo a que não seja nada escrito no canal.</entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>long</type +></entry> +<entry +>é codificado como quatro bytes, em que o byte mais significativo vem primeiro, de modo a que o número 10001025 (correspondente à 0x989a81) será codificado como:</entry> +<entry +><literal +>0x00 0x98 0x9a 0x81</literal +></entry> +</row> + +<row> +<entry +><type +>enums</type +></entry> +<entry +><para +>são codificados como <type +>long</type +>s</para +></entry> +<entry +></entry> +</row> + +<row> +<entry +><type +>byte</type +></entry> +<entry +><para +>é codificado como um único byte, de modo a que o byte 0x42 será codificado como:</para +></entry> +<entry +><literal +>0x42</literal +></entry> +</row> + +<row> +<entry +><type +>string</type +></entry> +<entry +><para +>é codificado como um <type +>long</type +>, contendo o tamanho da cadeia de caracteres seguinte, e pela sequência de caracteres propriamente dita, terminando com um byte zero (que está incluído na contagem do tamanho).</para> +<important> +<para +>inclui o byte 0 final na contagem do tamanho!</para> +</important> +<para +>O <quote +>ola</quote +> seria codificado da seguinte forma:</para +></entry> +<entry +><literal +>0x00 0x00 0x00 0x04 0x6f 0x6c 0x60 0x00</literal +></entry> +</row> + +<row> +<entry +><type +>boolean</type +></entry> +<entry +><para +>é codificado como um byte, contendo 0 se for <returnvalue +>false</returnvalue +> (falso) ou 1 se for <returnvalue +>true</returnvalue +> (verdadeiro), de modo a que o valor booleano <returnvalue +>true</returnvalue +> é codificado como:</para +></entry> +<entry +><literal +>0x01</literal +></entry> +</row> + +<row> +<entry +><type +>float</type +></entry> +<entry +><para +>é codificado na representação de 4 bytes do IEEE754 - a documentação detalhada de como o IEEE funciona estão aqui: <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 +> e aqui: <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 +>. Deste modo, o valor 2,15 seria codificado como:</para +></entry> +<entry +><literal +>0x9a 0x99 0x09 0x40</literal +></entry> +</row> + +<row> +<entry +><type +>struct</type +></entry> +<entry +><para +>Uma estrutura é codificada com base no seu conteúdo. Não existem prefixos ou sufixos adicionais, por isso a estrutura </para> +<programlisting +>struct teste { + string nome; // que é igual a "ola" + long valor; // que é igual a 10001025 (0x989a81) +}; +</programlisting> +<para +>seria codificada como</para +></entry> +<entry> +<literallayout +>0x00 0x00 0x00 0x04 0x6f 0x6c 0x60 0x00 +0x00 0x98 0x9a 0x81 +</literallayout +></entry> +</row> + +<row> +<entry +><type +>sequence</type +></entry> +<entry +><para +>uma sequência é codificada através da listagem do número de elementos que se seguem e da descodificação dos elementos, um a um.</para> +<para +>Por isso uma sequência de 3 longs 'a', with a[0] = 0x12345678, a[1] = 0x01 e a[2] = 0x42 seria codificada 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 +>Se você precisar de fazer referência a um tipo, todos os tipos primitivos são referidos pelos nomes indicados acima. As estruturas e as enumerações possuem nomes próprios (como Header). As sequências são referidas como um *<replaceable +>tipo normal</replaceable +>, de modo que uma sequência de longs é um <quote +>*long</quote +> e uma sequência de estruturas Header é um <quote +>*Header</quote +>. </para> + +</sect2> + +<sect2 id="mcop-protocol-messages"> +<title +>Mensagens</title> + +<para +>O formato do cabeçalho das mensagens do &MCOP; está definido pela seguinte estrutura: </para> + +<programlisting +>struct Header { + long magic; // o valor 0x4d434f50, que é codificado como MCOP + long messageLength; + long messageType; +}; +</programlisting> + +<para +>Os valores possíveis de messageTypes são atualmente </para> + +<programlisting +>mcopServerHello = 1 + mcopClientHello = 2 + mcopAuthAccept = 3 + mcopInvocation = 4 + mcopReturn = 5 + mcopOnewayInvocation = 6 +</programlisting> + +<para +>Algumas notas sobre as mensagens do &MCOP;: </para> + + +<itemizedlist> +<listitem> +<para +>Todas as mensagens começam com uma estrutura Header. </para> +</listitem> + +<listitem> +<para +>Alguns dos tipos de mensagens deverão ser ignorados pelo servidor, enquanto a autenticação não estiver completa. </para> +</listitem> + +<listitem> +<para +>Depois de receber o cabeçalho, o tratamento do protocolo (conexão) poderá receber a mensagem por completo, sem olhar para o seu conteúdo. </para> +</listitem> +</itemizedlist> + +<para +>O messageLength no cabeçalho é, obviamente em alguns casos, redundante, o que significa que esta aproximação não é minimalista no que respeita ao número de bytes. </para> + +<para +>Contudo, isto conduz a uma implementação simples (e rápida) do processamento não em bloqueante de mensagens. Com a ajuda do cabeçalho, as mensagens poderão ser recebidas pelas classes de tratamento do protocolo em segundo plano (não-bloqueante), se existirem demasiadas ligações ao servidor, todas elas poderão ser servidas em paralelo. Você não precisa de olhar para o conteúdo da mensagem para recebê-la (e para determinar que terminou), basta olhar para o cabeçalho, assim o código para isso é relativamente simples. </para> + +<para +>Logo que uma mensagem esteja lá, ela poderá ser descodificada e processada em um único passo, sem se preocupar com os casos em que nem todos os dados foram recebidos (porque o messageLength garante que tudo está lá). </para> + +</sect2> + +<sect2 id="mcop-protocol-invocations"> +<title +>Invocações</title> + +<para +>Para invocar um método remoto, você precisa enviar a seguinte estrutura no corpo de uma mensagem de &MCOP; com o messageType = 1 (mcopInvocation): </para> + +<programlisting +>struct Invocation { + long objectID; + long methodID; + long requestID; +}; +</programlisting> + +<para +>depois disso, você envia os parâmetros como uma estrutura, ⪚ se você invocar o método concatenar(string s1, string s2), você envia uma estrutura do tipo </para> + +<programlisting +>struct InvocationBody { + string s1; + string s2; +}; +</programlisting> + + +<para +>se o método foi declarado como só de ida0 - o que significa que é assíncrono sem código devolvido - então isto é tudo. Caso contrário, você iria receber como resposta uma mensagem com o messageType = 2 (mcopReturn) </para> + +<programlisting +>struct ReturnCode { + long requestID; + <tipo-a-devolver> result; +}; +</programlisting> + + +<para +>em que o <tipo-resultante> é o tipo do resultado. Como os tipos void são omitidos na codificação, você também poderá só escrever o requestID se regressar de um método void. </para> + +<para +>Por isso o nosso método string concatenar(string s1, string s2) iria originar um código de resultado do tipo </para> + +<programlisting +>struct ReturnCode { + long requestID; + string result; +}; +</programlisting> + +</sect2> + +<sect2 id="mcop-protocol-inspecting"> +<title +>Inspecionando as Interfaces</title> + +<para +>Para fazer as invocações, você teria de conhecer os métodos que um objeto suporta. Para fazer isto, o methodID 0, 1, 2 e 3 estão pré-destinados a certas funcionalidades. Isto é </para> + +<programlisting +>long _lookupMethod(MethodDef defMetodo); // methodID sempre a 0 +string _interfaceName(); // methodID sempre a 1 +InterfaceDef _queryInterface(string nome); // methodID sempre a 2 +TypeDef _queryType(string nome); // methodID sempre a 3 +</programlisting> + +<para +>para ler isso, você obviamente precisa de </para> + +<programlisting +>struct MethodDef { + string methodName; + string type; + long flags; // posto a 0 por agora (será necessário na transmissão) + sequence<ParamDef> signature; +}; + +struct ParamDef { + string name; + long typeCode; +}; +</programlisting> + +<para +>o campo parameters contém os componentes do tipo que indicam os tipos dos parâmetros. O tipo do valor devolvido é indicado no campo type do MethodDef. </para> + +<para +>Na forma restrita, só os métodos <methodname +>_lookupMethod()</methodname +> e <methodname +>_interfaceName()</methodname +> são diferentes de objeto para objeto, enquanto que o <methodname +>_queryInterface()</methodname +> e o <methodname +>_queryType()</methodname +> são sempre os mesmos. </para> + +<para +>O que são esses methodIDs? Se você fizer uma invocação de &MCOP;, irá ficar esperando para passar um número para o método que você está invocando. A razão para isso é que os números podem ser processados muito mais depressa do que as cadeias de caracteres ao executar um pedido ao &MCOP;. </para> + +<para +>Por isso, como é que obtém esses números? Se você souber a assinatura do método, existe um MethodDef que descreve o método (e que contém o nome, o tipo, os nomes e os tipos de parâmetros, entre outras coisas) e você poderá passar isso ao _lookupMethod do objeto onde deseja invocar um método. Dado que o _lookupMethod está pré-associado ao methodID 0, você não deverá ter problemas ao fazê-lo. </para> + +<para +>Por outro lado, se você não souber a assinatura do método, você poderá descobrir os métodos que são suportados, usando o _interfaceName, o _queryInterface e o _queryType. </para> +</sect2> + +<sect2 id="mcop-protocol-typedefs"> +<title +>Definições dos Tipos</title> + +<para +>Os tipos de dados definidos pelo usuário são descritos com a estrutura <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 +>Porquê o &arts; Não Usa o &DCOP;</title> + +<para +>Uma vez que o &kde; abandonou o <acronym +>CORBA</acronym +> por completo e está usando o &DCOP; em todo o sistema, naturalmente a questão a se levantar é porque o &arts; não faz isso também. Afinal de contas, o suporte do &DCOP; está no <classname +>KApplication</classname +>, é bem-mantido, supostamente integra-se bem com a libICE, entre outras coisas. </para> + +<para +>Uma vez que existirá (potencialmente) uma grande quantidade de pessoas a se perguntar se ter o &MCOP; além do &DCOP; é realmente necessário, aqui está a resposta. Não me levem a mal, porque eu não está dizendo que o <quote +>o &DCOP; é ruim</quote +>. Eu estou simplesmente tentando dizer que <quote +>o &DCOP; não é a solução adequada para o &arts;</quote +> (embora seja uma boa solução para outras coisas). </para> + +<para +>Primeiro, você precisa de compreender para que o &DCOP; foi criado. Desenvolvido em dois dias durante o encontro &kde;-TWO, pretendia ser o mais simples possível, um protocolo de comunicações realmente <quote +>leve</quote +>. Especialmente, a implementação descartou tudo que pudesse envolver complexidade, como por exemplo um conceito completo de como os tipos de dados seriam codificados. </para> + +<para +>Ainda que o &DCOP; não se preocupe com certas coisas (por exemplo: como é que se envia uma cadeia de caracteres de forma transparente na rede?) - isso precisa de ser feito. Por isso, tudo o que o &DCOP; não faz, fica a cargo do &Qt; nos aplicativos do &kde; que usam o &DCOP; hoje em dia. Isto é em grande parte gestão de tipos (usando o operador de serialização do &Qt;). </para> + +<para +>Por isso, o &DCOP; é um protocolo mínimo que permite perfeitamente aos aplicativos do &kde; enviarem mensagens simples do tipo <quote +>abrir uma janela a apontar para http://www.kde.org</quote +> ou <quote +>os seus dados de configuração mudaram</quote +>. Contudo, dentro do &arts; o foco situa-se em outras coisas. </para> + +<para +>A idéia é que alguns pequenos plugins do &arts; irão comunicar-se, trocando algumas estruturas de dados como <quote +>eventos MIDI</quote +> e <quote +>ponteiros de posição na música</quote +> ou <quote +>gráficos de fluxo</quote +>. </para> + +<para +>Estes são tipos de dados complexos, os quais deverão ser enviados entre objetos diferentes e passados como sequências ou parâmetros. O &MCOP; fornece um conceito de tipos para definir dados complexos a partir de dados mais simples (de forma semelhante às estruturas ou vetores no C++). O &DCOP; não se preocupa com os tipos como um todo, por isso este problema seria deixado para o programador - como: criar classes de C++ para os tipos, certificando-se que eles pudessem serializar-se corretamente (por exemplo: suportar o operador de transmissão do &Qt;). </para> + +<para +>Mas desta forma, eles seriam inacessíveis a tudo o que não fosse codificação direta de C++. Especificamente, você não poderia desenhar uma linguagem de scripting que conhecesse todos os plugins de tipo a que poderão estar expostos, uma vez que eles não se descrevem a si próprios. </para> + +<para +>O mesmo argumento se aplica também às interfaces. Os objetos do &DCOP; não expõem as suas relações, hierarquias de herança, etc. - se você fosse criar um navegador de objetos que lhe mostrasse <quote +>que atributos tem este objeto</quote +>, seria mal-sucedido. </para> + + +<para +>Embora o Matthias tenha dito que existe uma função especial <quote +>functions</quote +> em cada objeto que lhe indica os métodos que um dado objeto suporta, isto deixa de fora coisas como os atributos (propriedades), as sequências e as relações de herança. </para> + +<para +>Isto quebra seriamente os aplicativos como o &arts-builder;. Mas lembre-se. o &DCOP; não pretendia ser um modelo de objetos (uma vez que o &Qt; já tem um com o <application +>moc</application +> e semelhantes), nem pretende ser algo semelhante ao <acronym +>CORBA</acronym +>, mas simplesmente uma forma de fornecer comunicação entre aplicativos. </para> + +<para +>Porque o &MCOP; ainda existe é: deverá funcionar perfeitamente com canais entre objetos. O &arts; faz um uso intensivo de pequenos plugins, que se interligam entre si com os fluxos. A versão em <acronym +>CORBA</acronym +> do &arts; tinha de introduzir uma divisão muito incômoda entre <quote +>os objetos SynthModule</quote +>, os quais eram os módulos de trabalho internos que faziam a transmissão e <quote +>a interface <acronym +>CORBA</acronym +></quote +>, que era algo externo. </para> + +<para +>Muito do código preocupava-se em fazer a interação entre <quote +>os objetos SynthModule</quote +> e <quote +>a interface <acronym +>CORBA</acronym +></quote +> parecer natural, mas não o era, porque o <acronym +>CORBA</acronym +> não sabia nada sobre fluxos. O &MCOP; sabe. Olhe para o código (algo como o <filename +>simplesoundserver_impl.cc</filename +>). Muito melhor! Fluxos podem ser declarados na interface dos módulos e implementados de forma natural. </para> + +<para +>Ninguém pode negar. Uma das razões pela qual o &MCOP; foi feito foi a velocidade. Aqui estão alguns argumentos de porque o &MCOP; será definitivamnete mais rápido que o &DCOP; (sem sequer mostrar imagens). </para> + + +<para +>Uma invocação do &MCOP; terá um cabeçalho com seis <quote +>long</quote +>s. Isto é: </para> + +<itemizedlist> +<listitem +><para +>o código do <quote +>MCOP</quote +></para +></listitem> +<listitem +><para +>o tipo da mensagem (invocação)</para +></listitem> +<listitem +><para +>o tamanho do pedido em bytes</para +></listitem> +<listitem +><para +>ID do pedido</para +></listitem> +<listitem +><para +>ID do objeto destino</para +></listitem> +<listitem +><para +>ID do método destino</para +></listitem> +</itemizedlist> + +<para +>Depois disso, seguem-se os parâmetros. Repare que a decodificação destes é extremamente rápida. Você poderá usar pesquisas em tabelas para encontrar o objeto e a função de decodificação do método, o que significa que a complexidade é O(1) (levará a mesma quantidade de tempo, independentemente de quantos objetos estão ativos, ou de quantas funções existem). </para> + +<para +>Comparando isto com o &DCOP;, verá que existem, pelo menos </para> + +<itemizedlist> +<listitem +><para +>uma cadeia de caracteres para o objeto destino - algo do tipo <quote +>aMinhaCalculadora</quote +></para +></listitem +> +<listitem +><para +>um texto do tipo <quote +>adicionarNumero(int,int)</quote +> para indicar qual o método</para +></listitem> +<listitem +><para +>muita mais informação do protocolo adicionada pela libICE, e outros detalhes do DCOP que eu desconheço</para +></listitem> +</itemizedlist> + +<para +>Tudo isto é muito doloroso para decodificar, uma vez que você irá necessitar de processar o texto, procurar a função, &etc;. </para> + +<para +>No &DCOP;, todos os pedidos são passados através de um servidor (o <application +>DCOPServer</application +>). Isto significa que o processo de uma invocação síncrona se assemelha a: </para> + +<itemizedlist> +<listitem> +<para +>O processo do cliente envia o pedido. </para> +</listitem> + +<listitem> +<para +>O <application +>DCOPserver</application +> (o intermediário) recebe a invocação e procura onde precisa ir, enviando para o servidor <quote +>real</quote +>. </para> +</listitem +> + +<listitem> +<para +>O processo do servidor recebe a invocação, efetua o pedido e envia o resultado. </para> +</listitem> + +<listitem> +<para +>O <application +>DCOPserver</application +> (o intermediário) recebe o resultado e ... envia-o para o cliente. </para> +</listitem> + +<listitem> +<para +>O cliente decodifica a resposta. </para> +</listitem> +</itemizedlist> + +<para +>No &MCOP;, a mesma invocação assemelha-se ao seguinte: </para> + +<itemizedlist> +<listitem> +<para +>O processo do cliente envia o pedido. </para> +</listitem> + +<listitem> +<para +>O processo do servidor recebe a invocação, efetua o pedido e envia o resultado. </para> +</listitem> + +<listitem> +<para +>O cliente decodifica a resposta. </para> +</listitem> +</itemizedlist> + +<para +>Digamos que ambos foram implementados corretamente, a estratégia ponto-a-ponto do &MCOP; deverá ser mais rápida por um fator de 2, do que a estratégia de intermediário do &DCOP;. Repare contudo que existiam razões para escolher a estratégia do &DCOP;, principalmente: se você tiver 20 aplicativos rodando, se cada um estiver conversando com outro, você precisa de 20 conexões no &DCOP;, e de 200 com o &MCOP;. Contudo, no caso de multimídia, isto supostamente não será a configuração normal. </para> + +<para +>Tentou-se comparar o &MCOP; com o &DCOP;, fazendo uma invocação do tipo adicionar dois números. Alterou-se o testdcop para conseguir isto. Porém, o teste pode não ter sido confiável do lado do &DCOP;. Invocou-se o método no mesmo processo que fez a chamada para o &DCOP;, e não se soube como se ver livre de uma mensagem de depuração, pelo que foi feita redireção do resultado. </para> + +<para +>O teste só usava um objeto e uma função, esperando que os resultados do &DCOP; começassem a descer com mais objetos e funções, enquanto os resultados do &MCOP; deveriam se manter iguais. Também, o processo do <application +>dcopserver</application +> não estava conectado a nenhum dos outros aplicativos, uma vez que, se existissem outros aplicativos conectados, a performance do encaminhamento iria decrescer. </para> + +<para +>O resultado obtido foi que, enquanto o &DCOP; obteve cerca de 2000 invocações por segundo, o &MCOP; obteve um pouco mais de 8000 invocações por segundo. Isto resulta em um fator de 4. Sabe-se que o &MCOP; não está ajustado para o máximo possível, ainda. (Comparação: o <acronym +>CORBA</acronym +>, implementado no mico, faz algo entre 1000 e 1500 invocações por segundo). </para> + +<para +>Se você quiser dados <quote +>brutos</quote +>, pense em fazer algum aplicativo de medida de performance para o &DCOP; e envie-o para mim. </para> + +<para +>O <acronym +>CORBA</acronym +> tinha uma funcionalidade interessante na qual você poderia usar os objetos que implementou uma vez, como <quote +>processos de servidor separados</quote +> ou como <quote +>bibliotecas</quote +>. Você poderia usar o mesmo código para tal, e o <acronym +>CORBA</acronym +> iria decidir transparentemente o que fazer. Com o &DCOP;, isto não é realmente pretendido, e tanto quanto se sabe não é possível realmente. </para> + +<para +>O &MCOP;, por outro lado, deverá suportá-lo desde o início. Por isso, você poderá rodar um efeito dentro do &artsd;. Mas se você for um editor de ondas, você poderá optar por rodar o mesmo efeito dentro do espaço do processo. </para> + +<para +>Embora o &DCOP; seja, em grande medida, uma forma de comunicação entre aplicativos, o &MCOP; também o é. Especialmente para a transmissão multimídia, o que é importante (uma vez que você poderá rodar vários objetos &MCOP; em paralelo, para resolver uma tarefa de multimídia no seu aplicativo). </para> + +<para +>Ainda que o o &MCOP; não o faça de momento, as possibilidades estão em aberto para implementar as funcionalidades de qualidade de serviço. Algo do gênero <quote +>aquele evento &MIDI; é mesmo MUITO importante, em comparação com esta invocação</quote +>. Ou algo do tipo <quote +>necessita de estar ali a tempo</quote +>. </para> + +<para +>Por outro lado, a transferência de fluxos poderá ser integrada no protocolo &MCOP; sem problemas e ser combinada com elementos de <acronym +>QoS</acronym +>. Uma vez que o protocolo poderá ser alterado, a transferência de fluxos do &MCOP; não deverá ser mais lenta do que uma transmissão convencional de <acronym +>TCP</acronym +>, mas: é mais fácil e mais consistente de usar. </para> + +<para +>Não existe necessidade de basear uma plataforma de multimídia no &Qt;. Ao decidir isso, e usando toda aquela serialização e outras funcionalidades de fluxo do &Qt;, iria conduzir facilmente a que a plataforma se tornasse apenas para o &Qt; (ou apenas para o &kde;). Quer dizer: tão logo se veja os GNOMEs começando a usar o &DCOP;, também, ou algo do gênero, provavelmente eu estarei errado. </para> + +<para +>Enquanto se sabe que o &DCOP; basicamente não sabe nada sobre os tipos de dados que envia, de modo que você poderia usar o &DCOP; sem usar o &Qt;, veja como é usado no uso do dia-a-dia do &kde;: as pessoas enviam tipos como o <classname +>QString</classname +>, o <classname +>QRect</classname +>, o <classname +>QPixmap</classname +>, o <classname +>QCString</classname +>, ..., de um lado para o outro. Estes usam a serialização do &Qt;. Por isso, se alguém optar por suportar o &DCOP; em um programa do GNOME, ele teria de afirmar que usava os tipos <classname +>QString</classname +>,... (ainda que não o faça, de fato) e emular a forma como o &Qt; faz a transmissão, ou então teria de enviar outros tipos de cadeias de caracteres, imagens e retângulos, o que deixaria de ser interoperável. </para> + +<para +>Bem, seja o que for, o &arts; pretendeu sempre funcionar com ou sem o &kde;, com ou sem o &Qt;, com ou sem o X11, e talvez com ou sem o &Linux; (e não há problema nenhum com as pessoas que o transpõem para um sistema operacional proprietário conhecido). </para> + +<para +>É a minha posição que os componentes não&GUI; deverão ser criados de forma independente da &GUI;, para possibilitar o compartilhamento destes pela maior quantidade de programadores (e usuários) possível. </para> + +<para +>É óbvio que o uso de dois protocolos de <acronym +>IPC</acronym +> pode causar inconveniências. Ainda mais, se ambos não forem normatizados. Contudo, pelas razões indicadas acima, a mudança para o &DCOP; não é uma opção. Se existir um interesse significativo em encontrar uma forma de unir os dois, ok, poderemos tentar. Até poderemos tentar fazer com que o &MCOP; fale <acronym +>IIOP</acronym +>, onde então poderemos passar a ter um <acronym +>ORB</acronym +> de <acronym +>CORBA</acronym +>. </para> + +<para +>Eu falei com o Matthias Ettrich um pouco sobre o futuro dos dois protocolos e encontramos diversas formas de como as coisas poderão seguir daqui para a frente. Por exemplo, o &MCOP; poderia tratar da comunicação de mensagens no &DCOP;, colocando os protocolos um pouco mais juntos. </para> + +<para +>Assim algumas soluções possíveis seriam: </para> + +<itemizedlist> +<listitem> +<para +>Criar uma gateway de &MCOP; - &DCOP; (o qual deverá ser possível, e possibilitaria a interoperabilidade) - nota: existe um protótipo experimental, se você quiser ver algo sobre o assunto. </para> +</listitem> + +<listitem> +<para +>Integrar tudo o que os usuários do &DCOP; esperam no &MCOP;, e tentar apenas usar o &MCOP; - uma pessoa até poderia adicionar uma opção de <quote +>intermediário</quote +> no &MCOP;, também ;) </para> +</listitem> + +<listitem> +<para +>Basear o &DCOP; no &MCOP; em vez da libICE, e começar a integrar lentamente as coisas em conjunto. </para> +</listitem> +</itemizedlist> + +<para +>Contudo, poderá não ser a pior possibilidade para usar cada protocolo em tudo em que se pensou usar (existem algumas grandes diferenças nos objetivos de desenho), e não vale a pena tentar juntá-los num só. </para> + +</sect1> +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/midi.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/midi.docbook new file mode 100644 index 00000000000..ed07feec978 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/midi.docbook @@ -0,0 +1,524 @@ +<!-- <?xml version="1.0" ?> +<!DOCTYPE chapter PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd"> +To validate or process this file as a standalone document, uncomment +this prolog. Be sure to comment it out again when you are done --> + +<chapter id="midi"> +<title +>&MIDI;</title> + +<sect1 id="midi-overview"> +<title +>Introdução</title> + +<!-- what-to-say-here: aRts has three roles + * moving midi events around between applications + * abstracting the hardware + * synthesizer --> + +<para +>O suporte ao &MIDI; no &arts; pode fazer uma grande quantidade de coisas. Antes de mais nada, permite a <emphasis +>comunicação</emphasis +> entre as diversas peças de software que produzem ou consomem eventos &MIDI;. Se você, por exemplo, tiver uma sequenciador e um reprodutor que funcionem com o &arts;, o &arts; poderá enviar os eventos &MIDI; do sequenciador para o reprodutor. </para> + +<para +>Por outro lado, o &arts; pode também ajudar os aplicativos a <emphasis +>interagir com o hardware</emphasis +>. Se uma determinada parte de um software (como, por exemplo, o suporte de amostragem) funcionar com o &arts;, ela será capaz de receber os eventos &MIDI; de um teclado &MIDI; externo, da mesma forma. </para> + +<para +>Finalmente, o &arts; fornece um excelente <emphasis +>sintetizador modular</emphasis +>. Ele está desenhado para fazer exatamente isso. Por isso, você poderá criar instrumentos a partir de pequenos módulos com o artsbuilder, e usar depois esses instrumentos para compor ou tocar música. A síntese poderá não ser pura, uma vez que existem módulos que você poderá usar para tocar amostras. Por isso, o &arts; poderá ser um reprodutor de amostras, um sintetizador, entre outras coisas e, sendo completamente modular, é muito fácil de extender, muito fácil de experimentar, além de ser poderoso e flexível. </para> +</sect1> + +<sect1 id="midi-manager"> +<title +>O Gerenciador de &MIDI;</title> +<!-- what-to-say-here: + * how to use artscontrol - view midimanager + * what does autorestore do? (not yet implemented - so not yet documented) --> + +<para +>A componente central no &arts; que mantém o registo dos aplicativos que estão conectados e como os eventos deverão ser passados entre eles é o gerenciador MIDI. Para ver ou influenciar o que ele faz, inicie o artscontrol. Depois, escolha <menuchoice +><guilabel +>Ver</guilabel +><guilabel +>Ver o Gerenciador de MIDI</guilabel +> </menuchoice +> no menu. </para> + +<para +>Do lado esquerdo, você verá as <guilabel +>Entradas MIDI</guilabel +>. Aqui, todos os objetos que produzem eventos &MIDI;, como por exemplo uma porta &MIDI; que envie dados vindos de um teclado &MIDI; conectado, um sequenciador que toque uma música, entre outras coisas, serão listados. Do lado direito, você verá as <guilabel +>Saídas MIDI</guilabel +>. Aqui, todas as coisas que consumam eventos &MIDI;, como um reprodutor de amostras simulado (como software) ou a porta &MIDI; externa onde o seu reprodutor por hardware estará conectado, serão listadas. Os aplicativos novos, como os sequenciadores se registarão eles próprios, de modo que a lista vá sendo atualizada ao longo do tempo. </para> + +<para +>Você poderá conectar as entradas às saídas se você marcar a entrada do lado esquerdo e a saída do lado direito, escolhendo em seguida <guilabel +>Conectar</guilabel +> com o botão abaixo. O <guilabel +>Desconectar</guilabel +> funciona da mesma forma. Você irá ver o que está conectado como pequenas linhas entre as entradas e as saídas, no meio da janela. Observe que você poderá conectar um emissor a mais de um receptor (e vice-versa). </para> + +<para +>Os programas (como o sequenciador Brahms) se adicionarão eles próprios quando são iniciados e serão removidos da lista quando terminarem. Mas você também poderá adicionar itens novos no menu <guilabel +>Adicionar</guilabel +>: </para> + +<variablelist> +<varlistentry> +<term +><guimenuitem +>Porta MIDI do Sistema (OSS)</guimenuitem +></term> +<listitem> +<para +>Isto irá criar um novo objeto do &arts; que conversa com uma porta MIDI externa. </para> + +<para +>Uma vez que as portas MIDI externas podem fazer ambas as coisas (enviar e receber dados), a escolha desta opção irá adicionar uma entrada e uma saída MIDI. No &Linux;, você deverá ter um controlador <acronym +>OSS</acronym +> (ou <acronym +>OSS</acronym +>/Free, que vem com o kernel do seu &Linux;) ou um <acronym +>ALSA</acronym +> instalado para a sua placa de som, para que isto funcione. Ele irá perguntar o nome do dispositivo. Normalmente, é o <filename class="devicefile" +>/dev/midi</filename +> ou o <filename class="devicefile" +>/dev/midi00</filename +>. </para> + +<para +>Contudo, se você tiver mais de um dispositivo &MIDI; ou &MIDI; local instalado, poderão existir mais opções. Para ver mais informações sobre as suas portas &MIDI;, inicie o &kcontrolcenter; e escolha <menuchoice +><guilabel +>Informação</guilabel +> <guilabel +>Som</guilabel +></menuchoice +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Saída MIDI de Sintetização do aRts</guimenuitem +></term> +<listitem> +<para +>Isto irá adicionar uma nova saída &MIDI; com um instrumento sintetizado do &arts;. Se você escolher o item do menu, aparecerá uma janela que lhe permite escolher um instrumento. Você poderá criar instrumentos novos com o artsbuilder. Todos os arquivos <literal role="extension" +>.arts</literal +> com um nome que comece por <filename +>instrument_</filename +> irão aparecer aqui. </para> +</listitem> +</varlistentry> +</variablelist> + +</sect1> + +<sect1 id="brahms"> +<title +>Usando o &arts; & o Brahms</title> + +<para +>Atualmente, começar é bastante fácil. Você irá precisar de uma versão para o &kde; 2.1 ou superior do &brahms;, que poderá ser encontrada no módulo <literal +>kmusic</literal +> do <acronym +>CVS</acronym +>. Existe também algumas informações sobre como obter o &brahms; na <ulink url="http://www.arts-project.org/" +>Página Pessoal do aRts</ulink +> na seção Download. </para> + +<para +>Quando você o iniciar, ele irá aparecer no gerenciador de &MIDI;. Se você quiser fazer síntese, basta adicionar um instrumento sintetizado &MIDI; através da opção <menuchoice +><guilabel +>Adicionar</guilabel +><guilabel +>Saída MIDI de Síntese do aRts</guilabel +></menuchoice +>. </para> + +<para +>Escolha um instrumento (por exemplo, o <guilabel +>organ2</guilabel +>). Conecte-os com o botão <guilabel +>Ligar</guilabel +>. Finalmente, poderá começar a compor no &brahms;, para que o resultado seja sintetizado com o &arts;. </para> + +<para +>Normalmente, é uma boa ideia ter a janela do &artscontrol; aberta e ver se o volume não está muito alto (a qualidade piora quando as barras tocam no limite superior). Agora, você poderá começar a trabalhar em uma música de demonstração do &arts; e, se estiver pronta, poderá publicá-la no 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 +>O <command +>midisend</command +> é um pequeno aplicativo que lhe permitirá enviar eventos de &MIDI; a partir da linha de comando. Ele se registará como cliente, tal como acontece com os outras aplicativos. A forma mais simples de usá-lo é <screen +><prompt +>%</prompt +> <userinput +><command +>midisend</command +> <option +>-f</option +> <parameter +><replaceable +>/dev/midi00</replaceable +></parameter +></userinput +> </screen +>, o que irá fazer mais ou menos o mesmo que adicionar uma porta &MIDI; do sistema no &artscontrol;. (Não somente isso, porque o <command +>midisend</command +> só envia eventos). A diferença é que é fácil, por exemplo, iniciar o <command +>midisend</command +> em vários computadores diferentes (e, por isso, usar a transparência na rede). </para> + +<para +>Também é possível fazer com que o <command +>midisend</command +> envie os dados a partir do <filename class="devicefile" +>stdin</filename +>, que poderá usar para encaminhar os dados dos aplicativos que não conhecem o &arts;, como a seguir: <screen +><prompt +>%</prompt +> <userinput +><command +><replaceable +>aplicacao_que_produz_eventos_midi_no_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 +>Criar Instrumentos</title> + +<para +>A forma como o &arts; faz a síntese de &MIDI; é a seguinte: você tem uma estrutura com algumas portas de entrada, onde ele vai obter a frequência, a velocidade (volume) e um parâmetro que indica se a nota ainda continua pressionada. A estrutura deverá agora sintetizar exatamente a nota com esse volume e reagir ao parâmetro 'pressed' (pressionado) (onde o 'pressed' = 1 significa que o usuário ainda mantém essa tecla carregada e o 'pressed' = 0 significa que o usuário soltou a tecla). </para> + +<para +>Quando os eventos &MIDI; chegam, o &arts; irá criar novas estruturas para as notas à medida das necessidades, passar-lhes os parâmetros, e limpá-las quando terminar. </para> + +<para +>Para criar e usar uma dessas estruturas, você deverá fazer o seguinte: </para> + +<itemizedlist> +<listitem> +<para +>Para começar, a forma mais conveniente é abrir o arquivo <filename +>template_Instrument.arts</filename +> no &arts-builder;. </para> + +<para +>Isto poderá ser obtido se usar o <menuchoice +><guimenu +>Arquivo</guimenu +><guimenuitem +>Abrir um Exemplo...</guimenuitem +></menuchoice +> e escolher o <guimenuitem +>template_Instrument</guimenuitem +> no selector de arquivos. Isto irá fornecer-lhe uma estrutura vazia com os parâmetros necessários, os quais você só terá de <quote +>preencher</quote +>. </para> +</listitem> + +<listitem> +<para +>Para processar o parâmetro pressed, é conveniente usar o Synth_ENVELOPE_ADSR, ou, no caso de tocar apenas um WAV de uma bateria, simplesmente tocá-lo, ignorando deste modo o parâmetro pressed. </para> +</listitem> + +<listitem> +<para +>A estrutura deverá indicar quando já não é necessária na saída <quote +>done</quote +> (pronto). Se o done for igual a <returnvalue +>1</returnvalue +>, o &arts; irá assumir que pode remover a estrutura. Convenientemente, o envelope de ADSR fornece um parâmetro quando tiver terminado, por isso você só precisa conectar isto à saída done da estrutura. </para> +</listitem> + +<listitem> +<para +>Você deverá mudar o nome da sua estrutura para algum nome que comece por <filename +>instrument_</filename +>, como por exemplo <filename +>instrument_piano.arts</filename +> - você deverá gravar o arquivo com o mesmo nome na sua pasta <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +> (que é onde o artsbuilder normalmente deseja gravar os arquivos). </para> +</listitem> + +<listitem> +<para +>Finalmente, logo que o tenha salvo, você será capaz de usá-lo com o &artscontrol; no gerenciador de &MIDI;.</para> +</listitem> + +<listitem> +<para +>Ah, é claro que a sua estrutura deverá tocar os dados de áudio que gera nas saídas esquerda e direita da estrutura, que serão por sua vez tocadas no gerenciador de áudio (você poderá ver isso no &artscontrol;), para que o consiga ouvir finalmente (ou processá-lo posteriormente com efeitos). </para> +</listitem> +</itemizedlist> + +<para +>Uma boa forma de aprender como criar instrumentos é abrir um instrumento existente através da opção <menuchoice +><guilabel +>Arquivo</guilabel +><guilabel +>Abrir um Exemplo</guilabel +> </menuchoice +> e ver como funciona ;) </para> +</sect1> + +<sect1 id="mapped-instruments"> +<title +>Instrumentos Mapeados</title> + +<para +>Os instrumentos mapeados são os que se comportam de forma diferente, dependendo da frequência, do programa, do canal ou da velocidade. Você poderá ter por exemplo um piano de 5 oitavas, usando uma amostra por cada oitava (ajustando a frequência, de acordo com isso). Isto irá soar bastante melhor do que usar apenas uma amostra. </para> + +<para +>Você poderá criar também um mapa de bateria, que toca uma amostra específica da bateria por tecla. </para> + +<para +>Finalmente, é muito útil se você tocar vários sons diferentes num instrumento mapeado em programas diferentes. Desta forma, você poderá usar o seu sequenciador, teclado externo ou outra fonte &MIDI; para mudar de sons sem ter de ajustar o &arts; à medida que trabalha. </para> + +<para +>Um bom exemplo para isso é o instrumento <filename +>arts_all</filename +>, o qual apenas reune todos os instrumentos que vêm com o &arts; num mapa. Desta forma, você apenas terá de configurar uma vez o &artscontrol; para usar este <quote +>instrumento</quote +>, e assim, poderá compor uma música inteira num sequenciador sem ter de se incomodar com o &arts;. Precisa de outro som? Basta escolher o programa no sequenciador, para que o &arts; lhe dê outro som. </para> + +<para +>Criar esses mapas é relativamente simples. Você apenas precisa de criar um arquivo de texto e escrever regras que se assemelhem a isto: </para> + +<programlisting +>ON <replaceable +>[ condições ...]</replaceable +> DO structure=<replaceable +>uma_estrutura</replaceable +>.arts +</programlisting> + +<para +>As condições poderão ser uma ou mais das seguintes: </para> + +<variablelist> + +<varlistentry> +<term +><option +>pitch</option +></term> + +<listitem> +<para +>A frequência ou tom que é tocado. Você poderá usar isto se quiser dividir o seu instrumento com base no tom. No exemplo inicial, um piano que use amostras diferentes para as várias oitavas iria usar isto como condição. Você poderá indicar uma frequência única, como por exemplo <userinput +><option +>pitch</option +>=<parameter +>62</parameter +></userinput +> ou um intervalo de frequências, como por exemplo <userinput +><option +>pitch</option +>=<parameter +>60</parameter +>-<parameter +>72</parameter +></userinput +>. Os tons possíveis situam-se entre <parameter +>0</parameter +> e <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>program</option +></term> +<listitem> +<para +>O programa que está ativo no canal para onde a nota vai ser enviada. Normalmente, os sequenciadores permitem-lhe escolher o <quote +>instrumento</quote +> através da opção program. São permitidos programas únicos ou intervalos de programas, isto é, por exemplo, <userinput +><option +>program</option +>=<parameter +>3</parameter +></userinput +> ou <userinput +><option +>program</option +>=<parameter +>3</parameter +>-<parameter +>6</parameter +></userinput +>. Os programas possíveis situam-se entre <parameter +>0</parameter +> e <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>channel</option +></term> +<listitem> +<para +>O canal para onde a nota vai ser enviada. São permitidos canais únicos ou intervalos, isto é, por exemplo, <userinput +><option +>channel</option +>=<parameter +>0</parameter +></userinput +> ou <userinput +><option +>channel</option +>=<parameter +>0</parameter +>-<parameter +>8</parameter +></userinput +>. Os canais possíveis situam-se entre <parameter +>0</parameter +> e <parameter +>15</parameter +>. </para> +</listitem> + +</varlistentry> +<varlistentry> +<term +><option +>velocity</option +></term> +<listitem> +<para +>A velocidade (volume) que a nota tem. São permitidas velocidades únicas (quem irá usar isso?) ou intervalos, como por exemplo <userinput +><option +>velocity</option +>=<parameter +>127</parameter +></userinput +> ou <userinput +><option +>velocity</option +>=<parameter +>64</parameter +>-<parameter +>127</parameter +></userinput +>. As velocidades possíveis situam-se entre <parameter +>0</parameter +> e <parameter +>127</parameter +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Um exemplo completo para um mapa seria (este é extraído do arquivo <filename +>instrument_arts_all.arts-map</filename +> atual): </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 você poderá ver, a estrutura é selecionada, dependendo do programa. No programa 11, você vê um <quote +>mapa de bateria</quote +> (com dois itens), que irá tocar um <quote +>bombo</quote +> com o C-5 (pitch=60), e um <quote +>prato de choque</quote +> com o C#5 (pitch=61). </para> + +<para +>Para fazer com que os arquivos dos mapas apareçam automaticamente no &artscontrol; como opções dos instrumentos, terão de se chamar <filename +>instrument_<replaceable +>qualquercoisa</replaceable +>.arts-map</filename +> e estarem na sua Pasta Pessoal, em <filename class="directory" +>$<envar +>HOME</envar +>/arts/structures</filename +>, ou na pasta do &kde; em <filename class="directory" +>$<envar +>KDEDIR</envar +>/usr/local/kde/share/apps/artsbuilder/examples</filename +>. As estruturas que são usadas no mapa poderão ser indicadas com seu caminho completo ou então relativo à pasta onde o arquivo de mapa se encontra. </para> + +<para +>Extender o mapa arts_all map ou mesmo criar um mapa geral &MIDI; completo para o &arts; é uma boa idéia para tornar o &arts; mais simples de usar por si só. Pense por favor em contribuir com instrumentos interessantes que crie, de modo a que possam ser incluídos nas versões futuras do &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-pt_BR/docs/tdemultimedia/artsbuilder/midiintro.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/midiintro.docbook new file mode 100644 index 00000000000..81df5037ded --- /dev/null +++ b/tde-i18n-pt_BR/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 +>Introdução ao <acronym +>MIDI</acronym +></title> + +<para +>Não escrito ainda </para> + +</appendix> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/modules.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/modules.docbook new file mode 100644 index 00000000000..fbc58e618c9 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/modules.docbook @@ -0,0 +1,1329 @@ +<!-- <?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 do &arts;</title> + + <sect1 id="modules-introduction"> +<title +>Introdução</title> + +<para +>Este capítulo descreve todos os módulos normais do &arts;. Sendo uma das funcionalidades mais poderosas do &arts;, os módulos podem ser conectados em conjunto através de estruturas para implementar novas funções como efeitos e instrumentos. </para> + +<para +>Os módulos são divididos em duas categorias. Os módulos de síntese são usados para implementar a <quote +>canalização</quote +> que manipula os fluxos de dados multimídia para implementar novos efeitos, instrumentos, misturadores e aplicativos. Os módulos visuais permitem-lhe oferecer uma interface gráfica para o usuário poder controlar as estruturas de som que são criadas com os módulos de síntese. </para> + +</sect1> + +<sect1 id="synth-modules-reference"> +<title +>Referência dos Módulos de Síntese</title> + + +<sect2 id="mcat-synth-arithmetic-mixing"> +<title +>Aritmética + Mistura</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 +>Isto adiciona dois sinais. </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 +>Isto multiplica um sinal por um determinado fator. Você poderá usar isto para reduzir a amplitude dos sinais (0 < fator < 1) ou ampliá-los (fator > 1) ou ainda invertê-los (fator < 0). Observe que o fator pode ser um sinal e não tem que ser constante (⪚ um sinal de envelope ou um sinal 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 +>Isto divide um sinal por um fator. Você pode usar isto para dividir um sinal por outro. Ou configurar invalue1 para 1 e você obterá o recíproco de invalue2 como outvalue. Tome cuidado para que o invalue2 nunce atinja 0 ou você terá problemas com divisões por zero. </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 +>Isto adiciona uma quantidade arbitrária de sinais. Se você precisar de somar todas as formas de onda produzidas por quatro osciladores, você poderá conectar todas as saídas deles a um único módulo Synth_MULTI_ADD. Isto é mais eficiente do que usar três 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 +>Isto mistura dois sinais. Se o valor da percentagem for igual a -1, só o sinal esquerdo é ouvido; se for igual a 1, só o sinal direito é ouvido. Se for 0 (zero), ambos os sinais são ouvidos com o mesmo volume. </para> + +<para +>Isto permite-lhe garantir que o seu sinal permaneça em um intervalo bem definido. Se você tiver dois sinais que estejam entre -1 e 1 antes da mistura, eles irão permanecer dentro do mesmo intervalo após a referida mistura. </para> +</sect3> + +<sect3 id="mref-synth-autopanner-sect"> +<title +>Synth_AUTOPANNER</title> +<anchor id="mref-synth-autopanner"/> + +<para +>O oposto de um cruzamento. Isto pega um sinal mono e divide-o em um sinal estéreo: Isto é usado para automaticamente distribuir o sinal entra as saídas esquerda e direita. Isto torna a mistura mais viva. Um aplicativo padrão deve ser uma guitarra ou som de ligação. </para> + +<para +>Conecta um <acronym +>LFO</acronym +>, uma onda senoidal ou dente-de-serra por exemplo ao inlfo. e seleciona uma frequência entre 0,1 e 5Hz para um efeito tradicional ou mais ainda para efeitos especiais. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-busses"> +<title +>Barramentos</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 +>Um canal de envio para um barramento. Fornece os sinais ao left (esquerdo) e ao right (direito), bem como o nome do barramento onde os dados deverão ir na porta <quote +>bus</quote +>. O sinal combinado de todos os canais de envio ('uplinks') irão aparecer em todos os canais de recepção ('downlinks') desse <quote +>barramento</quote +>. </para> +</sect3> + +<sect3 id="mref-synth-bus-downlink-sect"> +<title +>Synth_BUS_DOWNLINK</title> +<anchor id="mref-synth-bus-downlink"/> + +<mediaobject> +<imageobject> +<imagedata fileref="images/Synth_BUS_DOWNLINK.png" + format="PNG"/></imageobject> +<textobject +><phrase +>Synth_BUS_DOWNLINK</phrase +></textobject> +</mediaobject> + +<para +>Obtém (a soma de) todos os dados que são colocados num determinado barramento (com o nome que você indicar na porta <quote +>bus</quote +> (barramento)). </para> +</sect3> + +</sect2> + +<!-- TODO AFTER KDE2.1: move freeverb into delays, and rename category to + Delays & reverbs --> + +<sect2 id="mcat-synth-delays"> +<title +>Atrasos</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 +>Isto atrasa o sinal de entrada por um período de tempo determinado. A especificação do tempo deverá ser entre 0 e maxdelay (atraso máximo) para obter um atraso equivalente em segundos. </para> + +<para +>Este tipo de atraso <emphasis +>não pode ser usado</emphasis +> nas estruturas de realimentação ('feedback'). Isto acontece por ser um atraso variável. Você poderá modificar o seu tamanho durante a execução e até mesmo configurá-lo como zero. Mas como em uma estrutura de realimentação a própria saída é necessária para calcular as próximas amostras, uma atraso cujo valor possa cair para zero durante a síntese poderá conduzir a uma situação de interrupção. </para> + +<para +>Use os CDELAYs nesse caso, e combinando talvez um atraso constante (de 0,001 segundos) com um atraso flexível. </para> + +<para +>Você poderá também combinar um CDELAY com um DELAY para obter um atraso de tamanho variável com um valor mínimo num ciclo de realimentação. Certifique-se apenas que tem um 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 +>Isto atrasa o sinal de entrada por um período de tempo determinado. A especificação do tempo deverá ser maior que 0 para obter um atraso de 0 segundos ou mais. O atraso é constante durante o cálculo, o que significa que ele não poderá ser modificado. </para> + +<para +>Isto poupa tempo de cálculo, uma vez que não é feita nenhuma interpolação e é útil para estruturas recursivas. Veja a descrição acima (Synth_DELAY). </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-envelopes"> +<title +>Envelopes</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 +>Este é um envelope clássico de <acronym +>ADSR</acronym +>, o que significa que você indica: </para> + +<variablelist> +<varlistentry> +<term +>active</term> +<listitem> +<para +>Se a nota está sendo pressionada no momento pelo usuário. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>O sinal de entrada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>attack</term> +<listitem> +<para +>O tempo que deverá passar entre o usuário pressionar a nota e o sinal atingir a sua amplitude máxima (em segundos). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>decay</term> +<listitem> +<para +>O tempo que deverá passar entre o sinal atingir a sua amplitude máxima e voltar para um nível constante (em segundos). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>sustain</term> +<listitem> +<para +>O nível constante em que o sinal é mantido até que o usuário solte a nota. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>release</term> +<listitem> +<para +>O tempo que deverá passar depois do usuário soltar a nota até que o sinal seja reduzido à zero (em segundos). </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Você irá obter o sinal redimensionado em 'outvalue' (na saída). Se o envelope do <acronym +>ASDR</acronym +> tiver terminado, irá colocar o 'done' (terminado) a 1. Você poderá usar isto para fornecer a saída <quote +>done</quote +> de um instrumento (que fará com que a estrutura do instrumento seja removida pelo encaminhador de &MIDI; logo que a fase do 'release' tenha terminado). </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 +>O módulo Synth_PSCALE irá aplicar um fator de escala ao canal de áudio que passa por ele, de um volume 0 (silêncio) até o 1 (volume original), e de volta a 0 (silêncio). De acordo com a posição (pode obter a posição a partir de Synth_SEQUENCE). A altura em que o pico deverá ocorrer pode ser indicada em 'pos'. </para> + +<para +>Exemplo: Se definir o 'top' igual a 0,1 significa que, ao fim de 10% da nota ter sido tocada, o volume atingiu o seu máximo e começa a decair a partir daí. </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-effects"> +<title +>Efeitos</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 +>Este é um efeito de reverberação. Na implementação atual, passa um sinal estéreo através do efeito, adicionando a tal reverberação ao mesmo sinal. </para> + +<note> +<para +>Isto significa que ele também poderá ser usado numa StereoEffectStack. </para> +</note> + +<para +>O sinal de entrada deverá ser conectado a (inleft, inright) e o de saída a (outleft, outright). </para> + +<para +>Os parâmetros que você poderá configurar são: </para> + +<variablelist> +<varlistentry> +<term +>roomsize</term> +<listitem> +<para +>O tamanho da sala que a reverberação irá simular (intervalo: 0..1, em que o 1 é a maior sala possível). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>damp</term> +<listitem> +<para +>Isto indica um filtro que fará com que a sala simulada absorva as altas frequências (intervalo de 0..1, em que o 1 significa que as altas frequências são absorvidas de forma agressiva). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>wet</term> +<listitem> +<para +>A quantidade de sinal reverberado (isto é, a quantidade de sinal que deverá ser modificado pelos filtros, resultando em um som <quote +>molhado</quote +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>dry</term> +<listitem> +<para +>A quantidade de sinal puro que é passado, resultando num eco (ou atraso combinado), em vez de ser afetado por reverberação (intervalo: 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 +>A quantidade de efeito estéreo que o algoritmo de reverberação adiciona ao efeito, tornando o som reverberado mais amplo no panorama estéreo (intervalo: 0..1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mode</term> +<listitem> +<para +>[ TODO: Eu penos que, se o 'mode' for igual a 1, a reverberação mantém a imagem atual do som, onde o 0 é a operação 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 +>O módulo 'tremolo' modula a amplitude com base numa onda <acronym +>LFO</acronym +>. Tradicionalmente você iria usar uma onda senoidal, mas porquê limitar-se? O que irá obter é um efeito muito intenso que corta a maioria dos arranjos devido ao seu efeito altamente dinâmico. O efeito de 'tremolo' é ainda um dos efeitos favoritos dos guitarristas, ainda que não seja tão popular como era nos anos 60. </para> + +<para +>[ TODO: atualmente, isto está implementado como 'invalue + abs(inlfo)' - provavelmente faria mais sentido se fosse implementado como 'invalue * (1+inlfo*depth)', onde o 'depth' (profundidade) seria um parâmetro entre 0..1 - isto poderá ter sido decidido após o &kde;2.1 ; se você tiver um comentário, envie uma mensagem para a lista do &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 +>Um 'flanger' é um efeito de atraso variável no tempo. Para tornar o desenvolvimento de efeitos complexos de 'flanger' mais simples, é fornecido este módulo que contém a base de um 'flanger' de um canal. </para> + +<para +>Ele contém as seguintes portas:</para> + +<variablelist> +<varlistentry> +<term +>invalue</term> +<listitem> +<para +>O sinal que você deseja processar. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>lfo</term> +<listitem> +<para +>De preferência, uma onda senoidal que modula o tempo de atraso no 'flanger' (-1 .. 1). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mintime</term> +<listitem> +<para +>O valor mínimo para o atraso no 'flanger' em milisegundos. Valores sugeridos: tente algo como 1 ms. Por favor use valores < 1000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>maxtime</term> +<listitem> +<para +>O valor máximo para o atraso no 'flanger' em milisegundos. Valores sugeridos: tente algo como 5 ms. Por favor use valores < 1000 ms. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>outvalue</term> +<listitem> +<para +>O sinal de saída. É importante que você misture isso com o sinal original para obter o efeito desejado. </para> +</listitem> +</varlistentry> +</variablelist> + +<tip> +<para +>Você poderá usar isto com base para um efeito 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 +>Este efeito de mudança de frequência altera a frequência do sinal da entrada sem afetar a velocidade. Uma aplicação para isto é por exemplo a alteração do tom da sua voz enquanto você a grava (e reproduz) em tempo-real. </para> + +<para +>O parâmetro <emphasis +>speed</emphasis +> (velocidade) é a velocidade relativa com que o sinal será reproduzido. Deste modo, uma velocidade igual a dois fará com que o som fique duas vezes mas alto (&ie; uma frequência de entrada de 440 Hz iria resultar numa frequência de saída de 880 Hz). </para> + +<para +>O parâmetro <emphasis +>frequency</emphasis +> (frequência) é usado internamente para mudar entre as várias diferenças do sinal. É ajustável e, dependendo da sua escolha, o desvio de frequência parecerá mais ou menos realístico para o seu caso de uso. Um bom valor para começar será algo do tipo 5 ou 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 +>Filtra todas as frequências superiores à frequência 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 corta um sinal, de modo a fazer com que ele caiba no intervalo [-1;1]. Ele não faz nada para evitar a distorção que acontece ao cortar os sinais altos. Você poderá usar isto como um efeito (por exemplo, para criar uma onda senoidal ligeiramente cortada). Contudo, é provavelmente uma boa idéia passar o sinal através de um filtro passa-baixo depois disso, para tornar o som menos agressivo. </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 é um bloco de equalização parametrizado engraçado. Os seus parâmetros são: </para> + +<variablelist> +<varlistentry> +<term +>invalue, outvalue</term> +<listitem> +<para +>O sinal que é filtrado pelo equalizador. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>low</term> +<listitem> +<para +>Como é que as frequências baixas deverão ser alteradas. O valor está em dB, onde 0 significa que as baixas frequências não são alteradas, o -6 significa que as reduzirá em 6dB, e o +6 significa que as aumentará em 6dB. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>mid</term> +<listitem> +<para +>Como é que as frequências intermediárias deverão ser alteradas pelo equalizador (ver em 'low'). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>high</term> +<listitem> +<para +>Como é que as altas frequências deverão ser alteradas pelo equalizador (ver em 'low'). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>frequency</term> +<listitem> +<para +>Esta é a frequência central do equalizador em Hz, onde as frequências intermediárias se situam à volta desse espectro, tendo as baixas frequências à sua esquerda e as altas à direita. Observe que a frequência não poderá ser mais elevada que metade da taxa de amostragem; normalmente esta é igual a 22 050 Hz e não poderá ser menor que 1 Hz. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>q</term> +<listitem> +<para +>Isto influencia quão estreito é o espectro central. Deverá ser um número positivo > 0. Um valor igual a um é razoável, os valores mais elevados correspondem a um espectro mais estreito de frequências intermediárias e os menores que um correspondem a um espectro largo. </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 +>Um filtro por ressonância filtra todas as frequências ao redor de um determinado valor de pico. Não existe nenhuma forma útil de indicar a frequência intermediária (a que não será cortada), uma vez que as entradas são duas constantes estranhas 'f' e 'b'. O código é muito antigo, desde os primeiros dias do sintetizador, e provavelmente será substituído por um filtro novo que terá um frequência e um valor de ressonância como parâmetros). </para> + +<para +>Todavia tente algo do género b=5, f=5 ou b=10, f=10 ou 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 as frequências acima da frequência de corte (é um filtro de 24dB com 4 pólos, o qual filtra -24db por oitava acima da frequência de corte), mas oferece um parâmetro adicional para ajustar a ressonância do filtro, em que o 0 significa ausência de ressonância e o 4 significa auto-oscilação. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-midi-sequencing"> +<title +>MIDI + Sequenciação</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 carrega uma estrutura de um instrumento a partir de um arquivo e registra-se como uma saída de MIDI no gerenciador de &MIDI; do &arts;. As notas qiue são enviadas para esta saída irão resultar na criação de vozes dos instrumentos. </para> + +<note> +<para +>Você poderá configurar algo mais conveniente no &artscontrol; do que fazê-lo manualmente no &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 +>Irá tocar uma sequência de notas e tocar outra e outra vez. As notas são dadas na notação de teclado e são separadas por ponto-e-vírgula. Um exemplo será <literal +>A-3;C-4;E-4;C-4;</literal +>. A velocidade é dada em segundos por nota, por isso, se você quiser 120 batidas por minuto, você deverá indicar provavelmente 0,5 segundos por nota, uma vez que 60 segundos/0,5 segundos por nota=120 bpm. </para> + +<para +>Você poderá indicar em cada nota um tamanho relativo à velocidade adicionando dois pontos (:) após a nota, seguido do tamanho. O <literal +>A-3:2;C-4:0.5;D-4:0.5;E-4;</literal +> demonstra isto. Como pode ver, os programas de composição de &MIDI; tendem a oferecer mais conforto ;) </para> + +<para +>O Synth_SEQUENCE dá-lhe informações adicionais sobre a posição da nota que está sendo tocada no momento, onde o 0 indica que iniciou agora e o 1 que terminou. Esta informação poderá ser usada no Synth_PSCALE (veja em baixo). </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 tal-e-qual o Synth_SEQUENCE com a única diferença que você não indica nomes de notas mas sim frequências. </para> + +</sect3> + +</sect2> + +<sect2 id="mcat-synth-samples"> +<title +>Amostras</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 +>Isto irá tocar um arquivo <literal role="extension" +>wav</literal +>. Isto só estará presente se você tiver a libaudiofile instalada no seu computador. O arquivo WAVE iniciar-se-á logo que o módulo for criado. </para> + +<para +>Irá parar logo que tenha terminado, situação em que o finished (terminado) será configurado como 1. O parâmetro speed (velocidade) pode ser usado para reproduzir o arquivo mais depressa ou mais devagar, e onde o 1,0 é a velocidade normal (com que foi gravado). </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 Som</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 +>Você normalmente não irá necessitar deste módulo, a menos que esteja criando aplicativos autônomos. Dentro do &artsd;, já existe um módulo Synth_PLAY e, se criar outro, este não irá funcionar. </para> +</important> + +<para +>O módulo Synth_PLAY irá enviar o seu sinal de áudio para a placa de som. Os canais left (esquerdo) e right (direito) deverã conter a entrada <emphasis +>normalizada</emphasis +> dos canais. Se a sua entrada não estiver entre -1 e 1, será cortado o sinal. </para> + +<para +>Como já foi referido, só pode existir um módulo Synth_PLAY em uso, uma vez que este acessa diretamente sua placa de som. Utilize os barramentos se você quiser misturar mais de um canal de áudio em conjunto antes de reproduzí-lo. Use o módulo Synth_AMAN_PLAY para obter algo semelhante a uma saída no &artsd;. </para> + +<para +>Observe que o Synth_PLAY também faz a temporização da estrutura completa. Isto significa: sem Synth_PLAY = sem fonte de temporização = sem som. Por isso, você irá necessitar (exatamente) de um 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 +>Você normalmente não irá necessitar deste módulo, a menos que esteja criando aplicativos autônomos. Dentro do &artsd;, já existe um módulo Synth_RECORD e, se criar outro, este não irá funcionar. </para> +</important> + +<para +>O módulo Synth_RECORD irá gravar um sinal proveniente da placa de som. Os canais left (esquerdo) e right (direito) irão conter a entrada dos canais (entre -1 e 1). </para> + +<para +>Como já foi mencionado, só pode existir um módulo Synth_RECORD em uso, uma vez que este acessa diretamente sua placa de som. Utilize os barramentos se você quiser usar os canais de áudio gravados de mais de um lugar. Use o módulo Synth_AMAN_RECORD para obter algo semelhante a uma entrada no &artsd;. Para isto funcionar, o &artsd; deverá estar rodando <emphasis +>com o full duplex ativo</emphasis +>. </para> +</sect3> + +<sect3 id="mref-synth-aman-play-sect"> +<title +>Synth_AMAN_PLAY</title> +<anchor id="mref-synth-aman-play"/> + +<mediaobject +><imageobject +><imagedata fileref="images/Synth_AMAN_PLAY.png" +format="PNG"/></imageobject> +<textobject +><phrase +>Synth_AMAN_PLAY</phrase +></textobject> +</mediaobject> + +<para +>O módulo Synth_AMAN_PLAY irá enviar para a saída o seu sinal de áudio. É bom (mas não necessário) se você enviar para fora um sinal normalizado (entre -1 e 1). </para> + +<para +>Este módulo irá usar o gerenciador de áudio para atribuir onde o sinal será tocado. O gerenciador de áudio poderá ser controlado através do &artscontrol;. Para torná-lo mais intuitivo no seu uso, é bom dar ao sinal que será tocado um nome. Isto poderá ser obtido através da opção <emphasis +>title</emphasis +> (título). Outra funcionalidade do gerenciador de áudio é ser capaz de se recordar onde tocou um determinado sinal da última vez. Para fazer isso, ele precisa ser capaz de distinguir os sinais. É por isso que você deverá atribuir algo único ao <emphasis +>autoRestoreID</emphasis +>, também. </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 +>O módulo Synth_AMAN_RECORD irá gravar um sinal de áudio de uma fonte externa (&ie;. line in/microfone) para dentro do &artsd;. O resultado será um sinal normalizado (entre -1 e 1). </para> + +<para +>Este módulo irá usar o gerenciador de áudio para atribuir onde o sinal será tocado. O gerenciador de áudio poderá ser controlado através do &artscontrol;. Para torná-lo mais intuitivo no seu uso, é bom dar ao sinal a ser gravado um nome. Isto poderá ser obtido através da opção <emphasis +>title</emphasis +> (título). Outra funcionalidade do gerenciador de áudio é ser capaz de se recordar onde gravou um determinado sinal da última vez. Para fazer isso, ele precisa ser capaz de distinguir os sinais. É por isso que você deverá atribuir algo único ao <emphasis +>autoRestoreID</emphasis +>, também. </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 +>O módulo Synth_CAPTURE irá gravar um sinal de áudio em um arquivo WAVE no seu disco rígido. O arquivo será sempre chamado de <filename +>/tmp/mcop-<replaceable +>usuário</replaceable +>/capture.wav</filename +> </para> +</sect3> + +</sect2> + +<sect2 id="mcat-synth-tests"> +<title +>Testes</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 +>Isto simplesmente não faz nada. Só é útil para situações de teste. </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 +>Você poderá usar isto para depuração. Ele irá imprimir o valor do sinal em invalue em intervalos regulares (p.ex. a cada 1 segundo), combinado com o comentário que você indicou. Desta forma, você poderá descobrir se alguns dos sinais estão dentro de determinados intervalos ou se estão lá de alguma maneira. </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 +>Você poderá usar isto para depurar como é que os seus eventos &MIDI; estão chegando ao &arts;. </para> + +<para +>Quando um MIDI_DEBUG estiver rodando, o &artsserver; irá imprimir linhas do tipo: </para> + +<screen +><computeroutput +>201 100753.837585 on 0 42 127</computeroutput +></screen> + +<screen +><computeroutput +>202 101323.128355 off 0 42</computeroutput +></screen> + +<para +>A primeira linha lhe diz que 100753ms (isto é, 100 segundos) depois do MIDI_DEBUG começar, chegou um evento on de &MIDI; no canal 0. Este evento tinha a velocidade (volume) de 127, a mais elevada possível. A linha a seguir mostra o evento de liberação do MIDI. [ TODO: isto não funciona atualmente, quando funcionar, deverá ser feito através do gerenciador de &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 +>Isto cria um sinal com um número constante. </para> +<!-- TODO: this doesn't really belong in test, does it? --> +</sect3> +</sect2> + +<sect2 id="mcat-synth-osc-mod"> +<title +>Oscilação & Modulação</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 os osciladores no &arts; não precisam de uma frequência de entrada, mas sim de uma posição na onda. A posição deverá ser entre 0 e 1, o que se mapeia em um objeto normal do Synth_WAVE_SIN no intervalo 0..2*pi. Para gerar os valores oscilantes para uma frequência, é usado um 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 +>Isto é usado na modulação de frequência. Coloque a sua frequência na entrada frequency (frequência) e coloque outro sinal na entrada modulator. Depois disso, defina o modlevel (nível de modulação) para algo como 0,3. A frequência será então modulada com o modulator. Pode experimentar. Funciona bem mesmo quando você coloca uma realimentação nele, o que significa ter uma combinação do sinal de saída atrasado com o Synth_FM_SOURCE (você terá de colocá-lo com algum oscilador, uma vez que só tem o papel do Synth_FREQUENCY) e algum outro sinal para obter bons resultados. </para> + +<para +>Funciona otimamente em conjunto com os 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 senoidal. Coloque um sinal pos de um Synth_FREQUENCY ou de um Synth_FM_SOURCE na entrada. Deste modo, poderá obter uma onda senoidal na saída. O sinal pos indica a posição de fase na onda, e pertence ao intervalo 0..1, que se mapeia internamente em 0..2*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 de ondas triangulares. Coloque um sinal pos de um Synth_FREQUENCY ou de um Synth_FM_SOURCE na entrada. Deste modo, poderá obter uma onda senoidal na saída. O sinal pos indica a posição de fase na onda, e pertence ao intervalo 0..1, que se mapeia internamente em 0..2*PI. Tenha cuidado, porque o sinal de entrada <emphasis +>tem</emphasis +> de estar no intervalo 0..1 para que o sinal de saída produza bons 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 +>Um gerador de ruído. Isto gera um sinal aleatório entre -1 e 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 quadradas. Coloque um sinal pos de um Synth_FREQUENCY ou de um Synth_FM_SOURCE na entrada. Deste modo, poderá obter uma onda senoidal na saída. O sinal pos indica a posição de fase na onda, e pertence ao intervalo 0..1, que se mapeia internamente em 0..2*PI. Tenha cuidado, porque o sinal de entrada <emphasis +>tem</emphasis +> de estar no intervalo 0..1 para que o sinal de saída produza bons 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 dente-de-serra. Coloque um sinal pos de um Synth_FREQUENCY ou de um Synth_FM_SOURCE na entrada. Deste modo, poderá obter uma onda senoidal na saída. O sinal pos indica a posição de fase na onda, e pertence ao intervalo 0..1, que se mapeia internamente em 0..2*PI. Tenha cuidado, porque o sinal de entrada <emphasis +>tem</emphasis +> de estar no intervalo 0..1 para que o sinal de saída produza bons 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 impulsos - este módulo é semelhante na idéia ao oscilador de ondas quadradas (Synth_WAVE_RECT), mas oferece uma relação configurável de nível alto/baixo, através do parâmetro <emphasis +>dutycycle</emphasis +>. Coloque um sinal pos de um Synth_FREQUENCY ou de um Synth_FM_SOURCE na entrada. Deste modo, poderá obter uma onda senoidal na saída. O sinal pos indica a posição de fase na onda, e pertence ao intervalo 0..1, que se mapeia internamente em 0..2*PI. Tenha cuidado, porque o sinal de entrada <emphasis +>tem</emphasis +> de estar no intervalo 0..1 para que o sinal de saída produza bons resultados. </para> +</sect3> +</sect2> +<sect2 id="mcat-synth-misc"> +<title +>Diversos</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 reduz o intervalo dinâmico do sinal. Por exemplo, os compressores são úteis na compensação das variações amplas de volume se alguém estiver falando em um microfone. </para> + +<para +>Assim que o nível de entrada exceder um determinado nível (o patamar), o sinal é comprimido. Ele simplesmente multiplica tudo o que estiver acima do limite pelo valor de proporção, o qual é um número entre 0 e 1. Finalmente, o sinal completo é multiplicado pelo fator de saída. </para> + +<para +>Os argumentos attack e release atrasam o início e o fim da compressão. Use isto se você, por exemplo, quiser ainda ouvir o início forte de uma batida de bateria. O argumento está em milisegundos e um valor igual a 0ms é possível, se bem que poderá resultar apenas em um ligeiro ruído. </para> + +</sect3> +</sect2> +</sect1> + +<sect1 id="visual-modules-reference"> +<title +>Referência dos Módulos Visuais</title> + +<para +>TODO quando os módulos visuais estiverem mais "completos". </para> +</sect1> + +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/porting.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/porting.docbook new file mode 100644 index 00000000000..f245e6459e2 --- /dev/null +++ b/tde-i18n-pt_BR/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 Aplicativos para o &arts;</title> + +<sect1 id="using-artsdsp"> +<title +>Usando o &artsdsp;</title> + +<para +>O utilitário &artsdsp;, <link linkend="artsdsp" +>descrito anteriormente</link +>, possibilita que a maioria dos aplicativos antigos que se comunicavam diretamente com os dispositivos de áudio, funcionem corretamente com o &arts;. Aplicativos escritos para usar o Enlightenment Sound Daemon (<application +>esd</application +>) irão funcionar na maioria dos casos, rodando o <application +>esd</application +> com o &artsdsp;. </para> + +<para +>Isto faz com que seja encurtado o caminho para portar aplicativos existentes para o &kde;. No entanto, isto não possibilita que esses aplicativos tirem vantagem do potencial do &arts;, como utilizar módulos e e usar outros fluxos de multimídia que não sejam de áudio digital. Se o aplicativo necessita de recursos mais sofisticados do que simplesmente reproduzir arquivos de som, normalmente faz mais sentido adicionar suporte nativo para o &arts; ao aplicativo. </para> + +<para +>Usando o &arts; o seu aplicativo não precisa realizar muito trabalho -- ele pode se apoiar nas funções do &arts; para tratar de coisas como codecs para diferentes formatos de mídia e controle do hardware de som. </para> + +</sect1> + +<sect1 id="adding-native-arts-support"> +<title +>Adicionando Suporte Nativo ao &arts;</title> + +<para +>Ao usar o &arts;, você terá inúmeras <link linkend="arts-apis" +><acronym +>API</acronym +>s</link +> para escolher. A decisão de qual usar depende de uma série de fatores, incluindo o tipo de mídia a ser usado (som, &MIDI;, &CD; áudio, &etc;), os recursos requeridos da <acronym +>API</acronym +>, e quando é escrito em C++. Na maioria dos casos a escolha refere-se obviamente aos recursos requeridos. </para> + +<para +>Para portabilidade entre plataformas, aplicativos que necessitam rodar em ambientes que não sejam o &kde; não confie no &arts; pelo menos até o momento. Usar paradigma de plug-ins é uma boa escolha para suportar diferentes ambientes de multimídia. Fazendo uma <acronym +>API</acronym +> de plug-ins aberta e documentada (especiamente para aplicativos de código fechado) oferece a vantagem de que outras pessoas além dos desenvolvedores do aplicativo podem implementar um plug-in para o &arts;. </para> + +</sect1> + +</chapter> + diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/references.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/references.docbook new file mode 100644 index 00000000000..77c5b2c95b5 --- /dev/null +++ b/tde-i18n-pt_BR/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 +>Referências</title> + +<variablelist> + +<varlistentry> +<term +><ulink +url="http://multimedia.kde.org" +>http://multimedia.kde.org</ulink +></term> +<listitem> +<para +>Este é o site web principal para informações sobre multimídia relacionadas com o &kde;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><ulink +url="http://www.arts-project.org" +>http://www.arts-project.org</ulink +></term> +<listitem> +<para +>Esta é a página do projeto &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +>Desenvolvimento do &kde; 2.0</term> +<listitem> +<para +>O capítulo 14 deste livro aborda multimídia, incluindo o &arts;. Ele está disponível impresso ou on-line com anotações em <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 +>Este site possui uma lista bem abrangente de aplicativos de som e &MIDI; para &Linux;. </para> +</listitem> +</varlistentry> + +</variablelist> + +</chapter> diff --git a/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/tools.docbook b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/tools.docbook new file mode 100644 index 00000000000..edfb1c6f3d4 --- /dev/null +++ b/tde-i18n-pt_BR/docs/tdemultimedia/artsbuilder/tools.docbook @@ -0,0 +1,1007 @@ +<!-- +<?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 +>Ferramentas do &arts;</title> + +<para +>Incluído com o &arts;, vem um conjunto de utilitários para controlar e configurar o seu comportamento. Você precisa de ter alguma familiaridade com a maioria dessas ferramentas para usar efetivamente o &arts;. Esta seção descreve cada um dos utilitários e as suas opções de comando. </para> + +<sect1 id="kde-control-center"> +<title +>&kcontrol;</title> + +<para +>Ao rodar o &arts; no &kde;, o &kcontrolcenter; oferece um grupo de opções do painel de controle na categoria <guilabel +>Som</guilabel +>. Algumas dessas opções são usadas pelo &arts;. Você também poderá associar sons com vários eventos do gerenciador de janelas e do &kde; com o painel <menuchoice +><guilabel +>Aparência & Comportamento</guilabel +><guilabel +>Notificações do Sistema</guilabel +></menuchoice +>. Veja o manual do &kcontrol; para saber como usar as opções do painel. </para> + +</sect1> + +<sect1 id="artsd"> +<title +>&artsd;</title> + +<para +>O acesso aos recursos de hardware de som é controlado pelo &artsd;, o servidor do &arts;. Isto permite aos diferentes aplicativos enviarem pedidos simultâneos ao servidor, onde poderão ser misturados e tocados. Sem um servidor de som centralizado, um único aplicativo que usasse um dispositivo de som iria impedir que os outros aplicativos o usassem também. </para> + +<para +>Para usar o &arts;, deverá existir uma e apenas uma cópia do &artsd; sendo executada. É tipicamente executada quando o &kde; se inicia, se estiver ativo no painel <guilabel +>Servidor de Som</guilabel +> do &kcontrol;. </para> + +<para +>O programa aceita os seguintes 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 +>taxa amostragem</replaceable +></option +> <option +>-b <replaceable +>bits</replaceable +></option +> <option +>-d</option +> <option +>-D <replaceable +>nome dispositivo</replaceable +></option +> <option +>-F <replaceable +>fragmentos</replaceable +></option +> <option +>-S <replaceable +>tamanho</replaceable +></option +> <option +>-s <replaceable +>segundos</replaceable +></option +> <option +>-m <replaceable +>nome da aplicação</replaceable +></option +> </group +> <group choice="opt" +> <option +>-h</option +> <option +>-A</option +> <option +>-v</option +> <option +>-l <replaceable +>nível</replaceable +></option +> </group +> </cmdsynopsis> + +<variablelist +><varlistentry> +<term +><option +>-r <replaceable +>taxa de amostragem</replaceable +></option +></term> +<listitem> +<para +>Indica a taxa de amostragem a usar.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Mostra o modo de usar os comandos.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-n</option +></term> +<listitem> +<para +>Ativa a transparência na rede.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-p <replaceable +>porta</replaceable +></option> +</term> +<listitem> +<para +>Define a porta <acronym +>TCP</acronym +> a usar (implica o <option +>-n</option +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-u</option +></term> +<listitem> +<para +>Público e sem autenticação (perigoso).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-d</option +></term> +<listitem> +<para +>Ativa a operação em full duplex.</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-D <replaceable +>nome do dispositivo</replaceable +></option +></term> +<listitem> +<para +>Indica o dispositivo de áudio a usar (normalmente é o <filename +>/dev/dsp</filename +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-F <replaceable +>fragmentos</replaceable +></option +></term> +<listitem> +<para +>Define o número de fragmentos.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-S <replaceable +>tamanho</replaceable +></option +></term> +<listitem> +<para +>Define o tamanho de cada fragmento em bytes.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-s <replaceable +>segundos</replaceable +></option +></term> +<listitem> +<para +>Define o tempo de suspensão automática do servidor, em segundos. Um valor igual a zero desativa a suspensão automática.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m <replaceable +>nome do aplicativo</replaceable +></option +></term> +<listitem> +<para +>Indica o nome de um aplicativo para usar para mostrar as mensagem de erro, de aviso e informativas. Se você estiver rodando o KDE, poderá usar o utilitário <application +>artsmessage</application +> para isto.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-N</option +></term> +<listitem> +<para +>Aumenta o tamanho dos buffers de rede para um valor adequado para rodar em uma LAN de 10 Mbps. Isto é equivalente a usar a opção '-w 5' (ver abaixo). </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-w <replaceable +>n</replaceable +></option +></term> +<listitem> +<para +>Ao rodar o <application +>artsd</application +> sobre uma conexão de rede com outra máquina, você poderá querer usar um tamanho maior dos buffers para evitar cortes. O aRts fornece aos aplicativos um tamanho mínimo sugerido. Sem esta opção, o tamanho padrão baseia-se no valor 'tamanho do fragmento' * 'número de fragmentos'. Se usar esta opção você poderá aumentar o tamanho pré-definido por um fator de <replaceable +>n</replaceable +>. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-l <replaceable +>nível</replaceable +></option +></term> +<listitem> +<para +>Indica o nível de informações - 3 (silencioso), 2 (avisos), 1 (informação), 0 (depuração).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +></term> +<listitem> +<para +>Mostra o número da versão.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Na maioria dos casos, bastará executar o &artsd;. </para> +</sect1> + +<sect1 id="artswrapper"> +<title +>&artswrapper;</title> + +<para +>Para oferecer uma boa resposta em tempo-real, o &artsd; é normalmente executado como um processo em tempo-real (nas plataformas que suportem prioridades de tempo-real). Isto necessita de permissões do <systemitem class="username" +>root</systemitem +>, por isso, para minimizar as implicações de segurança, o &artsd; poderá ser iniciado com o pequeno programa de interface &artswrapper;, o qual simplesmente configura a prioridade de tempo-real (executando como <systemitem class="username" +>root</systemitem +>) e executa depois o &artsd; como um usuário que não o <systemitem class="username" +>root</systemitem +>. </para> + +<para +>Se você tornar o artswrapper SUID <systemitem class="username" +>root</systemitem +>, ele irá provavelmente melhorar a qualidade da sua reprodução de áudio, reduzindo os cortes na música. Contudo, aumenta também o risco de que um erro no código ou algum usuário malicioso faça estourar ou prejudicar o seu sistema. Além disso, nas máquinas multi-usuário, priorizar o áudio de alta-fidelidade poderá provocar uma perda de desempenho para os usuário que estão tentando fazer um uso <quote +>produtivo</quote +> da máquina.</para> + +</sect1> + +<sect1 id="artsshell"> +<title +>&artsshell;</title> + +<para +>O comando &artsshell; pretende ser um utilitário para efetuar diversas funções relacionadas com o servidor de som. Pretende-se que o utilitário seja extendido com comandos novos no futuro (veja os comentários no código-fonte para ter algumas idéias). </para> + +<para +>O comando aceita o seguinte 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 +>volume</replaceable +>]</arg +> <arg +>stereoeffect <replaceable +>opções</replaceable +></arg +> </group +> <group +> <option +>-h</option +> <option +>-q</option +> </group +> </cmdsynopsis> + +<para +>artsshell [options] <replaceable +>comando</replaceable +> [<replaceable +>opções do comando</replaceable +>] </para> + +<para +>São suportadas as seguintes opções: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-q</option +></term> +<listitem> +<para +>Suprime todos os resultados.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Mostra o modo de usar os comandos.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>São suportados os seguintes comandos:</para> + +<variablelist> + +<varlistentry> +<term +><option +>suspend</option +></term> +<listitem> +<para +>Suspende o servidor de som. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>status</option +></term> +<listitem> +<para +>Mostra a informação de estado do servidor de som.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>terminate</option +></term> +<listitem> +<para +>Termina o servidor de som. Isto poderá confundir e/ou estourar os aplicativos que estejam usando-o no momento. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>autosuspend</option +> <parameter +>segundos</parameter +></term> +<listitem> +<para +>Configura o tempo de suspensão automática para o número de segundos indicado. O servidor de som suspender-se-á se estiver inativo durante esse período de tempo. Um valor igual a zero desativa a suspensão automática. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>networkbuffers</option +> <parameter +>n</parameter +></term> +<listitem> +<para +>Define o tamanho dos buffers de rede para ser um fator de <parameter +>n</parameter +> vezes o tamanho pré-definido. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>volume</option +> [<replaceable +>volume</replaceable +>]</term> +<listitem> +<para +>Altera o fator de escala para as saídas de áudio do servidor de som. O argumento <replaceable +>volume</replaceable +> é um valor de ponto flutuante. Sem argumentos, é mostrado o volume atual. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect lista</option +></term> +<listitem> +<para +>Mostra todos os módulos de efeitos estéreo disponíveis.</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect insert [top|bottom]</option +> <replaceable +>nome</replaceable +></term> +<listitem> +<para +>Introduz um efeito estéreo na pilha de efeitos. Devolve um identificador que poderá ser usado para removê-lo posteriormente. Poderá ser instalado no topo ou no fundo (o padrão).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>stereoeffect remove</option +> <replaceable +>identificador</replaceable +></term> +<listitem> +<para +>Remove o efeito estéreo com o identificador <replaceable +>identificador</replaceable +> da pilha de efeitos.</para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsplay"> +<title +><application +>artsplay</application +></title> + +<para +>O comando <application +>artsplay</application +> é um utilitário simples para tocar um arquivo de som. Ele aceita um único argumento que corresponde ao nome de um arquivo de som que é enviado para o servidor de som de modo a ser tocado. O arquivo de som poderá ser qualquer tipo de arquivo de som comum como o <literal role="extension" +>wav</literal +> ou o <literal role="extension" +>au</literal +>. Este utilitário é bom para testar se o servidor de som está funcionando. Se executar dois comandos em paralelo ou em sucessão rápida, você poderá demonstrar como os servidores de som misturam mais de uma fonte.</para> + +</sect1> + +<sect1 id="artsdsp"> +<title +><application +>artsdsp</application +></title> + +<para +>O servidor de som só suporta os aplicativos que tirem partido do &arts;. Muitas dos aplicativos legadas querem acessar o dispositivo de som diretamente. O comando &artsdsp; oferece uma solução intermediária que permite à maioria desses aplicativos rodarem sem alterações. </para> + +<para +>Quando um aplicativo é executado com o &artsdsp;, todos os acessos ao dispositivo de áudio <filename class="devicefile" +>/dev/dsp</filename +> são interceptados e mapeados em chamadas à <acronym +>API</acronym +> do &arts;. Embora a emulação do dispositivo não seja perfeita, a maioria dos aplicativos funciona desta forma, ainda que com alguma latência e degradação de performance. </para> + +<para +>O comando &artsdsp; segue o formato: </para> + +<!-- LW: FIX THIS --> +<para +>artsdsp [<replaceable +>opções</replaceable +>] <replaceable +>argumentos da aplicação</replaceable +> </para> + +<para +>São reconhecidas as seguintes opções: </para> + +<variablelist> + +<varlistentry> +<term +><option +>-h</option +>, <option +>--help</option +></term> +<listitem> +<para +>Mostra uma breve ajuda.</para> +</listitem> +</varlistentry> +<varlistentry> +<term +><option +>-n</option +> <option +>--name</option +> = <replaceable +>nome</replaceable +></term> +<listitem> +<para +>Usa o <replaceable +>nome</replaceable +> para identificar o tocador no <command +>artsd</command +>.</para> + +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-m</option +> <option +>--mmap</option +></term> +<listitem> +<para +>Emula o mapeamento de memória (⪚ para o <application +>Quake</application +>).</para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-v</option +> <option +>--verbose</option +></term> +<listitem> +<para +>Mostra os parâmetros.</para> +</listitem> +</varlistentry> + +</variablelist> + +<para +>Uma invocação típica é a seguinte: </para> + +<para> +<userinput +><command +>artsdsp</command +> <option +>-v</option +> <option +>-m</option +> <parameter +>realplay <replaceable +>musica.mp3</replaceable +></parameter +></userinput> +</para> + +<para +>Alguns aplicativos funcionam melhor com a opção <option +>--mmap</option +>. Nem todas as funcionalidades do dispositivo de som estão emuladas por completo, mas a maioria dos aplicativos deverão funcionar. Se encontrar algum que não funcione, envie um relatório de erro detalhado para que os programadores possam corrigir. Mais uma vez, lembre-se que isto é uma solução intermediária e uma espécie de 'truque sujo'; a melhor solução será adicionar o suporte nativo do &arts; aos aplicativos. Se o seu aplicativo de som favorito não tem o suporte ao &arts;, peça ao programador para fornecê-lo. </para> + +</sect1> + +<sect1 id="artscat"> +<title +><application +>artscat</application +></title> + +<para +>Este é um utilitário simples para enviar os dados brutos para o servidor de som. Você precisa indicar o formato dos dados (a taxa de amostragem, o tamanho da amostra e o número de canais). Este não é provavelmente um utilitário que você use muito, mas poderá ser útil para fins de teste. A sintaxe do comando é a seguinte: </para> + +<!-- LW: FIX THIS --> + +<para +>artscat [ <replaceable +>opções</replaceable +> ] [ <replaceable +>nome do arquivo</replaceable +> ] </para> + +<para +>Se não for indicado nenhum arquivo, irá ler do 'standard input'. São suportadas as seguintes opções: </para> + +<variablelist> +<varlistentry> +<term +><option +>-r</option +> <parameter +>taxa de amostragem</parameter +></term> +<listitem> +<para +>Configura a taxa de amostragem a ser usada. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-b</option +> <parameter +>bits</parameter +></term> +<listitem> +<para +>Define o tamanho da amostra a usar (8 ou 16). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-c</option +> <parameter +>canais</parameter +></term> +<listitem> +<para +>Define o número de canais (1 ou 2). </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-h</option +></term> +<listitem> +<para +>Mostra a utilização do comando e sai. </para> +</listitem> +</varlistentry> + +</variablelist> +</sect1> + +<sect1 id="artscontrol"> +<title +>&artscontrol;</title> + +<para +>Este é um utilitário gráfico para efetuar um determinado número de tarefas relacionadas com o servidor de som. A janela padrão mostra dois indicadores de nível do volume e uma barra para controlar o volume global. No menu <guimenu +>Ver</guimenu +>, você poderá selecionar outras funções: </para> + +<variablelist> + +<varlistentry> +<term +><guimenuitem +>Osciloscópio FFT</guimenuitem +></term> +<listitem> +<para +>Abre uma janela que mostra uma visualização do tipo de analisador de espectro em tempo-real. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Gerenciador de Áudio</guimenuitem +></term> +<listitem> +<para +>Mostra as fontes de áudio ativas e permite-lhe conectá-las a qualquer um dos barramentos disponíveis. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Estado do aRts</guimenuitem +></term> +<listitem> +<para +>Mostra se o servidor de som está rodando e se o escalonamento é feito em tempo-real. Indica quando o servidor se suspende automaticamente e permite-lhe suspendê-lo imediatamente. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Gerenciador de MIDI</guimenuitem +></term> +<listitem> +<para +>Mostra as entradas e saídas ativas de &MIDI; e permite-lhe criar conexões [TODO: Isto ainda funciona? São precisos mais detalhes]. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>FreeVerb</guimenuitem +></term> +<listitem> +<para +>Conecta um efeito de reverberação FreeVerb à pilha dos efeitos de saída do &arts; e permite-lhe controlar graficamente os parâmetros do efeito. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><guimenuitem +>Mostrador de volume com Leds</guimenuitem +></term> +<listitem> +<para +>Muda os indicadores de volume da janela principal para usar um mostrador colorido com <acronym +>LED</acronym +>s em vez de usar barras de progresso. </para> +</listitem> +</varlistentry> + +</variablelist> + +</sect1> + +<sect1 id="artsc-config"> +<title +><application +>artsc-config</application +></title> + +<para +>Este é um utilitário para ajudar os programadores a usar a <acronym +>API</acronym +> de C do &arts;. Ele mostra as opções apropriadas do compilador e do editor de ligações que são necessárias ao compilar e ao gerar um executável com o &arts;. Pretende-se que seja usado nos 'Makefile's para ajudar na portabilidade. O comando aceita três opções: </para> + +<variablelist> +<varlistentry> +<term +><option +>--cflags</option +></term> +<listitem> +<para +>Mostra as opções do compilador que são necessárias ao compilar com a <acronym +>API</acronym +> de C do &arts;. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>--libs</option +></term> +<listitem> +<para +>Mostra as opções do editor de ligações que são necessárias ao gerar o executável que usa as bibliotecas da <acronym +>API</acronym +> de C do &arts;. </para> +</listitem> +</varlistentry> +<varlistentry> +<term +><acronym +>--version</acronym +></term> +<listitem> +<para +>Mostra a versão do comando <command +>artsc-config</command +>. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>O resultado típico do comando é mostrado em baixo:</para> + +<screen width="40" +><prompt +>%</prompt +> <userinput +><command +>artsc-config</command +> <option +>--cflags</option +></userinput> +<computeroutput +>-I/usr/local/kde3/include/artsc</computeroutput> +<prompt +>%</prompt +> <userinput +><command +>artsc-config</command +> <option +>--libs</option +></userinput> +<computeroutput +>-L/usr/local/kde3/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 +>Você poderá usar este utilitário em um Makefile para uma regra do tipo: </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 +>O comando &mcopidl; é o compilador de arquivos &IDL; para o &MCOP;, o 'Multimedia Communication Protocol' usado pelo &arts;. As interfaces no &arts; são definidas em &IDL;, uma 'Interface Definition Language' independente da linguagem. O utilitário &mcopidl; aceita um arquivo &IDL; como entrada e gera arquivos de inclusão e de código em C++ que implementam essa interface. O comando aceita a seguinte sintaxe: </para> + +<!-- LW: FIX THIS --> + +<para +>mcopidl [ <replaceable +>opções</replaceable +> ] <replaceable +>nome do arquivo</replaceable +> </para> + +<para +>As opções válidas são:</para> +<variablelist> +<varlistentry> +<term +><option +>-I</option +> <parameter +>diretório</parameter +></term> +<listitem> +<para +>Procura no <parameter +>diretório</parameter +> pelos arquivos de inclusão. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-e</option +> <parameter +>nome</parameter +></term> +<listitem> +<para +>Exclui a estrutura, interface ou tipo enumerado <parameter +>nome</parameter +> da geração de código. </para> +</listitem> +</varlistentry> + +<varlistentry> +<term +><option +>-t</option +></term> +<listitem> +<para +>Cria também os arquivos <literal role="extension" +>.mcoptype</literal +>/<literal role="extension" +>.mcopclass</literal +> que contêm a informação de tipo para o arquivo &IDL;. </para> +</listitem> +</varlistentry> +</variablelist> + +<para +>Para mais informações sobre o &MCOP; e o &IDL;, você poderá ver a seção <link linkend="interfaces" +>Interfaces e &IDL;</link +>. </para> + +</sect1> + +</chapter> |