Atabaque Studio

Aplicacao desktop Qt/QML para inspecionar PCAP e captura TV 3.0/ATSC 3.0 usando a libatsc3 como core de protocolo.

Objetivo

O foco principal e mostrar sinalizacao TV 3.0 de forma detalhada:

PCAP/captura -> IP/UDP -> LLS -> SLT -> SLS -> USBD/S-TSID/MPD/BALD -> ROUTE/DASH/NRT

A versao atual entrega uma primeira vertical funcional:

• dashboard Qt/QML com quatro modulos;
• analise offline de PCAP via libatsc3;
• catalogo de LLS por table_id, grupo e versao;
• reconstrucao de artefatos ROUTE/SLS quando a sinalizacao permite;
• visoes separadas para fluxos IP/UDP, sinalizacao, ROUTE/DASH, NRT, aplicacoes por BALD e inconsistencias;
• catalogo JSON em signaling-payloads.json com serviceContextId, tipo e XML original de tabelas/fragmentos;
• modo headless para smoke test e automacao.

Captura ao vivo e editor XML ja aparecem como modulos de produto, mas o backend completo deles ainda e etapa seguinte.

Começando (clone + build)

git clone https://github.com/adrielvasques/atabaque.git
cd atabaque
./scripts/atabaque.sh bootstrap   # deps Qt/build (libatsc3 já vem vendorizada)
./scripts/atabaque.sh build       # compila + bundle
./scripts/atabaque.sh run         # abre a GUI

Não precisa de --recursive: a libatsc3 é vendorizada (não é submódulo). Detalhes de build/AppImage/headless/logs em docs/build.md.

Dependencias Ubuntu/Debian

./scripts/bootstrap-third-party.sh
./scripts/bootstrap-ubuntu-qt.sh

Build

./scripts/build-qt-mvp.sh

O build compila a libatsc3 a partir do fonte em third_party/libatsc3 e gera um archive local em build/third_party/libatsc3/libatsc3_core.a. Ao final, tambem gera:

• dist/AtabaqueStudio/: pasta standalone.
• dist/AtabaqueStudio-linux-x86_64.tar.gz: pacote compactado.
• dist/AtabaqueStudio-linux-x86_64.run: arquivo unico executavel.

Para compilar sem gerar o bundle:

SKIP_STANDALONE=1 ./scripts/build-qt-mvp.sh

A libatsc3 é vendorizada (cópia enxuta já com o patch TV 3.0 aplicado, em third_party/libatsc3) — não é submódulo. Logo, basta clonar o repositório; não precisa de --recursive. O bootstrap-third-party.sh apenas valida a presença/patch (e, como fallback, clona o upstream caso a pasta esteja ausente).

O patch patches/libatsc3-tv30-lls-table-ids.patch adiciona os IDs LLS da TV 3.0 brasileira (0x90 BAMT, 0x91 TBSAT) e já vem aplicado na cópia vendorizada.

Rodar

./scripts/run-qt-mvp.sh

Na UI, abra o modulo Analise de PCAP, informe um PCAP e uma pasta de saida. O extractor cria uma subpasta por execucao, mostra a sinalizacao detalhada e deixa os artefatos em lls/ e route/.

Para rodar o pacote standalone gerado:

./dist/AtabaqueStudio/run.sh

Para rodar o executavel unico:

chmod +x dist/AtabaqueStudio-linux-x86_64.run
./dist/AtabaqueStudio-linux-x86_64.run

Tambem existe modo headless para teste rapido:

./build/atabaque-studio \
  --pcap /caminho/captura.pcap \
  --output /tmp/atabaque-runs

Cada execucao cria uma subpasta com:

• lls/: XMLs LLS catalogados por table_id, grupo e versao.
• route/: objetos SLS/ROUTE reconstruidos pela libatsc3.
• signaling-payloads.json: estrutura JSON com os payloads XML originais mapeados por familia.

O resumo por tipo diferencia, por exemplo, LLS SLT, LLS BAMT, ROUTE SLS multipart bundle, DASH MPD, TV 3.0 BALD, ROUTE S-TSID, ROUTE USBD, ROUTE FDT instance e segmentos ISOBMFF.

Mapeamento de sinalizacao exposto pelo Atabaque:

• LLS: aeat, bam, cdt, osn, rrt, slt, alem de extensoes reconhecidas como tbsat e systemTime.
• SLS: apd, bald, dwd, mpd, prrd, sgdd, sgdu, usbd, stsid.

Modulos da UI

• Analise de PCAP: modulo principal. Mostra fluxos IP/UDP, LLS, SLT/SLS, documentos USBD/S-TSID/MPD/BALD, artefatos e inconsistencias.
• Captura em tempo real: shell de produto para captura IP/UDP via libpcap, com LLS em 224.0.23.60:4937 e descoberta futura de fluxos ROUTE.
• Editor de PCAP: shell para editor XML de LLS/SLT/SLS/USBD/S-TSID/MPD/BALD, geracao de novo PCAP e reanalise.
• Parser de artefatos: classifica sinalizacao, DASH, NRT e aplicacoes. NRT sem BALD permanece artefato; aplicacao so aparece quando houver BALD.

Estrutura

cmake/LibAtsc3.cmake            Integra a libatsc3 fonte ao CMake
scripts/bootstrap-ubuntu-qt.sh  Instala dependencias de build/runtime
scripts/bootstrap-third-party.sh Clona/prepara libatsc3 e aplica patch TV 3.0
scripts/build-libatsc3-core.sh  Compila libatsc3.o e empacota libatsc3_core.a
scripts/build-qt-mvp.sh         Configura e compila o app Qt
src/core/                       Adaptador C++ sobre a libatsc3
src/domain/                     Modelos de dominio TV 3.0/ATSC 3.0
src/ui/Theme.qml                Design system (cores, tipografia, espacamento, icones)
src/ui/components/              Componentes reutilizaveis (AppButton, DataListCard, ...)
src/ui/pages/                   Telas (Dashboard, Analise, Captura, Editor, Parser)
src/ui/Main.qml                 Shell: topbar + navegacao entre paginas
third_party/libatsc3            Cópia vendorizada (enxuta) da libatsc3 + patch TV 3.0

Proximos passos de engenharia

1. Mover a extracao para uma thread de trabalho para nao bloquear a UI em PCAPs grandes.
2. Trocar as listas QML atuais por modelos Qt tipados para LLS, SLS, ROUTE, DASH, NRT e aplicacoes.
3. Implementar captura ao vivo IP/UDP via libpcap.
4. Implementar editor XML com validacao e diff.
5. Adicionar pipeline de geracao de nova sinalizacao e novo PCAP.