[C] bit shit

[trallallero]

Ho qualche dubbio sullo shift del C

ho un buffer di 128*128 bit, ogni bit corrisponde ad una casella di una matrice 128*128

Devo leggere il buffer e, per ogni bit, se 1 setto la relativa casella della matrice a 1 altrimenti a 0.

Il buffer è unsigned char.

Qual'è il sistema piú efficace ?

grazie

[mad_hhatter]

Ho qualche dubbio sullo shift del C

ho un buffer di 128*128 bit, ogni bit corrisponde ad una casella di una matrice 128*128

Devo leggere il buffer e, per ogni bit, se 1 setto la relativa casella della matrice a 1 altrimenti a 0.

Il buffer è unsigned char.

Qual'è il sistema piú efficace ?

grazie

ti conviene fare buf[i][j] && 0x<val> == 0 per testare se in una certa posizione c'è 1 o 0... <val> è tale che la sua rappresentazione binaria contenga tutti 0 tranne un 1 nella posizione desiderata.

spero di aver capito cosa ti serviva, ma non ho capito perchè parlavi di shift...

comunque il titolo mi ha fatto morire dal ridere :D

[marko.fatto]

Certo che ti stan proprio sulle balle sti bit:sbonk:

[trallallero]

ti conviene fare buf[i][j] && 0x<val> == 0 per testare se in una certa posizione c'è 1 o 0... <val> è tale che la sua rappresentazione binaria contenga tutti 0 tranne un 1 nella posizione desiderata.

spero di aver capito cosa ti serviva, ma non ho capito perchè parlavi di shift...

comunque il titolo mi ha fatto morire dal ridere :D

Certo che ti stan proprio sulle balle sti bit:sbonk:

ops :stordita:
vabbè, lapsus, stavo smadonnando :D

buf[i][j] non va bene perchè il buffer è un array

[mad_hhatter]

ops :stordita:
vabbè, lapsus, stavo smadonnando :D

buf[i][j] non va bene perchè il buffer è un array

allora leggi buf[i] e scrivi matrice[i / 128][i % 128] dove la divisione è intera!!

[trallallero]

allora leggi buf[i] e scrivi matrice[i / 128][i % 128] dove la divisione è intera!!

eh ?

in buf[i] ci sono 8 bits, ognuno corrisponde ad una casella della matrice

[mad_hhatter]

eh ?

in buf[i] ci sono 8 bits, ognuno corrisponde ad una casella della matrice

hai ragione, ho scritto la classica stronzata

[Furla]

fammi capire la struttura dati sarebbe unsigned char[128][16]? (16*8=128)
oppure un array su una sola dimensione: unsigned char[2048]? ((128/8)*128=2048)

[trallallero]

allora, spiego meglio e poi posto quello che sto facendo.

Ho un buffer unsigned char lungo 2048 bits.
Il primo bit corrisponde alla casella [0][0] della matrice, il secondo alla [0][1] etc etc. Quindi devo leggere tutti i bits, uno dopo l'altro ed assegnare 1 oppure 0 alla relativa casella

[trallallero]

hai ragione, ho scritto la classica stronzata

non l'ho detto io (ma l'ho pensato) :D

ma è normale, uno pensa di sapere ste cose ma non le usa mai, una volta che le devi scrivere diventa un casino. E non trovo esempi in rete

[mad_hhatter]

leggi buf[i], poi per j che va da 0 a 7 testi il bit j-esimo in buf[i] e scrivi in matrice[i * 8 / 128][(i * 8 % 128) + j]

spero di non aver detto altre cazzate

[mad_hhatter]

non l'ho detto io (ma l'ho pensato) :D

ma è normale, uno pensa di sapere ste cose ma non le usa mai, una volta che le devi scrivere diventa un casino. E non trovo esempi in rete

caspita, so leggere nel pensiero !!!!!!!!! :D

il fatto è che ti fai una rappresentazione mentale semplicissima che però non corrisponde alle strutture dati in memoria

[trallallero]

leggi buf[i], poi per j che va da 0 a 7 testi il bit j-esimo in buf[i] e scrivi in matrice[i * 8 / 128][(i * 8 % 128) + j]

spero di non aver detto altre cazzate

è quello che stavo facendo infatti (a parte il calcolo per le coordinate, grazie ;)) ma mi sembra un pò laborioso ... magari esiste un metodo migliore

[mad_hhatter]

è quello che stavo facendo infatti (a parte il calcolo per le coordinate, grazie ;)) ma mi sembra un pò laborioso ... magari esiste un metodo migliore

puoi sempre tenere due contatori, uno per la riga e uno per la colonna, da incrementare in modo opportuno

[trallallero]

puoi sempre tenere due contatori, uno per la riga e uno per la colonna, da incrementare in modo opportuno

si, preferisco la leggibilitá
alla fine ho fatto cosí:


for( y = 0; y < 128; y++)
{
for( x = 0; x < 128; x++, c >>= 1)
{
if ((x) % 8 == 0)
{
n++;
c = s[n];
}
mat[y][x] = c & 0x01;
}

}

grazie per il supporto :)

[mad_hhatter]

si, preferisco la leggibilitá
alla fine ho fatto cosí:


for( y = 0; y < 128; y++)
{
for( x = 0; x < 128; x++, c >>= 1)
{
if ((x) % 8 == 0)
{
n++;
c = s[n];
}
mat[y][x] = c & 0x01;
}

}

grazie per il supporto :)

bello!
ragionavo dalla prospettiva sbagliata: dal buffer alla matrice... pensando al contrario il codice risulta molto più semplice e leggibile... bravo

[trallallero]

bello!
ragionavo dalla prospettiva sbagliata: dal buffer alla matrice... pensando al contrario il codice risulta molto più semplice e leggibile... bravo

beh, grazie ma è frutto anche della collaborazione sul forum :)

[trallallero]

perfetto, ieri ho fatto le mie funzioni per la matrice, le maschere AND e OR etc etc e ... son cambiate le specifiche (con tanto di litigata col tipo "so tutto io")

non è più una matrice 128 * 128 di interi ma ... di bit.

quindi ho pensato: non faccio una matrice ma un buffer identico a quello che mi arriva così faccio una memcpy e taglio la testa al toro, ma c'è un problema:
il buffer di bit che mi arriva deve essere copiato nel mio buffer passando attraverso 2 maschere di bit (AND e OR) quindi chiedo:
esiste una memcpy speciale che utilizza maschere di bit ?

non so se mi sono capito bene :D

posso farmela anche da solo ma se esiste già di sistema sicuramente è più veloce