Entre em Contato com a Maurinsoft – Página: 46

Marcelo Martins C, cmake, ninja

Inclusão de libs no CMAKE

Muitas vezes temos que incluir libs e fontes no nosso projeto no CMAKE.

Irei mostrar como faze-lo.

Crie seu código CMakeLists.txt

cmake_minimum_required (VERSION 3.8)
project(projeto VERSION 1.0)
include_directories("."	"./include")
set(CMAKE_CXX_STANDARD 14)

#adicionando libs
add_library(lib1 SHARED IMPORTED)
set_property(TARGET lib1 PROPERTY IMPORTED_LOCATION "./libs")

add_library(lib2 SHARED IMPORTED)
set_property(TARGET lib2 PROPERTY IMPORTED_LOCATION "./libs2")

add_executable(projeto mainsource.c source1.c)

Pronto vc incluiu libs

C/C++ Sem categoria

Marcelo Martins libusb, usb

LIB libusb

Quem tem um PC, sabe que praticamente qualquer dispositivo atualmente esta conectado na USB.

Os dispositivos USB são cada vez mais populares, por sua praticidade e simplicidade.

O desenvolvimento e integração no linux, sempre foi um caminho tortuoso, neste post estarei desvendando um pouco de como funciona o desenvolvimento e o caminho a ser traçado.

O projeto libusb, é uma lib desenvolvida em C, para Linux, ela permite utilizar o protocolo USB da versão 1.0 até a 3.1.

O site do projeto pode ser visto:

https://libusb.info/

O git do projeto pode ser baixado facilmente através do seguinte repositório:

https://github.com/libusb/libusb/releases

Instalação no linux

A instalação da libusb pode ser feita de duas formas:

Compilação do fonte através da baixa e compilação manual.
Baixar os pacotes no linux

Estaremos tratando aqui, do segundo método, pois é o mais prático e direto.

Existem dois pacotes da lib usb:

Uma uso e distribuição (libusb-1.0-0), não permite compilar.
Lib destinada ao desenvolvimento e compilação. (libusb-1.0-0-dev)

Desenvolvimento em C

Para desenvolver em C, primeiramente precisaremos instalar as seguintes dependencias.

apt install libusb-1.0-0-dev libusb-1.0-0
Dependências para compilação

O pacote -dev, incluirá na pasta /usr/local/include os headers que permitem a compilação da lib.

No projeto fonte: https://github.com/libusb/libusb/archive/refs/tags/v1.0.24.zip

Você encontra uma pasta com uma série de fontes, exemplos (exemples).

Entre os exemplos estão o listdevs.c, que vemos no código abaixo:

/*
 * libusb example program to list devices on the bus
 * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>

#include "libusb.h"

static void print_devs(libusb_device **devs)
{
	libusb_device *dev;
	int i = 0, j = 0;
	uint8_t path[8];

	while ((dev = devs[i++]) != NULL) {
		struct libusb_device_descriptor desc;
		int r = libusb_get_device_descriptor(dev, &desc);
		if (r < 0) {
			fprintf(stderr, "failed to get device descriptor");
			return;
		}

		printf("%04x:%04x (bus %d, device %d)",
			desc.idVendor, desc.idProduct,
			libusb_get_bus_number(dev), libusb_get_device_address(dev));

		r = libusb_get_port_numbers(dev, path, sizeof(path));
		if (r > 0) {
			printf(" path: %d", path[0]);
			for (j = 1; j < r; j++)
				printf(".%d", path[j]);
		}
		printf("\n");
	}
}

int main(void)
{
	libusb_device **devs;
	int r;
	ssize_t cnt;

	r = libusb_init(NULL);
	if (r < 0)
		return r;

	cnt = libusb_get_device_list(NULL, &devs);
	if (cnt < 0){
		libusb_exit(NULL);
		return (int) cnt;
	}

	print_devs(devs);
	libusb_free_device_list(devs, 1);

	libusb_exit(NULL);
	return 0;
}

No código acima, irei apresentar apenas alguns poucos pontos, que acredito serem chaves para o entendimento desta api.

O include #include “libusb.h”, permite usar a api do c, este é um passo importante que apesar de notório, achei bom comentar.

A criação da variavel dev, conforme segue:

libusb_device *dev;

É importante, pois este, guardará as informações dos dispositivos.

A chamada da função libusb_get_device_descriptor, coleta as informações do device alvo. Lembrando que dispositivos usb no linux

int r = libusb_get_device_descriptor(dev, &desc);

O dispositivo e suas propriedades, podem ser visualizados, através da chamada de suas propriedades, como segue desc.idVendor .

Por fim, a listagem dos dispositivos conectados, pode ser obtida, pela função:

cnt = libusb_get_device_list(NULL, &devs);

Podemos notar a simplicidade desta api.

Espero ter ajudado a entender um pouco mais sobre USB e acesso a dispositivos.

Blog C/C++ Dicas Sem categoria

Marcelo Martins

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:

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.

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.

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:

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

Includes de distribuição,

Ficam em .\cef\include conforme figura abaixo:

C/C++ cmusphinx IA

Marcelo Martins C++, cmake, ninja

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)

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!

Blog C/C++ Dicas

Marcelo Martins IDE Online, Web

Testando código em C

As vezes precisamos testar um codigo em C de forma bem pontual.

E não temos uma maquina com tudo instalado, Compilador, ambiente.

Existe uma ferramenta Online:

https://ideone.com/

O atributo alt desta imagem está vazio. O nome do arquivo é image-1.png

Com ela, é possível testar códigos e compilar de forma rápida e pontual.

Sem categoria

Marcelo Martins

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

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

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.

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.

Sem categoria

Marcelo Martins

Dispositivo remoto USB

O virtualhere permite compartilhar um dispositivo usb remoto como se fosse nativo.

O site do fabricante é:

https://www.virtualhere.com/

Eu recomendo!

Blog Sem categoria

Marcelo Martins

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

Marcelo Martins

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

Marcelo Martins

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.

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.