Byla vydána verze 1.91.0 programovacího jazyka Rust (Wikipedie). Podrobnosti v poznámkách k vydání. Vyzkoušet Rust lze například na stránce Rust by Example.
Ministerstvo průmyslu a obchodu vyhlásilo druhou veřejnou soutěž v programu TWIST, který podporuje výzkum, vývoj a využití umělé inteligence v podnikání. Firmy mohou získat až 30 milionů korun na jeden projekt zaměřený na nové produkty či inovaci podnikových procesů. Návrhy projektů lze podávat od 31. října do 17. prosince 2025. Celková alokace výzvy činí 800 milionů korun.
Google v srpnu oznámil, že na „certifikovaných“ zařízeních s Androidem omezí instalaci aplikací (včetně „sideloadingu“) tak, že bude vyžadovat, aby aplikace byly podepsány centrálně registrovanými vývojáři s ověřenou identitou. Iniciativa Keep Android Open se to snaží zvrátit. Podepsat lze otevřený dopis adresovaný Googlu nebo petici na Change.org.
Byla vydána nová verze 18 integrovaného vývojového prostředí (IDE) Qt Creator. S podporou Development Containers. Podrobný přehled novinek v changelogu.
Cursor (Wikipedie) od společnosti Anysphere byl vydán ve verzi 2.0. Jedná se o multiplatformní proprietární editor kódů s podporou AI (vibe coding).
Google Chrome 142 byl prohlášen za stabilní. Nejnovější stabilní verze 142.0.7444.59 přináší řadu novinek z hlediska uživatelů i vývojářů. Podrobný přehled v poznámkách k vydání. Opraveno bylo 20 bezpečnostních chyb. Za nejvážnější z nich bylo vyplaceno 50 000 dolarů. Vylepšeny byly také nástroje pro vývojáře.
Pro moddery Minecraftu: Java edice Minecraftu bude bez obfuskace.
Národní identitní autorita, tedy NIA ID, MeG a eOP jsou nedostupné. Na nápravě se pracuje [𝕏].
Americký výrobce čipů Nvidia se stal první firmou na světě, jejíž tržní hodnota dosáhla pěti bilionů USD (104,5 bilionu Kč). Nvidia stojí v čele světového trhu s čipy pro umělou inteligenci (AI) a výrazně těží z prudkého růstu zájmu o tuto technologii. Nvidia již byla první firmou, která překonala hranici čtyř bilionů USD, a to letos v červenci.
Po Canonicalu a SUSE oznámil také Red Hat, že bude podporovat a distribuovat toolkit NVIDIA CUDA (Wikipedie).
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
koukni na imlib2
 26.2.2016 11:23
Jendа             | skóre: 78
             | blog: Jenda
             | JO70FB
        26.2.2016 11:23
Jendа             | skóre: 78
             | blog: Jenda
             | JO70FB
        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
#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;
}
            To je super, zacina mi to pozvolna "tapat", z ceho to je vykostene (pokud z neceho vetsiho) ?
Marecek
        Tiskni
            
                Sdílej:
                 
                 
                 
                 
                 
                