Reviewing my code after successfully recovering the images in pset4, I see a part I just copied (from Zamyla's video) without understanding.
Mainly, the following:
(block[3] & 0xf0) == 0xe0
I know what the code is testing; is the first half of the fourth byte equal to 0xe. In other words: block[3] == 0xe*, where * means any character.
Can anyone explain the logic and this use of &?
& is bitwise AND, the 0xf0 is sometimes referred to as a bit-mask, as the operation sets certain bits to 0. Both operands are integers, interpreted in their binary representation. The result has a 1 bit where the bit of the same value in both inputs was 1, else is 0.
Likewise, there are | bitwise OR (1 where at least one input had a 1), ^ bitwise XOR (eXclusive OR, 1 where input bits were different), and unary ~ bitwise negation (1 and 0 switched, can be used for changing sign: -value == ~value + 1). They even got their own "Bitwise operations in C" Wikipedia article.
I wrote my code to not use bitwise operators, as they're a bit hard understand for me (and you can do it without them). But that's what that is, the bitwise operator AND. There are even less explanations only about using them in conditions.
https://en.wikipedia.org/wiki/Bitwise_operations_in_C#Bitwise_AND_.22.26.22
Simply we are comparing bits to make sure are the same for our required pattern
our pattern is 0xe0 or 0xe1 or 0xe2 and so on... so ignore 1 - 2 - 3 - 4 - ... a - f we can make sure to have the right pattern by just checking 0xe
e is the first four bits of the byte
if buffer[3] contains the pattern 0xe we are finding what we are looking for in other words the pattern for the jpeg
Bitwise help us to compare:
The ideal 4 bit from buffer[3] would have 0xe
Our expression is: (buffer[3] & 0xf0) == 0xe0
Convert everything to binary and then let's compare:
0xe to binary: 1110 AND 0xf0 to binary: 11110000
forget 0x and let's focus on e and f: e has 4 bits and f has 4 bits
comparing bits:
1 & 1 == 1
1 & 1 == 1
1 & 1 == 1
0 & 1 == 0
So this comparing is equals to 1110 or in hex 0xe
Rules are simple 1 & 1 turns to be 1 AND 0 & 1 turns to be 0
Going back to our expression:
(buffer[3] & 0xf0) == 0xe0
1110 & 1111 IS INDEED 1110 WHICH IS 0xe and 0
1110 & 1111 is the same as 0xe0
So we just compared and found an ideal pattern where buffer[3] & mask (0xf0) is 0xe0 there for we just found a jpeg
It's clear what happens when you transform everything to binary from hex I hope this helps to understand this expression.
