Czytanie bitmapy BMP

Odpowiedz Nowy wątek
2006-12-17 15:54
mj
0

Piszę program, który operuje na plikach binarnych. W tym przypadku program otwiera plik bitmapy w trybie "rb" (cyli binarnym). Pierw odcytuje nagłówek pliku oraz nagłówek obrazka. W ten sposób "wyciągam" wszystkie podstawowe i przydatne informacje. Z tym nie mam problemu.

Schody się zaczynjaą jak mam wyciągnąć dane obrazka (kolory konkretnego piksela). Zrobiłem to w ten sposób:


 for (int i = File.bfOffBits; i < File.bfSize;i++) {

      fseek(f,i,SEEK_SET);
      fread(&bmpImg, 1, 1, f);
      printf(" %d ",bmpImg); 

     }

Jak konkretnie wyciągnąć dane o obrazku tak abym miał każdy piksel oddzielnie??!! :-/

Pozostało 580 znaków

2006-12-17 16:46
0

tu

http://www.efg2.com/Lab/ImageProcessing/Scanline.htm

opis (pascal - ale to nie powinno stanowic problemu)
jak zapisywane sa pixele w roznych bitmapach(ilosc kolorow)

Najprostszy to 24bit R,G,B i kazdy jest typu bajt.

Przyklad w c++ (MFC, ale wczytywanie bez uzycia klas MFC)
http://rudy.mif.pg.gda.pl/~reichel/down.php?id=237


Pozostało 580 znaków

2006-12-17 18:46
0

Stwórz sobie tablicę unsigned char'ów o wielkości biSizeImage z bitmapInfoHeadera, ustaw się na pozycji bfOffBits i wczytaj dane do tablicy ;)


but there's no sense crying over every mistake
you just keep on trying till you run out of cake

Pozostało 580 znaków

2006-12-18 23:48
snake_king
0

możesz podać przykład wypełnienia

Pozostało 580 znaków

2006-12-19 00:14
mj
0

To jest cały mój kod w C:

#include<stdio.h>
#include<stdlib.h>

    struct FileHeader {
      short bfType;
      int bfSize;
      short bfReserved1;
      short bfReserved2;
      short bfOffBits;
    };
    FileHeader File;

    struct PictureHeader {
      int biSize;
      int biWidth;
      int biHeight;
      short biPlanes;
      short biBitCount;
      int biCompression;
      int biSizeImage;
      int biXPelsPerMeter;
      int biYPelsPerMeter;
      int biClrUsed;
      int biClrImportant;
     };
     PictureHeader Picture;

     struct KoloryRGB {
      char R;
      char G;
      char B;
     };
     KoloryRGB Rgb;
     char dane;

int main(int argc,char*argv[]) {
    FILE *f = fopen(argv[1],"rb");

     system("cls");
     printf("\n INFORMACJE O BITMAPIE\n\n");

     fread(&File.bfType,sizeof(File.bfType),1,f);
     printf(" Typ: %x",File.bfType); 

     fread(&File.bfSize,sizeof(File.bfSize),1,f);
     printf("\n Rozmiar pliku: %d bajtow",File.bfSize);

     fread(&File.bfReserved1,sizeof(File.bfReserved1),1,f);
     printf("\n Zarezerwowane1: %d",File.bfReserved1);

     fread(&File.bfReserved2,sizeof(File.bfReserved2),1,f);
     printf("\n Zarezerwowane2: %d",File.bfReserved2); 

     fread(&File.bfOffBits,sizeof(File.bfOffBits),1,f);
     printf("\n Pozycja danych obrazkowych: %d",File.bfOffBits);   

     printf("\n"); 

     fseek(f,14,SEEK_SET);
     fread(&Picture.biSize,sizeof(Picture.biSize),1,f);
     printf("\n Wielkosc naglowka informacyjnego: %d",Picture.biSize);   

     fread(&Picture.biWidth,sizeof(Picture.biWidth),1,f);
     printf("\n Szerokosc: %d pikseli",Picture.biWidth); 

     fread(&Picture.biHeight,sizeof(Picture.biHeight),1,f);
     printf("\n Wysokosc: %d pikseli",Picture.biHeight);   

     fread(&Picture.biPlanes,sizeof(Picture.biPlanes),1,f);
     printf("\n Liczba platow (zwykle 0): %d",Picture.biPlanes); 

     fread(&Picture.biBitCount,sizeof(Picture.biBitCount),1,f);
     printf("\n Liczba bitow na piksel: %d (1, 4, 8, or 24)",Picture.biBitCount);   

     fread(&Picture.biCompression,sizeof(Picture.biCompression),1,f);
     printf("\n Kompresja: %d (0=none, 1=RLE-8, 2=RLE-4)",Picture.biCompression); 

     fread(&Picture.biSizeImage,sizeof(Picture.biSizeImage),1,f);
     printf("\n Rozmiar samego rysunku: %d",Picture.biSizeImage); 

     fread(&Picture.biXPelsPerMeter,sizeof(Picture.biXPelsPerMeter),1,f);
     printf("\n Rozdzielczosc pozioma: %d",Picture.biXPelsPerMeter);     

     fread(&Picture.biYPelsPerMeter,sizeof(Picture.biYPelsPerMeter),1,f);
     printf("\n Rozdzielczosc pionowa: %d",Picture.biYPelsPerMeter);

     fread(&Picture.biClrUsed,sizeof(Picture.biClrUsed),1,f);
     printf("\n Liczba kolorow w palecie: %d",Picture.biClrUsed);

     fread(&Picture.biClrImportant,sizeof(Picture.biClrImportant),1,f);
     printf("\n Wazne kolory w palecie: %d",Picture.biClrImportant);

     //czyta dane obrazka
     printf("\n\n Dane obrazka:\n\n");
     fseek(f,File.bfOffBits,SEEK_SET);

     //czyt. danych bitmapy
     int bmpImg;

     for (int i = File.bfOffBits; i < File.bfSize;i++) {

      fseek(f,i,SEEK_SET);

      fread(&bmpImg, 1, 1, f);
      printf("%d \n",bmpImg);  

     }

     printf("\n");  
     fclose(f);

    return 0;
}

Testowałem na pliku graficznym 2px x 2px! 24bitowa Bitmapa -> 24 bity na jeden piksel! 3 bajty na 1 pixel(3 kolory) ale zawsze na końcu linii dodawany jest jeden bajt!

Pozostało 580 znaków

2007-04-23 09:25
0
Ghostek napisał(a)

Stwórz sobie tablicę unsigned char'ów o wielkości biSizeImage z bitmapInfoHeadera, ustaw się na pozycji bfOffBits i wczytaj dane do tablicy ;)

czyli zacząć czytać od bfOffBits a gdzie skończyć?? bo u mnie biSizeImage ma wartość 202806...

ja zrobiłem coś takiego żeby wyświetlić obrazek:

    for(int i=head_img.biHeight; i > 0 ; i--){
        for(int j=0; j < head_img.biWidth; j++){
            fread(&pixel, 2, 1, f);
        pdc->SetPixel(j, i, RGB(pixel.rgbBlue, pixel.rgbGreen, pixel.rgbRed));
        }
   }

ale niestety na obrazku nie ma składnych kolorów obrazek przypomina jakby to co powinno być ale jest jakby zalany na kolorowo
czy może mi ktoś powiedzieć gdzie jest mój błąd ??

Pozostało 580 znaków

2007-04-23 23:10
0
#include <painter/bmp.h>
#include <painter/memory.h>
#include <painter/error.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

/*==============================================================================
    Windows Bitmap File Format Implementation

    Actually compression is not supported.

    Supported color depths:
        1bpp - w/r
        4bpp - w/r
        8bpp - w/r
        16bpp - w/r
        24bpp - w/r
        32bpp - w/r

    During writing a pixmap with 2bpp or 15bpp it will be automatically written
    as 4bpp or 16bpp.   

==============================================================================*/

#define BMPID 0x4d42
#define BMPFILEHDR_SZ 14
#define BMPINFOHDR_SZ 40

/* File Header */
typedef struct BMPFILEHEADER {
    uint16_t type;
    uint32_t fileSize;
    uint16_t reserved0;
    uint16_t reserved1;
    uint32_t dataOffset;
} BMPFILEHEADER;

/* Info Header */
typedef struct BMPINFOHEADER {
    uint32_t hdrSize;
    uint32_t width;
    uint32_t height;
    uint16_t planes;
    uint16_t depth;
    uint32_t compression;
    uint32_t bmpDataSize;
    uint32_t hResolution;
    uint32_t vResolution;
    uint32_t nColors;
    uint32_t nImportantColors;
} BMPINFOHEADER;

/**
 * painterSaveBMP - Save bitmap to file.
 * @fileName - file name
 * @pixmap - pixmap
 * @palette - palette (used in indexed color mode - can be NULL)
 *
 * Return 0 if bitmap was saved properly, otherwise -1.  
 * Conversions:
 *      2 -> 4 bit,
 *      15 -> 16 bit.
 *
 */
int painterSaveBMP(const char *fileName, P_Pixmap *pixmap, P_Palette *pal)
{
    FILE *fileHandle = NULL;

    BMPFILEHEADER fileHdr;
    BMPINFOHEADER infoHdr;

    P_Palette tmppal;

    int i = 0;
    int depth = 0;

    uint8_t *scanLine = NULL;

    size_t rowSize = 0;
    size_t scanLineSize = 0;
    size_t dataSize = 0;
    size_t palSize = 0;

    uint8_t bSrc, bDest;
    size_t j, x;

    assert(fileName);
    assert(pixmap);

    memset(&fileHdr, 0, sizeof (fileHdr));
    memset(&infoHdr, 0, sizeof (infoHdr));

    memset(tmppal, 0, sizeof (tmppal));

    /* saved color depth */ 
    depth = pixmap->depth;
    if (depth == 2) depth = 4;
    else if (depth == 15) depth = 16;

    /* calculate size of a row */
    /* NOTE: rowSize might be not equal to pixmap->rowSize (ex: 2bpp) */
    rowSize = painterCalcRowSize(depth, pixmap->width); /* NOTE: custom */

    /* calculate size of a scan line and create buffer */
    scanLineSize = rowSize;
    if (scanLineSize % 4 != 0) 
        scanLineSize = ((scanLineSize>>2) + 1)<<2; /* 4 byte align */

    scanLine = (uint8_t *)painter_malloc(scanLineSize);
    if (!scanLine) {
        return -1;
    }

    /* calculate data size */
    dataSize = pixmap->height * scanLineSize;

    /* calculate size of the color map table */
    if (depth <= 8)
        palSize = (1<<depth)<<2;

    /* fill file header */
    fileHdr.type = BMPID;
    fileHdr.fileSize = BMPFILEHDR_SZ + BMPINFOHDR_SZ + palSize + dataSize;
    fileHdr.dataOffset = BMPFILEHDR_SZ + BMPINFOHDR_SZ + palSize;

    /* fill info header */
    infoHdr.hdrSize = BMPINFOHDR_SZ;
    infoHdr.width = pixmap->width;
    infoHdr.height = pixmap->height;
    infoHdr.planes = 1;
    infoHdr.depth = depth;
    infoHdr.compression = 0; /* uncompressed */
    infoHdr.bmpDataSize = dataSize;
    infoHdr.hResolution = 0;
    infoHdr.vResolution = 0;
    if (depth <= 8)
        infoHdr.nColors = infoHdr.nImportantColors = 1<<depth;

    /* open file and write header */
    fileHandle = fopen(fileName, "wb");
    if (!fileHandle) {
        painterThrowError(P_ERR_FILESYSTEM, "painterSaveBMP", "Cannot save bitmap to file - '%s'", fileName);
        return -1;
    }

    /* file header */
    fwrite(&fileHdr.type, 2, 1, fileHandle);
    fwrite(&fileHdr.fileSize, 4, 1, fileHandle);
    fwrite(&fileHdr.reserved0, 2, 1, fileHandle);
    fwrite(&fileHdr.reserved1, 2, 1, fileHandle);
    fwrite(&fileHdr.dataOffset, 4, 1, fileHandle);

    /* info header */
    fwrite(&infoHdr.hdrSize, 4, 1, fileHandle);
    fwrite(&infoHdr.width, 4, 1, fileHandle);
    fwrite(&infoHdr.height, 4, 1, fileHandle);
    fwrite(&infoHdr.planes, 2, 1, fileHandle);
    fwrite(&infoHdr.depth, 2, 1, fileHandle);
    fwrite(&infoHdr.compression, 4, 1, fileHandle);
    fwrite(&infoHdr.bmpDataSize, 4, 1, fileHandle);
    fwrite(&infoHdr.hResolution, 4, 1, fileHandle);
    fwrite(&infoHdr.vResolution, 4, 1, fileHandle);
    fwrite(&infoHdr.nColors, 4, 1, fileHandle);
    fwrite(&infoHdr.nImportantColors, 4, 1, fileHandle);

    /* write color map if needed */
    if (depth <= 8) {
        assert(pal);

        /* change RGB format to BGR */
        for (i = 0; i < (1<<depth); i++) {
            tmppal[i].r = (*pal)[i].b;
            tmppal[i].g = (*pal)[i].g;
            tmppal[i].b = (*pal)[i].r;
        }

        fwrite(tmppal, 4, 1<<depth, fileHandle);
    }

    /* write bitmap data */
    i = pixmap->height;
    while (i--) {

        /* clear aligning */
        scanLine[scanLineSize-1] = 0;
        scanLine[scanLineSize-2] = 0;
        scanLine[scanLineSize-3] = 0;
        scanLine[scanLineSize-4] = 0;

        /* copydata, change pixels order or color depth */
        switch (pixmap->depth) {

            case 1: { /* 12345678 -> 87654321 */
                j = pixmap->rowSize;
                while (j--) {
                    bSrc = pixmap->rows[i][j];
                    bDest = 0;

                    x = 8;
                    while (x--) {
                        if (bSrc & (1<<x))
                            bDest |= (1<<(7-x));
                    }

                    scanLine[j] = bDest;
                }
            } break;

            case 2: { /* 2bpp -> 4bpp */
                x = 0;
                for (j = 0; j < (unsigned)pixmap->width; j += 4) {
                    bSrc = pixmap->rows[i][j>>2];

                    scanLine[j>>1] = ((bSrc&0x3)<<4) | ((bSrc&0xc)>>2);
                    x += 2;
                    if (x+2 <= (unsigned)pixmap->width) {
                        scanLine[(j>>1)+1] = (bSrc&0x30) | ((bSrc&0xc0)>>6);
                    }
                }
            } break;

            case 4: { /* 12 -> 21 */
                j = pixmap->rowSize;
                while (j--) {
                    bSrc = pixmap->rows[i][j];
                    bDest = 0;

                    bDest = bSrc>>4;
                    bSrc <<= 4;
                    bSrc |= bDest;

                    scanLine[j] = bSrc;
                }
            } break;

            case 32: { /* RGBA -> ARGB */
                j = pixmap->width;
                while (j--) {
                    scanLine[(j<<2)] = pixmap->rows[i][(j<<2)+1] ;
                    scanLine[(j<<2)+1] = pixmap->rows[i][(j<<2)+2];
                    scanLine[(j<<2)+2] = pixmap->rows[i][(j<<2)+3];
                    scanLine[(j<<2)+3] = pixmap->rows[i][(j<<2)];
                }
            } break;

            default: {
                memcpy(scanLine, pixmap->rows[i], pixmap->rowSize);
            } break;

        }

        /* write scan line */
        fwrite(scanLine, 1, scanLineSize, fileHandle);
    }

    return 0;
}

/**
 * painterLoadBMP - Create new pixmap and load bitmap data
 * @fileName - file name
 * @pal - pointer to palette
 *
 * Return pointer to new pixmap or NULL if error.
 */
P_Pixmap *painterLoadBMP(const char *fileName, P_Palette *pal)
{
    P_Pixmap *pixmap = NULL;

    FILE *fileHandle = NULL;

    BMPFILEHEADER fileHdr;
    BMPINFOHEADER infoHdr;

    P_Palette tmppal;

    uint8_t *scanLine = NULL;
    size_t scanLineSize = 0;
    size_t rowSize = 0;

    int i = 0;
    uint8_t bSrc, bDest;
    size_t j, x;

    assert(fileName);

    memset(&fileHdr, 0, sizeof (fileHdr));
    memset(&infoHdr, 0, sizeof (infoHdr));

    fileHandle = fopen(fileName, "rb+");
    if (!fileHandle) {
        painterThrowError(P_ERR_FILESYSTEM, "painterLoadBMP", "Cannot load bitmap from file - '%s'", fileName);
        return NULL;
    }

    /* read and verify file header */
    fread(&fileHdr.type, 2, 1, fileHandle);
    fread(&fileHdr.fileSize, 4, 1, fileHandle);
    fread(&fileHdr.reserved0, 2, 1, fileHandle);
    fread(&fileHdr.reserved1, 2, 1, fileHandle);
    fread(&fileHdr.dataOffset, 4, 1, fileHandle);

    if (fileHdr.type != BMPID) {
        fclose(fileHandle);
        painterThrowError(P_ERR_BMP_INVALIDHEADER, "painterLoadBMP", "Invalid file type - '%s'", fileName);
        return NULL;
    }

    /* read info header */
    fread(&infoHdr.hdrSize, 4, 1, fileHandle);
    fread(&infoHdr.width, 4, 1, fileHandle);
    fread(&infoHdr.height, 4, 1, fileHandle);
    fread(&infoHdr.planes, 2, 1, fileHandle);
    fread(&infoHdr.depth, 2, 1, fileHandle);
    fread(&infoHdr.compression, 4, 1, fileHandle);
    fread(&infoHdr.bmpDataSize, 4, 1, fileHandle);
    fread(&infoHdr.hResolution, 4, 1, fileHandle);
    fread(&infoHdr.vResolution, 4, 1, fileHandle);
    fread(&infoHdr.nColors, 4, 1, fileHandle);
    fread(&infoHdr.nImportantColors, 4, 1, fileHandle);

    /* debug */
    /*
    printf("type=%u\n", fileHdr.type);
    printf("fileSize=%u\n", fileHdr.fileSize);
    printf("dataOffset=%u\n", fileHdr.dataOffset);
    printf("hdrSize=%u\n", infoHdr.hdrSize);
    printf("width=%u\n", infoHdr.width);
    printf("height=%u\n", infoHdr.height);
    printf("planes=%u\n", infoHdr.planes);
    printf("depth=%u\n", infoHdr.depth);
    printf("compression=%u\n", infoHdr.compression);
    printf("bmpDataSize=%u\n", infoHdr.bmpDataSize);
    printf("hResolution=%u\n", infoHdr.hResolution);
    printf("vResolution=%u\n", infoHdr.vResolution);
    printf("nColors=%u\n", infoHdr.nColors);
    printf("nImportantColors=%u\n", infoHdr.nImportantColors);
    */

    /* check colour depth */
    if (infoHdr.depth != 1 && infoHdr.depth != 4 && 
        infoHdr.depth != 8 && infoHdr.depth != 16 &&
        infoHdr.depth != 24 && infoHdr.depth != 32) {
        fclose(fileHandle);
        painterThrowError(P_ERR_BMP_UNSUPPORTED, "painterLoadBMP", "Unsupported color depth - %ubpp", infoHdr.depth);
        return NULL;
    }

    /* compression support */
    if (infoHdr.compression != 0) {
        fclose(fileHandle);
        painterThrowError(P_ERR_BMP_UNSUPPORTED, "painterLoadBMP", "Compression is not supported");
        return NULL;
    }

    /* read color map */
    if (infoHdr.depth <= 8) {
        assert(pal);

        /*fseek(fileHandle, 14 + infoHdr.hdrSize, SEEK_SET);*/
        fread(tmppal, 4, 1<<infoHdr.depth, fileHandle);

        /* move data and change BGR format to RGB */
        for (i = 0; i < (1<<infoHdr.depth); i++) {
            (*pal)[i].r = tmppal[i].b;
            (*pal)[i].g = tmppal[i].g;
            (*pal)[i].b = tmppal[i].r;
            (*pal)[i].a = 0;
        }
    }

    /* calculate size of each row in bytes */
    rowSize = painterCalcRowSize(infoHdr.depth, infoHdr.width);

    /* create scan line buffer */
    scanLineSize = rowSize;
    if (scanLineSize % 4 != 0) 
        scanLineSize = ((scanLineSize>>2) + 1)<<2; /* 4 byte align */
    scanLine = (uint8_t *)painter_malloc(scanLineSize);
    if (!scanLine) {
        fclose(fileHandle);
        return NULL;
    }

    /* debug */
    /*
    printf("rowSize=%u\n", rowSize);
    printf("scanLineSize=%u\n", scanLineSize);  
    */

    /* create new pixmap */
    pixmap = painterCreatePixmap(infoHdr.width, infoHdr.height, infoHdr.depth);
    if (!pixmap) {
        fclose(fileHandle);
        return NULL;    
    }

    /* read bitmap data */
    /*
    fseek(fileHandle, 14 + infoHdr.hdrSize, SEEK_SET);
    if (infoHdr.depth <= 8)
        fseek(fileHandle, (1<<infoHdr.depth)<<2, SEEK_CUR);
    */

    i = infoHdr.height;
    while (i--) {
        fread(scanLine, 1, scanLineSize, fileHandle);

        /* copy data, change pixels order */
        switch (infoHdr.depth) {

            case 1: { /* 87654321 -> 12345678 */
                j = rowSize;
                while (j--) {
                    bSrc = scanLine[j];
                    bDest = 0;

                    x = 8;
                    while (x--) {
                        if (bSrc & (1<<x))
                            bDest |= (1<<(7-x));
                    }

                    pixmap->rows[i][j] = bDest;
                }
            } break;

            case 4: { /* 21 -> 12 */
                j = rowSize;
                while (j--) {
                    bSrc = scanLine[j];
                    bDest = 0;

                    bDest = bSrc>>4;
                    bSrc <<= 4;
                    bSrc |= bDest;

                    pixmap->rows[i][j] = bSrc;
                }
            } break;                

            case 32: { /* RGBA -> ARGB */
                j = pixmap->width;
                while (j--) {
                    pixmap->rows[i][(j<<2)] = scanLine[(j<<2)+1];
                    pixmap->rows[i][(j<<2)+1] = scanLine[(j<<2)+2];
                    pixmap->rows[i][(j<<2)+2] = scanLine[(j<<2)+3];
                    pixmap->rows[i][(j<<2)+3] = scanLine[(j<<2)];
                }
            } break;

            default: {
                memcpy(pixmap->rows[i], scanLine, rowSize);
            } break;

        }

    }

    fclose(fileHandle);

    return pixmap;
}

mj: na koncu nie ma jednego bajta tylko jest wyrownywanie do wielokrotnosci 4 bajtow dla kazdego wiersza...


Pozostało 580 znaków

2007-04-23 23:16
0

a moze by tak kolosy privem albo jako zalacznik wysylac..


no to pojechałem z nieobecnością.. chwila przerwy i prawie rok przeleciał

Pozostało 580 znaków

2007-04-24 11:18
0

OMG:

        fread(&infoHdr.hdrSize, 4, 1, fileHandle);
        fread(&infoHdr.width, 4, 1, fileHandle);
        fread(&infoHdr.height, 4, 1, fileHandle);
        fread(&infoHdr.planes, 2, 1, fileHandle);
        fread(&infoHdr.depth, 2, 1, fileHandle);
        fread(&infoHdr.compression, 4, 1, fileHandle);
        fread(&infoHdr.bmpDataSize, 4, 1, fileHandle);
        fread(&infoHdr.hResolution, 4, 1, fileHandle);
        fread(&infoHdr.vResolution, 4, 1, fileHandle);
        fread(&infoHdr.nColors, 4, 1, fileHandle);
        fread(&infoHdr.nImportantColors, 4, 1, fileHandle);

Bozia nie dała możliwości wczytywania struktur?
Src mojej zabawki - w asm - do przetwarzania bitmap ma mniej linii :|


I nie udawaj, że rozumiesz.

Pozostało 580 znaków

2007-04-24 13:48
0
deus napisał(a)

OMG:

fread(&infoHdr.hdrSize, 4, 1, fileHandle);
fread(&infoHdr.width, 4, 1, fileHandle);
fread(&infoHdr.height, 4, 1, fileHandle);
fread(&infoHdr.planes, 2, 1, fileHandle);
fread(&infoHdr.depth, 2, 1, fileHandle);
fread(&infoHdr.compression, 4, 1, fileHandle);
fread(&infoHdr.bmpDataSize, 4, 1, fileHandle);
fread(&infoHdr.hResolution, 4, 1, fileHandle);
fread(&infoHdr.vResolution, 4, 1, fileHandle);
fread(&infoHdr.nColors, 4, 1, fileHandle);
fread(&infoHdr.nImportantColors, 4, 1, fileHandle);

Bozia nie dała możliwości wczytywania struktur?
Src mojej zabawki - w asm - do przetwarzania bitmap ma mniej linii :|

a o align'ingu Kolega slyszal :-P sie czasem nie zdziw jak to co wczytasz nie bedzie tam gdzie powinno byc [diabel]


Pozostało 580 znaków

2007-04-24 14:43
0

Jasne, że słyszał... ale jeszcze nigdy nie miałem z tym problemów, nawet przy bardziej złożonych strukturach... w ostateczności jest
#pragma pack(1)


I nie udawaj, że rozumiesz.

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0