abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×
dnes 22:00 | Komunita

Portál Stack Overflow po roce opět vyzpovídal své uživatele, jedná se především o vývojáře softwaru, a zveřejnil (podcast) detailní výsledky průzkumu. Průzkumu se letos zúčastnilo více než 64 tisíc vývojářů. Jejich nejmilovanější platformou je linuxový desktop. Ten je také druhou nejpoužívanější platformou vývojářů.

Ladislav Hagara | Komentářů: 0
včera 11:55 | Komunita

Vývojový tým OpenSSL ve spolupráci s iniciativou Core Infrastructure konsorcia Linux Foundation spustil proces přelicencování této kryptografické knihovny ze současné licence na licenci Apache Licence v 2.0 (ASLv2). Nová licence usnadní začleňování OpenSSL do dalších svobodných a open source projektů. Všichni dosavadní vývojáři OpenSSL (Authors) obdrží v následujících dnech email s prosbou o souhlas se změnou licence.

Ladislav Hagara | Komentářů: 7
včera 01:11 | Komunita

Před třemi týdny Mozilla.cz představila projekt Photon, jehož cílem je návrh a implementace nového vzhledu Firefoxu. Včera zveřejnila první náhled vzhledu Photon. Práce na projektu Photon jsou rozděleny do pěti týmů, které celkem čítají 19 lidí. Zaměřují se na zlepšení prvního spuštění Firefoxu a zaujetí nových uživatelů, celkovou úpravu vzhledu, zlepšení animací, zrychlení odezvy uživatelského rozhraní a také upravení nabídek. Vývoj lze sledovat v Bugzille.

Ladislav Hagara | Komentářů: 36
23.3. 20:00 | Komunita

OneDrive pro firmy je již ve webových prohlížečích na Linuxu stejně rychlý jako na Windows. Microsoft opravil chybu z listopadu loňského roku. OneDrive pro firmy běžel na Linuxu mnohem pomaleji než na Windows. V popisu chyby bylo uvedeno, že stačilo v prohlížeči na Linuxu nastavit v user-agentu Windows a vše se zrychlilo. Odpovědí Microsoftu bylo (Internet Archive: Wayback Machine), že Linux není podporován. Po bouřlivých diskusích na redditu i Hacker News byla chyba nalezena a opravena.

Ladislav Hagara | Komentářů: 6
23.3. 19:00 | Zajímavý projekt

Byla vyhlášena soutěž Hackaday Prize 2017. Soutěž je určena vývojářům open source hardwaru. Pro výherce je připraveno celkově 250 tisíc dolarů. Každý ze 120 finalistů získá tisíc dolarů. Nejlepší pak navíc 50, 30, 20, 15, 10 a 5 tisíc dolarů. Jedná se již o čtvrtý ročník soutěže. V roce 2014 zvítězil projekt globální sítě open source pozemních satelitních stanic SatNOGS. V roce 2015 zvítězil open source systém pro řízení elektrických invalidních vozíků pohybem očí Eyedriveomatic. V roce 2016 zvítězil modulární robot Dtto.

Ladislav Hagara | Komentářů: 0
23.3. 15:00 | Bezpečnostní upozornění

Byla vydána Samba ve verzích 4.6.1, 4.5.7 a 4.4.12. Řešen je bezpečnostní problém CVE-2017-2619. Pomocí symbolických odkazů a souběhu (symlink race) lze "teoreticky" získat přístup k souborům, které nejsou sdíleny. Linuxové distribuce jsou postupně aktualizovány (Debian).

Ladislav Hagara | Komentářů: 0
23.3. 07:43 | Nová verze

Na Steamu se objevil port hry Arma: Cold War Assault (Operation Flashpoint) pro Mac a Linux. … více »

creon | Komentářů: 30
23.3. 05:55 | Nová verze

Po 18 měsících od vydání verze 8.0 byla vydána verze 9.0 open source alternativy GitHubu, tj. softwarového nástroje s webovým rozhraním umožňujícího spolupráci na zdrojových kódech, GitLab. Představení nových vlastností v příspěvku na blogu a na YouTube.

Ladislav Hagara | Komentářů: 0
23.3. 03:33 | Komunita

Platnost posledního patentu souvisejícího s Dolby Digital (AC-3) vypršela. Po MP3 se tak do Fedory oficiálně dostane také kodek AC-3.

Ladislav Hagara | Komentářů: 5
23.3. 00:44 | Komunita

Feral Interactive, společnost zabývající se vydáváním počítačových her pro operační systémy macOS a Linux, nabízí své hry na Steamu vývojářům open source 3D grafické knihovny Mesa zdarma. Podmínkou je minimálně 25 commitů za posledních 5 let. Stejnou nabídku dostali vývojáři knihovny Mesa v roce 2015 od Valve. O rok dříve dostali od Valve tuto nabídku vývojáři Debianu a Ubuntu.

Ladislav Hagara | Komentářů: 0
Jak se stavíte k trendu ztenčování přenosných zařízení (smartphony, notebooky)?
 (14%)
 (2%)
 (72%)
 (3%)
 (10%)
Celkem 931 hlasů
 Komentářů: 72, poslední 1.3. 11:16
    Rozcestník

    Dotaz: Screenshot obrazovky C/C++

    25.2.2016 22:09 Marecek
    Screenshot obrazovky C/C++
    Přečteno: 830×

    Ahoj, potreboval bych pomoct navect na smer, chtel bych pod linuxem delat screenshot obrazovky v C/C++ a presnaset to po siti na druhy stroj, presnos po LAN uz mam vyresen (klient-server) pres sockety v C, je to tedy dost pracne, ale funguje to. (pokud by nekdo dal tip i na nejake knihovny co usnadnuji praci se sockety nebudu se zlobit), ted mi vrta hlavou jak udelat ten screenshot, treba ho delat 5x za sekundu.

    Dekuji. Marecek

    Odpovědi

    25.2.2016 22:44 mimi.vx | skóre: 37 | blog: Mimi.VX | Praha
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++

    koukni na imlib2

    USE="-gnome -kde";turris
    27.2.2016 12:34 Marecek
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++

    Diky, docela zajimava knihovna.

    Jendа avatar 26.2.2016 11:23 Jendа | skóre: 73 | blog: Výlevníček | JO70FB
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    Co na to spustit externí program (scrot, import, …) a nechat si data vypsat v nějakém hezkém formátu (PPM) na jeho stdout?
    Nezapomeňte si příští víkend posunout časovače na svých bombách o hodinu dopředu!
    26.2.2016 19:29 Jardík
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    xcb_connect, pak xcb_get_setup, tam najdeš screen a id 'root' okna, jeho velikost a jeho visual (což je něco jako jaká je barevná hloubka a formát dat. Pak přes SHM utvoříš blok paměti a pošleš xkám request na kopii okna to tý bitmapy. Až to udělá, pošle ti info, že je hotovo, a můžeš to poslat přes socket.
    27.2.2016 12:36 Marecek
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++

    Joo, to by mohlo byt ono, prostuduji to.

    Ja zacal studovat nejaky opensource grabber obrazovaky, ale je to prilis mnoho kodu nez izoluji to co hledam.

    Dekuji. M

    27.2.2016 20:45 Jardík
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    Není to dokonalé, možná tam chybí někde chybové kontroly, možná je tam někde memory leak, ale nechtělo se mi s tím dělat moc dlouho. V komentáři je označeno místo, kde zpracovat výsledná data.
    #include <assert.h>
    #include <errno.h>
    #include <limits.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <xcb/xcb.h>
    #include <xcb/shm.h>
    
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    #include <sys/ipc.h>
    #include <sys/shm.h>
    
    
    enum {
        SCR_ERR_OK,
        SCR_ERR_CONNECTION_FAIL,
        SCR_ERR_CONNECTION_ERR,
        SCR_ERR_INVALID_SCREEN,
        SCR_ERR_SHM_NOT_SUPPORTED,
        SCR_ERR_INVALID_VISUAL,
        SCR_ERR_INVALID_PIXMAP_FORMAT,
        SCR_ERR_UNSUPPORTED_VISUAL,
        SCR_ERR_IMAGE_EMPTY,
        SCR_ERR_IMAGE_TOO_LARGE,
        
        SCR_ERR_SHMGET_FAILED,
        SCR_ERR_SHM_ATTACH_FAILED,
        SCR_ERR_GET_IMAGE_FAILED,
        SCR_ERR_GET_IMAGE_RACE_CONDITION
    };
    
    struct screenshoter
    {
        xcb_connection_t *con;
        xcb_setup_t const *setup;
        xcb_screen_t *screen;
        int screen_num;
    
        xcb_depth_t const* depth;
        xcb_visualtype_t const* visual;
        xcb_format_t const* pixformat;
    
        xcb_query_extension_reply_t const* shm_ext;
    
        xcb_shm_seg_t shm_seg;
    
        struct {
            unsigned char *data;
            size_t stride, size;
        } image;
    };
    
    int receive_screenshot(struct screenshoter *scr)
    {
        xcb_shm_get_image_cookie_t img_ck = xcb_shm_get_image(scr->con, scr->screen->root,
                0, 0, scr->screen->width_in_pixels, scr->screen->height_in_pixels,
                UINT32_MAX, XCB_IMAGE_FORMAT_XY_PIXMAP, scr->shm_seg, 0);
        xcb_generic_error_t *err = NULL;
        xcb_shm_get_image_reply_t *img_rep = xcb_shm_get_image_reply(scr->con, img_ck, &err);
        if (!img_rep) {
            if (err) free(err);
            return SCR_ERR_GET_IMAGE_FAILED;
        }
    
        if (img_rep->size != scr->image.size ||
                img_rep->visual != scr->screen->root_visual ||
                img_rep->depth != scr->depth->depth)
        {
            free(img_rep);
            return SCR_ERR_GET_IMAGE_RACE_CONDITION;
        }
    
        free(img_rep);
        return 0;
    }
    
    int create_shm_seg_and_image(struct screenshoter *scr)
    {
        // check if sreen has non-zero dimensions
        if (scr->screen->width_in_pixels == 0 ||
                scr->screen->height_in_pixels == 0)
            return SCR_ERR_IMAGE_EMPTY;
    
        // XCB doesn't run on platforms with non-8bit char, so char is 8bits
        // We only support depth, bits_per_pixel and scanline_pad that is multiple
        // of whole bytes
        //
        // NOTE: shm extension seems to return packed image data, bits_per_pixel and scanline_pad
        //       are not used
        if (scr->depth->depth % 8 != 0)
            return SCR_ERR_UNSUPPORTED_VISUAL;
    
        size_t bytes_per_pixel = scr->depth->depth / 8;
    
        // Calculate stride, first multiply width by bytes_per_pixel
        size_t stride = scr->screen->width_in_pixels;
        if (SIZE_MAX / stride < bytes_per_pixel)
            return SCR_ERR_IMAGE_TOO_LARGE;
        stride *= bytes_per_pixel;
    
        // now multiply by height, to get image size in bytes
        scr->image.stride = stride;
        if (SIZE_MAX / stride < scr->screen->height_in_pixels)
            return SCR_ERR_IMAGE_TOO_LARGE;
        scr->image.size = stride * scr->screen->height_in_pixels;
    
        int shmid = shmget(IPC_PRIVATE, scr->image.size, IPC_CREAT | 0777);
        if (shmid == -1)
            return SCR_ERR_SHMGET_FAILED;
    
        scr->image.data = shmat(shmid, NULL, 0);
        if (scr->image.data == (void*)-1) {
            shmctl(shmid, IPC_RMID, NULL);
            return SCR_ERR_SHM_ATTACH_FAILED;
        }
    
        // Generate shm segment id
        scr->shm_seg = xcb_generate_id(scr->con);
        // attach our file to it, use checked call so we can block for reply
        xcb_void_cookie_t attach_ck = xcb_shm_attach_checked(scr->con,
                scr->shm_seg, shmid, 0);
        // wait for reply
        xcb_generic_error_t *attach_err = xcb_request_check(scr->con, attach_ck);
        // we don't need shmid anymore after the request was processed by X
        shmctl(shmid, IPC_RMID, NULL);
        // check attach error
        if (attach_err) {
            free(attach_err);
            shmdt(scr->image.data);
            return SCR_ERR_SHM_ATTACH_FAILED;
        }
    
        return 0;
    }
    
    void free_shm_seg_and_image(struct screenshoter *scr)
    {
        xcb_shm_detach(scr->con, scr->shm_seg);
        shmdt(scr->image.data);
    }
    
    int find_default_screen(struct screenshoter *scr)
    {
        if (scr->screen_num < 0)
            return SCR_ERR_INVALID_SCREEN;
        
        xcb_screen_iterator_t iter = xcb_setup_roots_iterator(scr->setup);
        for (int i = 0; i < scr->screen_num; ++i) {
            if (iter.rem == 0)
                return SCR_ERR_INVALID_SCREEN;
            xcb_screen_next(&iter);
        }
        scr->screen = iter.data;
        return 0;
    }
    
    int detect_root_visual(struct screenshoter *scr)
    {
        xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(scr->screen);
        for (;;) {
            xcb_depth_t const *depth = depth_iter.data;
            int visuals_len = xcb_depth_visuals_length(depth);
            if (visuals_len <= 0)
                break;
            xcb_visualtype_t const *visuals = xcb_depth_visuals(depth);
    
            for (int i = 0; i < visuals_len; ++i) {
                if (visuals[i].visual_id == scr->screen->root_visual) {
                    scr->depth = depth;
                    scr->visual = &visuals[i];
                    return 0;
                }
            }
    
            if (depth_iter.rem == 0)
                break;
            xcb_depth_next(&depth_iter);
        }
    
        return SCR_ERR_INVALID_VISUAL;
    }
    
    int detect_pixmap_format(struct screenshoter *scr)
    {
        int formats_len = xcb_setup_pixmap_formats_length(scr->setup);
        if (formats_len > 0) {
            xcb_format_t const *formats = xcb_setup_pixmap_formats(scr->setup);
            for (int i = 0; i < formats_len; ++i) {
                if (formats[i].depth == scr->depth->depth) {
                    scr->pixformat = &formats[i];
                    return 0;
                }
            }
        }
        return SCR_ERR_INVALID_PIXMAP_FORMAT;
    }
    
    int get_screenshot(void)
    {
        struct screenshoter scr;
        int err = 0;
    
        // connect
        scr.con = xcb_connect(NULL, &scr.screen_num);
        if (!scr.con)
            return SCR_ERR_CONNECTION_FAIL;
    
        // check errors
        if (xcb_connection_has_error(scr.con)) {
            err = SCR_ERR_CONNECTION_ERR;
            goto retDisconnect;
        }
    
        // get setup and prefetch shm extension
        scr.setup = xcb_get_setup(scr.con);
        xcb_prefetch_extension_data(scr.con, &xcb_shm_id);
        xcb_flush(scr.con);
    
        // find screen
        err = find_default_screen(&scr);
        if (err != 0)
            goto retDisconnect;
    
        // detect visual
        err = detect_root_visual(&scr);
        if (err != 0)
            goto retDisconnect;
    
        // and pixmap format for root depth
        err = detect_pixmap_format(&scr);
        if (err != 0)
            goto retDisconnect;
    
        // get shm extension
        scr.shm_ext = xcb_get_extension_data(scr.con, &xcb_shm_id);
        if (!scr.shm_ext->present) {
            err = SCR_ERR_SHM_NOT_SUPPORTED;
            goto retDisconnect;
        }
    
        // create shm segment
        err = create_shm_seg_and_image(&scr);
        if (err != 0)
            goto retDisconnect;
    
        err = receive_screenshot(&scr);
        if (err == 0) {
            // TODO: process image data here
    
            // Image data is in scr.image.data, its bytesize is in scr.image.size,
            // its stride bytesize is in scr.image.stride, its width is in
            // scr.screen->width_in_pixels, height in scr.screen->height_in_pixels,
            // depth (in bits) is in scr.depth->depth. Visual format is in
            // scr.visual (red_mask, green_mask, blue_mask). Image data byteorder is
            // in scr.setup->image_byte_order
        }
    
        free_shm_seg_and_image(&scr);
        xcb_flush(scr.con);
    retDisconnect:
        xcb_disconnect(scr.con);
        return err;
    }
    
    
    int main()
    {
        int err = get_screenshot();
        fprintf(stderr, "err = %d\n", err);
    
        return 0;
    }
    
    
    1.3.2016 12:13 Marecek
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++

    To je super, zacina mi to pozvolna "tapat", z ceho to je vykostene (pokud z neceho vetsiho) ?

    Marecek

    2.3.2016 12:19 Jardík
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    Né, napsal jsem to sám podle dokumentace k xcb. Je to v public domain, můžeš si s tém dělat, co chceš.
    2.3.2016 12:24 Jardík
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    Jinak komentáře jsou občas mimo, já to pak editoval a nějaké jsem nezměnil. Třeba místo shmget() jsem tam měl memfd_create(), ale pak jsem zjistil, že je to docela nový syscall a že ani není wrapper v glibc, co je v ubuntu 15.10 no tomhle pc, tak jsem to na poslední chvíli měnil a snad nenasekal moc chyb.
    2.3.2016 22:03 jkkjflsj
    Rozbalit Rozbalit vše Re: Screenshot obrazovky C/C++
    Nejsem si úplně jistý, jak moc je myšlena otázka vážně, případně jak moc vážně jsou myšlené odpovědi. Nicméně snadné řešení jak screnshotů tak socketů poskytuje kde jaká knihovna. Mě osobně se pohodlně pracuje s wxWidgets.

    Pokud mermomocí vyžadujete jen tu nejzákladnější (xlib), pak mě příjde odpověď How do take a screenshot correctly with xlib? vyčerpávající. Člověk může být akorát na rozpacích z formátu do kterého se obrázek ukládá.

    Založit nové vláknoNahoru

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.