# Interfaces de Programação de Aplicativos do &arts;

## Visão Geral

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.

Existe uma importante distinção a fazer: a maioria das APIs são independentes de localização e linguagem porque elas são especificadas como mcopidl. 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:

core.idl

  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.

artsflow.idl

  Ela contém o sistema de fluxo que você usará para conectar-se com fluxos de áudio, a definição do Arts::SynthModule que é a base para qualquer interface que possui fluxos, e finalmente alguns objetos de áudio úteis.

kmedia2.idl

  Aqui, um objeto que pode tocar uma mídia (Arts::PlayObject) é 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.

soundserver.idl

  Aqui, uma interface para o amplo sistema do servidor de som artsd é definida. A interface é chamada Arts::SoundServer, 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).

artsbuilder.idl

  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 Arts::StructureDesc, Arts::ModuleDesc e Arts::PortDesc 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.

artsmidi.idl

  Este módulo define a funcionalidade midi básica, como objetos que produzem eventos midi, o que é um evento midi, um Arts::MidiManager para conectar os produtores e consumidores de eventos midi, e assim por diante. Como sempre a transparência de rede está implícita.

artsmodules.idl

  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.

artsgui.idl

  Isto cuida dos objetos visuais. Ele define o tipo básico Arts::Widget 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.

Onde possível, o próprio aRts é implementado usando IDL. Por outro lado, existem algumas APIs específicas de linguagem, 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:

KNotify, KAudioPlayer (incluída no libkdecore)

  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.

libartsc

  Interface em C plano para o servidor de som. Muito útil para portar aplicativos legados.

libmcop

  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.

libartsflow

  Somando à implementação do artsflow.idl, alguns utilitários úteis como conversão de taxa de amostragem.

libqiomanager

  Integração do MCOP no ciclo de eventos Qt, quando você escreve aplicativos Qt usando MCOP.

## knotify

Não escrito ainda

## kaudioplayer

Não escrito ainda

## libkmid

Não escrito ainda

## kmedia2

Não escrito ainda

## servidor de som

Não escrito ainda

## artsflow

Não escrito ainda

## API C

### Introdução

A API 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 artsd), 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;.

Eu fiz dois portes como prova do conceito: mpg123 e quake. Você pode obter os remendos a partir daqui. 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.

### Explanação Rápida

Enviar áudio para o servidor de som com a API é muito simples:

- inclua o arquivo de cabeçalho usando `#include <artsc.h>`

- inicialize a API com `arts_init()`

- crie um fluxo com `arts_play_stream()`

- configure parâmetros específicos com `arts_stream_set()`

- escreva dados de amostra para o fluxo com `arts_write()`

- feche o fluxo com `arts_close_stream()`

- libere a API com `arts_free()`

Aqui está um pequeno exemplo que ilustra isto:

    #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;
    }

### Compilando e Ligando: artsc-config

Para compilar e ligar facilmente programas usando a API C do &arts;, o utilitário artsc-config é fornecido o qual conhece quais bibliotecas você precisar ligar e onde os arquivos de inclusão estão. Ele é chamado usando

    artsc-config --libs

para encontrar as bibliotecas e

    artsc-config --cflags

para encontrar sinalizadores de compilação adicionais para o C. O exemplo acima pode ser compilado usando a linha de comando:

    cc -o artsctest artsctest.c `artsc-config --cflags` `artsc-config --libs`

    cc -o artsctest artsctest.c `artsc-config --cflags` `artsc-config --libs`

### Referência de Biblioteca

[A SER FEITO: gerar a documentação para o artsc.h usando o kdoc]