Hackujeme TV LG - od hello world po framebuffer

16.11.2012 21:45 | Přečteno: 4528× | Hardware | | poslední úprava: 17.11.2012 08:51

V minulom blogu o televízoroch LG som písal o tom ako sa dostať na rootovsku konzolu. Dnes zájdeme trochu ďalej a ukážeme si ako pomocou cross kompilátora pre túto platformu kompilovať programy / knižnice. Nakoniec si ukážeme ako používať framebuffer na vykresľovanie vlastného OSD. S použitím vedomostí o framebufferi môžme tvoriť aj tak neužitočný, ale veľmi efektný softvér, ako je zobrazovač modelov v blenderi, ktorý prijíma informácie o modeli cez RS232 a celý výpočet geometrie prebieha (mimochodom pekne pomalý pri použití float point aritmetiky) na TV prijímači.

Cross kompilátor

Ak si pozrieme súbor /proc/cpuinfo zistíme, že pracujeme s MIPS-om. Pre kompiláciu pre MIPS budeme potrebovať s takmer 100% pravdepodobnosťou cross kompilátor (ruku na srdce, kto z Vás používa MIPS na desktope?).

cat /proc/cpuinfo
system type             : MStar Titania
processor               : 0
cpu model               : MIPS 4KEc V6.12
BogoMIPS                : 211.96
wait instruction        : yes
microsecond timers      : yes
tlb_entries             : 16
extra interrupt vector  : yes
hardware watchpoint     : no
ASEs implemented        : mips16
shadow register sets    : 1
core                    : 0
VCED exceptions         : not available
VCEI exceptions         : not available

Softvér

Televízory LG majú celý systém okrem aplikácie RELEASE založený na open source kóde. Musia preto poskytovať upravené zdrojové kódy kernelu a knižníc. Tie je možné pre konkrétny model vyhľadať a stiahnuť na adrese www.lg.com/global/support/opensource/opensource.jsp.

Ako kompilátor sa dá použiť štandardné gcc pre MIPS (mal by byť dostupný v extra repozitároch). Hotový kompilátor je možné stiahnuť z uclibc.org. Pre jeho použitie postačí kompilátor rozbaliť v ľubovoľnom adresári a nastaviť PATH príkazom:

PATH=$PATH:$PWD/cross-compiler-mipsel/bin/

Funkčnosť kompilátora môžme vyskúšať na programe hello_world.c.

// hello_world.c

#include <stdio.h>
int main(void) { printf("Hello World!"); }

Kompilovať budeme príkazom mipsel-gcc -mips32 -static hello_world.c pre platformu saturn 6, alebo mipsel-gcc -mips32r2 -static hello_world.c pre platformu saturn 7. Platformu, pre ktorú je skompilovaný spustiteľný súbor skontrolujeme príkazom file a.out.

$ file a.out # Saturn 6
a.out: ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), statically linked, not stripped

$ file a.out # Saturn 7
a.out: ELF 32-bit LSB executable, MIPS, MIPS32 rel2 version 1 (SYSV), statically linked, not stripped

Presun programov do TV

Najjednoduchším, ale zároveň najnepohodlnejším spôsobom je skopírovanie programu na USB kľúč a pripojenie k TV. Kľúč sa automaticky pripojí a jednotlivé partície sú na adrese /mnt/usb(1|2|…)/Drive(1|2|3|4). Najčastejšie táto adresa bude /mnt/usb1/Drive1. Všetky súbory na USB kľúči sú automaticky pripojené s executable bitom, takže náš hello world nebudeme mať problém spustiť príkazom cd /mnt/usb1/Drive1/&&./a.out.

Kopírovanie dát pomocou RS232

Neustále pripájanie a odpájanie USB zariadenia je veľmi otravné hlavne pri ladení aplikácie. Pohodlnejším a pre menšie programy zrejme aj rýchlejším spôsobom bude kopírovanie priamo pomocou sériového portu. Dúfam, že teraz nikoho nenapadla myšlienka spustiť echo "cat > subor" > /dev/ttyUSB0 && cat lokalny_subor >> /dev/ttyUSB0 pretože tento kód nemôže fungovať pri prenose binárnych dát kvôli možnej kolízii s riadiacimi znakmi terminálu.

Pre zamedzenie kolízií s riadiacimi znakmi musia byť dáta zakódované do relatívne bezpečnej množiny znakov. Binárne dáta sú cez sériový port zvyčajne prenášané pomocou protokolov XMODEM, YMODEM, alebo ZMODEM.

XMODEM

Pri prenose sa používajú pakety štandardne o veľkosti 128B, za ktorým nasleduje kontrolný súčet o veľkosti 1B. Paket je prefixovaný 3-Bytovou hlavičkou, celková veľkosť je teda 132B. Po odosielaní čaká odosielateľ na signál ACK (môže pokračovať ďalším paketom), alebo NAK (došlo k chybe pri prenose). Tento protokol je veľmi pomalý pri pooužití USB-RS232 redukcie kvôli latencii USB protokolu.

YMODEM

Veľmi podobný XMODEM-u. Hlavným rozdielom je, že sa prenáša v hlavičke aj názov súboru.

ZMODEM

Tento protokol posiela v hlavičke názov súboru podobne ako YMODEM. Dáta sú vysielané bez čakania na potvrdenie príjemcu. Ten môže odosielať signály ACK a NAK s určitým oneskorením.

Kompilácia ZMODEM-u pre MIPS

Jednoduchú implementáciu x/y/zmodemu môžme nájsť na adrese ohse.de/uwe/software/lrzsz.html. Z webu stiahneme súbor lrzsz-x.y.z.tar.gz a rozbalíme ho príkazom tar -xvzf lrzsz-*.tar.gz. Kompilácia prebieha štandardnou trojicou príkazov ako u každej inej aplikácie používajúcej autoconf. Skript configure sa musí spustiť s premennými prostredia CC=/absolútna/cesta/k/mipsel-gcc a CFLAGS="-mips32 -static" pre saturn 6, alebo CFLAGS="-mips32r2 -static" pre saturn 7. Celá trojica príkazov vyzerá teda takto:

CC="/absolútna/cesta/k/mipsel-gcc" CFLAGS="-mips32r2 -static" ./configure --prefix "`pwd`/build"
make
make install

Skompilované programy pre x/y/zmodem sa budú nachádzať v adresári build/bin. Dostať ich do TV je možné napríklad pomocou USB kľúča.

ls build/bin
lrb  lrx  lrz  lsb  lsx  lsz

Kopírovanie súborov

Po zasunutí USB kľúča sa prípojný bod väčšinou nachádza na /mnt/usb1/Drive1. V tomto adresári nájdeme skompilované programy x/y/zmodemu. Pre prijatie súboru spustíme na TV nasledujúci príkaz:

(root@tv) /mnt/usb1/Drive1 # ./lrz -b --zmodem

Pre zmodem boli použité nasledujúce voľby:

-b

Binárny prenos

--zmodem

Používať ZMODEM protokol

Následne uvoľníme zariadenie /dev/ttyUSB0 klávesovou skratkou CTRL+A, SHIFT+K v screen-e. Prenos sa začne nasledujúcim príkazom spusteným na počítači.

(user@pc) ~ $ lsz -b --zmodem subor < /dev/ttyUSB0 > /dev/ttyUSB0

Odosielať súbory je možné aj bez ukončenia programu screen. Je však potrebné spustiť externý program lsz s presmerovaným vstupom aj výstupom priamo v screen-e klávesovou skratkou CTRL+A a následne príkazom :exec !!lsz -b --zmodem subor.

Makefile pre pohodlnejší život

Uvedený postup kopírovania je pomerne zložitý. Asi by som sa nemohol nazývať linuxákom keby som to nevedel zautomatizovať Nasledujúci Makefile slúži na kompiláciu a skopírovanie programu do TV. Pre upload programu stačí spustiť make upload. Cesty a voľby musia byť samozrejme upravené pre konkrétne zariadenie / konfiguráciu.

.PHONY: upload

CC=mips2_fp_le-gcc
CFLAGS=-mips32r2 -static
STRIP=mips2_fp_le-strip

OUTPUT=fb-test
SOURCE=main.c

DEVICE=/dev/ttyUSB0
WORKING_DIRECTORY=/mnt/usb1/Drive1
ZMODEM_BINARY=/mnt/usb1/Drive1/zmodem/lrz
ZMODEM_PARAMS=-b --zmodem --overwrite

${OUTPUT}: ${SOURCE}
	${CC} ${CFLAGS} $< -o $@
	${STRIP} $@
	upx -9 $@

upload: ${OUTPUT}
	echo "sh" > ${DEVICE}
	echo "cd ${WORKING_DIRECTORY}" > ${DEVICE}
	echo "${ZMODEM_BINARY} ${ZMODEM_PARAMS}" > ${DEVICE}
	lsz ${ZMODEM_PARAMS} ${OUTPUT} < ${DEVICE} > ${DEVICE}
	echo "exit" > ${DEVICE}

Framebuffer

Prvé framebufferové zariadenie nájdeme v Linuxe zvyčajne na adrese /dev/fb0. U televízorov LG je síce zariadenie vytvorené a má správne major (29) a minor(0) číslo, ale neobsluhuje ho žiaden modul. O tom sa ľahko môžme presvedčiť pri pokuse o čítanie (cat /dev/fb0 > /tmp/fb.data ... cat: can't open '/dev/fb0': No such device or address), alebo o zápis. Aby zariadenie fungovalo musíme skompilovať (alebo stiahnuť) moduly obsluhujúce framebuffer. Tie sú zverejnené na stránke sourceforge.net/projects/openlgtv/files/VFB/. Súbor vfb-lgmod-v0.01.zip funguje aj na nemodifikovanom firmvéri zatiaľ čo na vfb-openlgtv-v0.01.zip budeme potrebovať nahradiť jadro. Súbor obsahuje niekoľko modulov, ktoré sa dajú naraz načítať spustením ./vfb.sh.

Po načítaní modulov môžme začať používať framebuffer. Pre vyskúšanie si môžme zobraziť menu televízora a zaznamenať jeho obraz príkazom cat /dev/fb0 > /tmp/fb.data. Po vypnutí menu môžme uložený obraz obnoviť príkazom cat /tmp/fb.data > /dev/fb0.

Konverzia obrázkov pre framebuffer

Prvý framebuffer má veľkosť 1368x768 pixelov. Formát je ARGB1555 (tj. 16 bitov na pixel). Pixely sú uložené štandardne tj. prvý pixel je v ľavej hornej časti obrazovky. Za nim nasledujú ďalšie pixely smerom doprava. Spôsob kódovania farieb do 16-bitového pixelu je v nasledujúcej tabuľke.

Bity	Význam
a 00000 00000 00000	Úplne priehľadný pixel. Z toho vyplýva, že nie je možné definovať úplne čiernu farbu, ale minimálne jedna zložka farby musí byť nenulová.
0 rrrrr ggggg bbbbb	Polopriehľadný pixel (alfa približne 0.75) s farbou definovanou zvyšnými bitmi.
1 rrrrr ggggg bbbbb	Neprehľadný pixel s farbou definovanou zvyšnými bitmi.
a rrrrr ggggg bbbbb	Hodnota červenej zložky pixelu.
a rrrrr ggggg bbbbb	Hodnota zelenej zložky pixelu.
a rrrrr ggggg bbbbb	Hodnota modrej zložky pixelu.

Nasledujúci program slúži na jednoduchú konverziu medzi obrázkom a RAW dátami ARGB1555. Používa sa príkazom python convert.py obrazok.png obrazok.data pre konverziu do ARGB1555, alebo python convert.py obrazok.data obrazok.png pre opačnú konverziu. Vykresliť obrázok na TV je možné príkazom cat obrazok.data > /dev/fb0.

coding: utf-8 -*-

from PIL import Image
from struct import pack, unpack

IMAGE_WIDTH = 1368
IMAGE_HEIGHT = 768
IMAGE_SIZE = (IMAGE_WIDTH, IMAGE_HEIGHT)
IMAGE_PIXEL_COUNT = 1368 * 768

def image_to_argb1555(image, output_filename):
    def convert_color_to_argb1555(pixel):
        r, g, b, a = pixel
        if r < 8 and g < 8 and b < 8: # Nepodporuje čiernu
            b = 8
        if a > 228:
            a = 0
        elif a > 96:
            a = 1
        else:
            a = 0
            r = 0
            g = 0
            b = 0
        color = ((r >> 3) << 10) | ((g >> 3) << 5) | ((b >> 3) << 0) | ((a) << 15)
        return color
    image.resize(IMAGE_SIZE)
    pixels = map(convert_color_to_argb1555, image.getdata())
    data = pack(str(IMAGE_PIXEL_COUNT) + "H", *pixels)
    f = open(output_filename, 'wb')
    f.write(data)

def image_from_argb1555(in_data, output_filename):
    def convert_color_from_argb1555(pixel_data):
        r = ((pixel_data & 0b0111110000000000) >> 10) << 3
        g = ((pixel_data & 0b0000001111100000) >> 5) << 3
        b = ((pixel_data & 0b0000000000011111) >> 0) << 3
        a = ((pixel_data & 0b1000000000000000) >> 15) << 7
        if a == 0: # Môže nadobúdať len 0 a 128
            a = 255
        else:
            a = 196
        if r == 0 and g == 0 and b == 0:
            a = 0
        return (r << 0) | (g << 8) | (b << 16) | (a << 24)
    pixel_data = unpack(str(IMAGE_PIXEL_COUNT) + "H", in_data)
    argb_data = map(convert_color_from_argb1555, pixel_data)
    image_buffer = pack(str(IMAGE_PIXEL_COUNT) + "I", *argb_data)
    im = Image.fromstring("RGBA", IMAGE_SIZE, image_buffer, "raw", "RGBA", 0, 1)
    im.save(output_filename)

def main():
    import sys
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    try: # Konverzia z obrázku na ARGB1555
        im = Image.open(input_file)
        image_to_argb1555(im, output_file)
    except IOError: # Opačná konverzia
        in_data = open(input_file, 'rb').read()
        image_from_argb1555(in_data, output_file)

if __name__ == "__main__":
    main()

Obrázky z menu získané z framebufferu príkazom cat /dev/fb > /tmp/fb.data a konvertované skriptom a naopak obrázky vykreslené na TV zápisom do framebufferu vyzerajú nasledovne:

Graphics Output Path

V skutočnosti na vykresľovanie obrazu vôbec nepotrebujeme zariadenie /dev/fb0. Aplikácia RELEASE zabezpečujúca užívateľské rozhranie používa framebuffer priamo.

Samotný framebuffer sa nachádza v RAM. O čítanie tejto oblasti a jej vykresľovanie na obrazovke sa stará obvod s ničnehovoriacim názvom MStar GOP (Graphics Output Path). Dokumentáciu k samotnému obvodu som síce nenašiel, ale zdrojové kódy ovládača sú otvorené a dostupné na webe openlgtv.git.sourceforge.net. Obvod GOP je možné ovládať pomocou zariadenia /dev/gop. Nasledujúci príklad vypíše do dmesg-u informácie o framebufferi. Skompilujeme ho príkazom:

mipsel-gcc main.c -mips32r2 -static \
  -I /cesta/ku/kernelu/include
  -I /cesta/ku/kernelu/drivers/mstar/include
  -I /cesta/ku/kernelu/drivers/mstar/gop/titania2

#define __KERNEL__

#include <fcntl.h>
#include <sys/ioctl.h>
#include <mhal_gop.h>
#include <mdrv_gop.h>

#define DEVICE_FILE "/dev/gop"

int main()
{
	int fd = open(DEVICE_FILE, 0);
	if (fd < 0) {
		return -1;
	}
	ioctl(fd, MDRV_GOP_IOC_GWIN_INFO, 0);
	close(fd);
	return 0;
}

Výpis dmesg-u po spustení programu by mal vyzerať približne takto:

[ 6150.942000] GOP opens successfully
[ 6150.942000]
[ 6150.942000] GOP[0] info-----------------------------------
[ 6150.942000] p->eGOP_Type=0
[ 6150.942000] p->u8Wid=3
[ 6150.942000] p->u32SrcX=0
[ 6150.942000] p->u32SrcY=0
[ 6150.942000] p->u32DispX=0
[ 6150.942000] p->u32DispY=0
[ 6150.942000] p->u32Width=1368
[ 6150.943000] p->u32Height=768
[ 6150.943000] p->u32DRAMRBlkStart=0x0AC0A000
[ 6150.943000] p->u32DRAMRBlkHSize=1368
[ 6150.943000] p->u32DRAMRBlkVSize=768
[ 6150.943000] p->eColorTyped=E_GOP_COLOR_RGB555_BLINK
[ 6150.943000] p->pitch=0
[ 6150.943000] p->mem size=0x00000000
[ 6150.943000]
[ 6150.943000] GOP[1] info-----------------------------------
[ 6150.943000] p->eGOP_Type=1
[ 6150.943000] p->u8Wid=1
[ 6150.943000] p->u32SrcX=0
[ 6150.944000] p->u32SrcY=0
[ 6150.944000] p->u32DispX=0
[ 6150.944000] p->u32DispY=0
[ 6150.944000] p->u32Width=984
[ 6150.944000] p->u32Height=768
[ 6150.944000] p->u32DRAMRBlkStart=0x02A5D010
[ 6150.944000] p->u32DRAMRBlkHSize=1376
[ 6150.944000] p->u32DRAMRBlkVSize=768
[ 6150.944000] p->eColorTyped=E_GOP_COLOR_I8
[ 6150.944000] p->pitch=1376
[ 6150.944000] p->mem size=0x00102000
[ 6150.944000]
[ 6150.944000] GOP[2] info-----------------------------------
[ 6150.944000] p->eGOP_Type=0
[ 6150.945000] p->u8Wid=0
[ 6150.945000] p->u32SrcX=0
[ 6150.945000] p->u32SrcY=0
[ 6150.945000] p->u32DispX=0
[ 6150.945000] p->u32DispY=0
[ 6150.945000] p->u32Width=0
[ 6150.945000] p->u32Height=0
[ 6150.945000] p->u32DRAMRBlkStart=0x00000000
[ 6150.945000] p->u32DRAMRBlkHSize=0
[ 6150.945000] p->u32DRAMRBlkVSize=0
[ 6150.945000] p->eColorTyped=E_GOP_COLOR_RGB555_BLINK
[ 6150.945000] p->pitch=0
[ 6150.945000] p->mem size=0x00000000
[ 6150.945000] GOP closes successfully

Dôležitá pre priame ovládanie je hlavne informácia o začiatočnej pozícii framebufferu v pamäti (štandardne 0x0AC0A000 pre nultý framebuffer) a formát pixelov. Framebuffery sú vytvorené aplikáciou RELEASE pri zapnutí TV. Nie je problém vytvoriť ďalšie framebuffery za behu zariadenia. Podporované formáty pixelov sa nachádzajú v súbore mhal_gop.h. Zariadenie je ovládane pomocou volaní ioctl. Ich zoznam sa dá nájsť v súbore mdrv_gop.h. Žiaľ nemám žiadne ďalšie zdroje informácií než zdrojové kódy, takže zatiaľ neviem napríklad povedať čo robí zaujímavo pomenované makro MDRV_GOP_IOC_ENABLE_CAPTURE_STREAM (samozrejme nájdu sa tam aj ďalšie zaujímavé kúsky).

Priame ovládanie framebufferu

Keď už zistiť adresu, na ktorej sa nachádza framebuffer a jeho formát nebude problémom napísať program, ktorý vie niečo vykresliť na framebuffer. Nasledujúci C program využíva zariadenie /dev/mem pre priamy prístup k pamäti. Zariadenie pracuje ako klasické blokové zariadenie a je možné ho namapovať do adresného priestoru aplikácie volaním mmap, čím sa zabráni náhodnému prepisu iných častí pamäte. Po spustení aplikácie sa celá vrstva OSD zaplní bielou farbou.

#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>

#define COLOR_WHITE 0xffffUL
#define FB_ADDR 0x0AC0A000UL
#define FB_SIZE 0x201000UL
#define FB_WIDTH 1368
#define FB_HEIGHT 768

static uint16_t *vfb;

inline void put_pixel(int x, int y, uint16_t pixel_value)
{
	vfb[FB_WIDTH * y + x] = pixel_value;
}

void draw_rectangle(int x1, int y1, int x2, int y2, uint16_t pixel_value)
{
	int x, y;
	for (y = y1; y < y2; ++y) {
		for (x = x1; x < x2; ++x) {
			put_pixel(x, y, pixel_value);
		}
	}
}

int main()
{
	int fd = open("/dev/mem", O_RDWR | O_SYNC);
	if (fd == -1) {
		return -1;
	}
	vfb = mmap(0, FB_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, FB_ADDR);
	if (vfb == MAP_FAILED) {
		close(fd);
		return -1;
	}
	draw_rectangle(0, 0, FB_WIDTH - 1, FB_HEIGHT - 1, COLOR_WHITE);
	munmap(vfb, FB_SIZE);
	close(fd);
	return 0;
}

Takýmto spôsobom sa dá naprogramovať napr. zobrazovanie 3D modelov cez framebuffer.

Zdrojové kódy, z ktorých som vychádzal pri písaní príkladov sú na tejto adrese.

Čo ďalej?

V mojich blogoch o TV som vysvetlil ako získať prístup k Linuxu v týchto TV prijímačoch a ukázal som ako používať niektoré nezdokumentované časti hardvéru. Napriek použitiu otvoreného softvéru nie je podpora pre hackovanie zo strany výrobcu práve najlepšia. Komunita ľudí vylepšujúcich firmvér je pomerne malá a bez zdrojových kódov RELEASE to asi tak aj zostane.

Nevidel som žiaden komunitný projekt nahradzujúci kompletne užívateľské rozhranie TV. Nepredpokladá, že by sa to s touto generáciou zariadení zmenilo. Projekty ako XBMC sú príliš pomalé na to, aby boli schopné bežať na procesore MIPS s nízkou frekvenciou bez akejkoľvek grafickej akcelerácie. Ja budem situáciu okolo LG naďalej sledovať a ak by sa niečo v tomto smere zmenilo budem o tom českú / slovenskú komunitu informovať.

       

Obrázky

Komentáře

[tired joe]

macgyver, vhodne zvolené :))

[kotyz]

Tenhle zápis si zaslouží tučňáka!

[coder]

+1 . Kvalitni blog.

[smazáno]

+1

[xkucf03]

Staniž se.

[=^..^= AmigaPower®]

Potřeboval bych hacknout svýho Rubína, pude to anténím vstupem? Jinej to nemá...

[mirec]

Samozrejme, ale bude k tomu potrebný senzomatický subéterový prijímač

[kotyz]

Tyhle starý herky se hackujou zásadně přes elektrickou zásuvku! Včera to někdo zkoušel na mě, v celym baráku blikaly světla, dokonce i v lednici...

[Radovan]

Přes anténu to nejde, musíš se nabourat přímo do zpožďovací linky

Tady je manpage: prijimac-pro-barevnou-televizi-rubin-401-1-habr-pavel-1973

[loki]

Nadherny blogpost, dik za nej. Tv s Linuxem si taky musim poridit

[mirec]

nz

Kúpiť TV s linuxom nebýva problém. Výrobcovia to síce neuvádzajú, ale mnoho modelov či už LG alebo Samsung je vybavených linuxom. Neviem ako je to u ostatných značiek, ale predpokladám, že podobne. Problém nastane až keď sa s tým človek chce hrať, nie každý výrobca poskytuje potrebné nástroje. Niekedy je potrebné sa výrobcovi vyhrážať právnikmi na to aby uvoľnil ich upravený GPL kód. Teraz mám doma napr. jeden kus OEM hardvéru, ktorý nemá softvér, ale mal by na tom bežať linux. Zákazníkom, ktorí kupujú 10 000+ dosiek poskytnú SDK (mimochodom trochu upravený kernel, kompilátor a pár open source knižníc), s ostatnými sa nemienia ani zaoberať. Nebyť uniknutého SDK stiahnutého z rapidsharu tak to ani nenabootujem.

[pc2005]

Projekty ako XBMC sú príliš pomalé na to, aby boli schopné bežať na procesore MIPS s nízkou frekvenciou bez akejkoľvek grafickej akcelerácie.

Zajímavý, že to divx HD dá.

[mirec]

Pozor, o dekódovanie videa sa stará špecializovaný obvod (GOP). Samotný procesor má asi 200MHz a nemá FPU. Vo videu (odkaz v perexe), kde renderujem 3D model je vidieť zhruba práce CPU s float pointmi (samotný algoritmus je celkom rýchly). Rýchlosť je okolo 1000 float point operácií za sekundu (pre porovnanie môj desktop má niekoľko miliárd fp operácií za sekundu so SIMD inštrukciami).

[pc2005]

Aha já bral tuhle vlastnost jako moc agresivní kvantifikátor.

bez akejkoľvek grafickej akcelerácie

A předpokládám, že ten GOP bude umět jen divx, že?

Rýchlosť je okolo 1000 float point operácií za sekundu

Safra to je ale hodně pomalý .

[mirec]

No kiež by som o tom obvode vedel viacej než časť zoznamu kódov, ktoré sa mu dajú poslať. Podľa servisného manuálu by sa mal nachádzať v puzdre s označením LGE3369A. Inak dekódovanie by malo fungovať podobne ako u raspberry pi. Mimochodom obraz aj zvuk sú schopné fungovať ďalej aj bez jadra (keď som zhodil jadro obraz a zvuk z tuneru fungovali stále bez problémov). Voliteľne však musí vedieť aj čítať z bufferu (prehrávanie z USB) a možno aj zaznamenávať do bufferu.