Blog C/C++ Dicas Sem categoria
Instalação CEF no Linux

CEF é o anacrônico de Chromium Embedded Framework, é uma interface para o Chromium em outras aplicações.

Estaremos tratando aqui, como realizar a instalação deste frame work.

Existem dois caminhos para realizar tal feito, o primeiro e mais complicado é através do procedimento de compilação total, o segundo é através da baixa dos binários já montados.

Compilação total

O Passo a passo que se segue foi tirado em pesquisa da web e consta entre outros links:

https://bitbucket.org/chromiumembedded/cef/wiki/MasterBuildQuickStart#markdown-header-mac-os-x-setup

Baixe os repositórios dos projetos no seguinte repositório GIT:

https://bitbucket.org/%7Bdc443723-7652-4c63-b340-033e522146db%7D/

Para tanto, existem 3 repositórios:

  • CEF
  • CEF-PROJECT
  • Java-cef

Conforme imagem abaixo:

Repositórios do Projeto CEF

Como o projeto Java, não esta em nosso alvo, ignoraremos este ultimo.

Baixando do CEF

Primeiramente precisamos baixar o projeto

git clone https://bitbucket.org/chromiumembedded/cef.git

Digite o comando acima no seu console.

Instalação do projeto CEF

No site do desenvolvedor este recomenda uma super máquina, com 16 núcleos de processador, e conexão de internet de 100mbits.

Este procedimento deve ser realizado em um Ubuntu 18.04, pois tive problemas em ambientes diferentes.

Realmente o processo é um pouco demorado, e recomendo fortemente que pelo menos a conexão seja de boa qualidade, para que não sofram com o processo.

Siga os passos abaixo para realizar a instalação do CEF:

Passo 1

Entre na pasta cef, e crie os diretórios:

mkdir ./code

mkdir ./code/automate

mkdir ./code/chromium_git

criação das pastas

Passo 2

Baixe e execute o arquivo install0buuild-deps.sh

Este arquivo irá instalar todas as dependências do cef.

cd ./code

sudo apt install curl

curl ‘https://chromium.googlesource.com/chromium/src/+/master/build/install-build-deps.sh?format=TEXT’ | base64 -d > install-build-deps.sh

chmod 755 install-build-deps.sh

sudo ./install-build-deps.sh –no-arm –no-chromeos-fontes –no-nacl

Dependências para instalação do CEF




Passo 3

Baixe os repositórios de ferramentas

cd ./code

git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git

Passo 4

Agora voce precisa incluir o caminho absoluto da sua pasta.

Para isso primeiro vá a pasta do cef, indo e digite o comando

export PATH=`dirs | cut -d' ' -f2`/code/depot_tools:$PATH

Pega o caminho da pasta atual e inclui no repositório

Passo 5

Agora é necessário baixar o automate.

cd ~/code/automate
wget https://bitbucket.org/chromiumembedded/cef/raw/master/tools/automate/automate-git.py

Passo 6

Agora vamos baixar o chromium_git, para isso vamos seguir o seguinte passo.

Crie o arquivo update.sh, na pasta ./code/chromium_git

cd ..

cd ./chromium_git

vim update.sh

Edite o seguinte fragmento:

#!/bin/bash
CAMINHO=`dirs | cut -d' ' -f2`
echo $CAMINHO
python ../automate/automate-git.py --download-dir=$CAMINHO/../chromium_git --depot-tools-dir=$CAMINHO/../depot_tools --no-distrib --no-build

Agora dê permissão ao script:

chmod +755 update.sh

Agora rode o script e aguarde.

./update.sh

Passo 7

Neste passo, iremos gerar os defines para configurar o ambiente.

O Chromium usa o usuário root para build da aplicação, porem temos a opção de usuários não root.

GN_DEFINE ROOT

export GN_DEFINES="use_sysroot=true use_allocator=none symbol_level=1 is_cfi=false use_thin_lto=false"

GN_DEFINE NOROOT

export GN_DEFINES="use_sysroot=false use_allocator=none symbol_level=1 is_cfi=false use_thin_lto=false use_vaapi=false"

Passo 8

Rode o script, em ./code/chromium_git/chromium/src/cef/

cd ./code/chromium_git/chromium/src/cef/
./cef_create_projects.sh

Passo 9

Gera o binario com Debug usando Ninja

cd ~/code/chromium_git/chromium/src
ninja -C out/Debug_GN_x64 cefclient cefsimple ceftests chrome_sandbox

Caso queira versão final, substitua a palavra Debug por Release.

Passo 10

Configure o Linux SUID Caixa de areia, se voce esta usando um kernel antigo, versão inferior a 3.8.

# This environment variable should be set at all times.
export CHROME_DEVEL_SANDBOX=/usr/local/sbin/chrome-devel-sandbox

# This command only needs to be run a single time.
cd ~/code/chromium_git/chromium/src
sudo BUILDTYPE=Debug_GN_x64 ./build/update-linux-sandbox.sh

Passo 11

Rode o cefclient, cefsimple e ou ceftests. Note que o cefclient somente compilará se voce estiver usando um parametro nao root, no passo 7.

cd ~/code/chromium_git/chromium/src
./out/Debug_GN_x64/cefclient

Instalação através de Baixa de Binários

Neste processo não há de fato a compilação, apenas a etapa de linkagem dos binários.

Este é o processo que recomendo, pois além de ser mais rápido é mais fácil e dá menos problema na hora da instalação.

Passo 1 – Baixa dos Binários

O primeiro passo é baixar os binários através do site abaixo:

https://cef-builds.spotifycdn.com/index.html

Nele existem diversas distribuições que podem ser vistas, é importante observar qual será o alvo da sua instalação. Para não baixar a distribuição errada, e eventualmente ter problemas com isso.

Lembrando que não é possível compilar um linux 32 com uma distribuição 64, pois a lib terá problemas na linkagem do mesmo. Então sempre escolha a versão que coincide com seu sistema operacional.

Caso não saiba qual é sua distribuição, recomendo, que use o comando,

uname -a

Conforme figura abaixo, podemos ver que meu linux é 64 bits, desta forma recomenda-se o uso da lib 64 bits.

Mostrando que é 64 bits

Desta forma seguiremos, com o padrão, conforme passado:

Agora baixe o binário, e instale na sua maquina linux descompactado.

Renomeie o arquivo para apenas cef, conforme figura abaixo.

Pasta montada no linux

Apenas para elucidar, estou usando o samba, que permite eu acessar as pastas do linux na minha maquina windows. Isso facilita a edição dos fontes.

Passo 2 – Preparação e Dependências.

Entre no linux pela console, entrando na pasta do cef. Digite o seguinte comando:

cmake .

Preparação para o make, onde irá peparar o makefile

Se não houver problemas de dependências, ele irá estar pronto para linkagem.

Caso dê problema, consulte a documentação, no link abaixo:

https://bitbucket.org/chromiumembedded/cef/wiki/MasterBuildQuickStart#markdown-header-ma

Passo 3 – Linkagem dos binários

Nesta etapa iremos montar a lib, pegando os binários pré compilados e juntando na .so

Para concluir esta etapa, basta digitar na console

make

Monta a lib

Ao fim, será mostrado, o resultado, como segue:

build concluído

A lib estará disponivel, no caminho .\cef\Release, conforme figura abaixo:

local de destino da lib

Includes de distribuição,

Ficam em .\cef\include conforme figura abaixo:

C/C++ cmusphinx IA
Montagem de código em C com Ninja

Definição

Ninja é um pequeno conjunto de ferramentas, desenvolvido por Evan Martin, um empregado da Google. Ninja foi usado em diversas construções de aplicações.

Entre suas vantagens estão a facilidade de montagem de aplicação, a velocidade e rapidez.

Outra vantagem é a capacidade de construir aplicações em multiplos SOs. (Windows, Linux, MacOS).

Referência:

https://en.wikipedia.org/wiki/Ninja_(build_system)

NINJA

Construção

Iremos apresentar um pequeno projeto construído com NINJA.

O srvOuve é um projeto que visa integrar o CMU sphinx, estaremos construindo uma build com ninja.

Primeiramente precisamos criar o arquivo CMakeLists.txt , que fará a magica acontecer.

Criamos o arquivo conforme aparece no fragmento abaixo:

cmake_minimum_required (VERSION 3.8)

#Define o projeto
project(srvOuve VERSION 1.0)

#Diretorios de Include
include_directories(	   "/usr/local/include/pocketsphinx"
						   "/usr/local/include/sphinxbase"
                          )

set(CMAKE_CXX_STANDARD 14)

add_executable(srvOuve ouve.cpp)

Agora precisaremos dizer ao sistema para gerar os arquivos do ninja, para tanto chamamos o cmake, conforme a sintaxe abaixo:

$ cmake -G Ninja

Execução na console

Com este passo o cmake criará dois arquivos:

build.ninja – Este arquivo contem as configurações de compilação (build)

O build.ninja conterá as regras de construção da aplicação.

# CMAKE generated file: DO NOT EDIT!
# Generated by "Ninja" Generator, CMake Version 3.10

# This file contains all the build statements describing the
# compilation DAG.

# =============================================================================
# Write statements declared in CMakeLists.txt:
#
# Which is the root file.
# =============================================================================

# =============================================================================
# Project: srvOuve
# Configuration:
# =============================================================================

#############################################
# Minimal version of Ninja required by this file

ninja_required_version = 1.5

# =============================================================================
# Include auxiliary files.


#############################################
# Include rules file.

include rules.ninja


#############################################
# Utility command for rebuild_cache

build CMakeFiles/rebuild_cache.util: CUSTOM_COMMAND
  COMMAND = cd /home/maurinsoft/projetos/srvOuve/srv && /usr/bin/cmake -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  DESC = Running CMake to regenerate build system...
  pool = console
  restat = 1
build rebuild_cache: phony CMakeFiles/rebuild_cache.util
# =============================================================================
# Object build statements for EXECUTABLE target srvOuve


#############################################
# Order-only phony target for srvOuve

build cmake_object_order_depends_target_srvOuve: phony
build CMakeFiles/srvOuve.dir/ouve.cpp.o: CXX_COMPILER__srvOuve ouve.cpp || cmake_object_order_depends_target_srvOuve
  DEP_FILE = CMakeFiles/srvOuve.dir/ouve.cpp.o.d
  FLAGS = -std=gnu++14
  INCLUDES = -I/usr/local/include/pocketsphinx -I/usr/local/include/sphinxbase
  OBJECT_DIR = CMakeFiles/srvOuve.dir
  OBJECT_FILE_DIR = CMakeFiles/srvOuve.dir

# =============================================================================
# Link build statements for EXECUTABLE target srvOuve


#############################################
# Link the executable srvOuve

build srvOuve: CXX_EXECUTABLE_LINKER__srvOuve CMakeFiles/srvOuve.dir/ouve.cpp.o
  OBJECT_DIR = CMakeFiles/srvOuve.dir
  POST_BUILD = :
  PRE_LINK = :
  TARGET_FILE = srvOuve
  TARGET_PDB = srvOuve.dbg

#############################################
# Utility command for edit_cache

build CMakeFiles/edit_cache.util: CUSTOM_COMMAND
  COMMAND = cd /home/maurinsoft/projetos/srvOuve/srv && /usr/bin/cmake-gui -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  DESC = Running CMake cache editor...
  pool = console
  restat = 1
build edit_cache: phony CMakeFiles/edit_cache.util
# =============================================================================
# Target aliases.

# =============================================================================
# Folder targets.

# =============================================================================
# =============================================================================
# Built-in targets


#############################################
# The main all target.

build all: phony srvOuve

#############################################
# Make the all target the default.

default all

#############################################
# Re-run CMake if any of its inputs changed.

build build.ninja: RERUN_CMAKE | /usr/share/cmake-3.10/Modules/CMakeCInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCXXInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake-3.10/Modules/CMakeGenericSystem.cmake /usr/share/cmake-3.10/Modules/CMakeLanguageInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake-3.10/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-C.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-C.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux.cmake /usr/share/cmake-3.10/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.10.2/CMakeCCompiler.cmake CMakeFiles/3.10.2/CMakeCXXCompiler.cmake CMakeFiles/3.10.2/CMakeSystem.cmake CMakeLists.txt
  pool = console

#############################################
# A missing CMake input file is not an error.

build /usr/share/cmake-3.10/Modules/CMakeCInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCXXInformation.cmake /usr/share/cmake-3.10/Modules/CMakeCommonLanguageInclude.cmake /usr/share/cmake-3.10/Modules/CMakeGenericSystem.cmake /usr/share/cmake-3.10/Modules/CMakeLanguageInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInformation.cmake /usr/share/cmake-3.10/Modules/CMakeSystemSpecificInitialize.cmake /usr/share/cmake-3.10/Modules/Compiler/CMakeCommonCompilerMacros.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-C.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Compiler/GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-C.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU-CXX.cmake /usr/share/cmake-3.10/Modules/Platform/Linux-GNU.cmake /usr/share/cmake-3.10/Modules/Platform/Linux.cmake /usr/share/cmake-3.10/Modules/Platform/UnixPaths.cmake CMakeCache.txt CMakeFiles/3.10.2/CMakeCCompiler.cmake CMakeFiles/3.10.2/CMakeCXXCompiler.cmake CMakeFiles/3.10.2/CMakeSystem.cmake CMakeLists.txt: phony

#############################################
# Clean all the built files.

build clean: CLEAN

#############################################
# Print all primary targets available.

build help: HELP




O cmake tambem cria o arquivo rules.ninja, responsável pelas regras de compilação.

# CMAKE generated file: DO NOT EDIT!
# Generated by "Ninja" Generator, CMake Version 3.10

# This file contains all the rules used to get the outputs files
# built from the input files.
# It is included in the main 'build.ninja'.

# =============================================================================
# Project: srvOuve
# Configuration:
# =============================================================================
# =============================================================================

#############################################
# Rule for running custom commands.

rule CUSTOM_COMMAND
  command = $COMMAND
  description = $DESC


#############################################
# Rule for compiling CXX files.

rule CXX_COMPILER__srvOuve
  depfile = $DEP_FILE
  deps = gcc
  command = /usr/bin/c++  $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in
  description = Building CXX object $out


#############################################
# Rule for linking CXX executable.

rule CXX_EXECUTABLE_LINKER__srvOuve
  command = $PRE_LINK && /usr/bin/c++  $FLAGS  $LINK_FLAGS $in  -o $TARGET_FILE $LINK_PATH $LINK_LIBRARIES && $POST_BUILD
  description = Linking CXX executable $TARGET_FILE
  restat = $RESTAT


#############################################
# Rule for re-running cmake.

rule RERUN_CMAKE
  command = /usr/bin/cmake -H/home/maurinsoft/projetos/srvOuve/srv -B/home/maurinsoft/projetos/srvOuve/srv
  description = Re-running CMake...
  generator = 1


#############################################
# Rule for cleaning all built files.

rule CLEAN
  command = /usr/bin/ninja -t clean
  description = Cleaning all built files...


#############################################
# Rule for printing all primary targets available.

rule HELP
  command = /usr/bin/ninja -t targets
  description = All primary targets available:

Para processar o ninja precisamos fazer uma pequena mudança, alterar as extensões de .c para .cpp, para que o sistema identifique que se trata de compilador C.

Incluindo dependências

Para incluir diretorios para Include, basta incluir a linha

Diretórios de Include

include_directories( “/usr/local/include/pocketsphinx”
“/usr/local/include/sphinxbase”
)

Include adicional

Gerando binário

Por fim precisaremos dar o comando ninja para compilar os scripts.

$ ninja

Pronto você montou um Montador em Ninja! Parabéns!

Sem categoria
Usando o microfone no linux

Estarei abordando aqui como gravar e como reproduzir audio gravados no microfone pelo console no linux.

Como funciona o áudio no Linux

O audio no linux, é um pouco diferente do tradicional, ele usa o que chamamos de alsa device.

ALSA é um conjunto de módulos do kernel, o ALSA, subistituiu o antigo OOS (Open Sound System).

O Kernel permite compartilhar os recursos de audio, através da API ALSA.

Os usuários normais tem privilégios de reprodução e alteração dos mixer de audio.

No console recomendamos fortemente a utilização do pacote alsa-utils, ele contem os utilitários alsamixer e amixer.

apt install alsa-utils

Instalação dos pacotes de áudio

Descobrindo os devices no Linux

Para descobrir os devices no linux, usaremos o arecord, que será instalado nos pacotes alsa-utils.

A sintaxe do arecord, é conforme a que segue:

arecord -l

Listando devices no linux
Exemplo de devices em minha maquina

O device sempre começa com hw:[placa],[device]

Gravando áudio

Para gravar um áudio, continuaremos usar o arecord, porem com uma sintaxe um pouco diferente.

arecord -f S16_LE -d 10 -r 16000 –device=”hw:2,2″ /tmp/teste-mic.wav

Gravação de som no arquivo

a opção -d faz a gravação de 10 segundos (duração)

o parametro -f é o formato, podendo ser conforme o link

https://linux.die.net/man/1/arecord

–device= é o nome do PCM selecionado.

Reproduzindo áudio

Para reproduzir um audio, utilizamos o comando aplay, porem eu pessoalmente gosto mais do mplayer.

apt install mplayer

Tocador de multimídia

Selecionar mixer

alsamixer é um mixer de audio, que permite ligar e desligar entradas de audio de seu pc.

>alsamixer

aplicação alsamixer

Para capturar o dispositivo de audio, é necessario ir até o dispositivo que deseja capturar.

Então pressionar space (Espaço), desta forma o dispositivo ficara capturado como default.

Dispositivo capturado para gravação.

Nota do autor, alguns dispositivos de som 7.1 tive dificuldades em conseguir capturar, tive que incluir um device usb 2.0, para conseguir capturar o audio.

Blog Sem categoria
Rosas do meu jardim
rosas do meu jardim

As minhas rosas, do jardim foi apartado.

Como pode o coração, e o jardim ser tão completo se não tem as rosas para enfeitar o seu chão.

Não existe o jardim, sem as rosas perdidas, pois somente elas enfeitam e embelezam este chão tão castigado.

Não há chuva que reponha, nem vento que modifique a aspereza deste solo seco e profanado.

São as rosas que fazem do solo, um jardim, sem elas nada mais é que sertão abandonado.

Sem categoria
Dia dos Pais
É obrigatório o pai registrar o filho? - CertidaodeNascimento.com.br

Mesmo estando longe, eu zelo por você.

Quando perto, eu procuro te alegrar,

Distante eu procuro consolar.

Não tenho coração, porque esse ficou com você quando nasceu.

As histórias que passamos, as dificuldades que enfrentamos e principalmente a ausencia que estamos.

Pai, um espelho para o filho - Milícia da Imaculada

Tudo será perdoado! Pois um dia, os grilhões da lei e os apelos por justiça não mais terão sentido.

Somente a face da verdade, a lei maior, o unico inquisidor verdadeiro.

Seu coração!

Sobre ele, repouso tranquilo,

Pois dei para voce quando nasceu.

E hoje sei que esta seguro em seu peito.

Parábola do Filho Pródigo - Estudo Completo sobre o Pai do Filho Pródigo

Leve-o com ele e tenha certeza que a cada batida, serei eu que estarei aqui vigiando.

Para que tudo o que da vida, for preciso e necessário voce tenha!

Pois se o amor de mãe protege, o de pai sustenta!

De Marcelo Maurin Martins para suas filhas

Blog Sem categoria
A vida imitando a arte

Sou fã de star trek, aqui no Brasil, Jornada nas Estrelas.

set de filmagem, trabalhado apenas do lado da câmera.

Como podemos ver nesta foto, o set de jornada nas estrelas, demonstra bem, o que as vezes vemos em tecnologia da informação.

O que o cliente vê é sempre o que esta no olhar das câmeras. Um ambiente produzido, perfeito e muitas vezes trabalhado, horas a fio por uma equipe muito competente.

spocksbrain_026.jpg
Imagem que a câmera mostra

De fato, esta é a imagem, que o empresário e os vendedores passam para os clientes.

Ambientes perfeitos, sem detalhes.

Mas a verdade esta por traz dos camarins, nos sets de filmagem.

Não seja só um “Severino”!
Ator Paulo Silvino, eterno Severino.

As vezes para fazer a porta abrir sozinha na filmagem, existe o nosso amigo Severino, que fica no set de filmagem, abrindo e fechando a porta com a mão. Pois algo deu errado no equipamento, e de fato, o cliente não pode esperar, por isso precisou dele, de forma rápida e pontual.

Muitas vezes vi, empresas de grande monta, apresentarem sua imagem ao grande publico, como a demonstrada no set. Tudo perfeito, funcionando. Mas de fato é trabalho duro de tantos Severinos da TI, que atuam exaustivamente para garantir que o publico tenha também essa visão.

Até ai, tudo bem! O cliente assim como o grande publico, realmente precisa ver o lado belo da arte da tecnologia, e pouco importa se iremos mostrar as agruras e problemas dessa maratona para chegar a esse estado de arte.

Mas o que vejo, as vezes com certo espanto, é gerentes, diretores, vendedores, compartilhar o olhar do grande publico, as vezes, eles tambem se perdem na grande arte, e começam a acreditar na magia que vendem.

Acredito que um bom gerente ou diretor, é como um bom produtor de filme, vende o sonho da tecnologia, mas trabalha ao fim, sabendo que o palco precisa de tantos Severinos da TI, que fazem o publico sonhar com a tecnologia, que de fato é nossa, e aos olhos dos clientes acontece como mágica.

Aos tantos Severinos da TI, parabéns vcs são os que realmente fazem a magica acontecer.

Blog srvOuve
srvOuve

Dei o primeiro passo no desenvolvimento do projeto srvOuve.

O intuito deste projeto, é fornecer uma ferramenta de reconhecimento de fala. Convertendo Fala para texto, este projeto é 100% offline, não necessitando de nenhuma API na nuvem.

O projeto srvOuve é uma integração com o Sphinx, projeto de reconhecimento de voz.

Permite através de uma porta tcp, escutar tudo o que é ouvido, em forma de texto.

O intuito deste projeto é facilitar o desenvolvimento em etapas de aprendizado de maquina.

Obtendo uma forma simples e eficiente de integrar esta feature.

O que é o CMU Sphinx

CMU Sphinx é uma api de reconhecimento de voz. Ela é bastante consagrada, possuindo muitos projetos atrelados a ela.

A grande vantagem desta api, é que ela não necessita de conexão externa ou acesso a internet.

Uso do CMU Sphinx

Utilizaremos o CMU Sphinx como base do nosso projeto.

Instalação do Shinx

Artigos relacionados

    CMU Sphinx – Maurinsoft

    Sem categoria
    Servidor de fala

    O intuito deste pequeno projeto, é disponibilizar recursos de fala (texto para voz).

    API espeak, integrada, permite sintetizar voz.

    O uso deste serviço é disponibilizado através da porta 8096, TCP, podendo ser integrado com diversas linguagens.

    Possui um pequeno executável de teste, que pode ser rodado em windows.

    O servidor necessita ser rodado em linux.

    en_USEnglish