C code to covert 16bit (RBG565) to grayscale image - for-loop

Question

I am trying to covert 16bit (RBG565) to grayscale image. I tried various combination of formula suggested in the internet all works good for 24 bit RGB888 format. when i try with 16bit (RBG565) the image has blue, red pixels, unable to create the exact grayscale image. please help.
Formula 1 works better than Formula 2:
Formula 1:
unsigned char gray = (red * 77+( (green )* 150)/2 + blue * 29+128) / 256;
Formula 2:
unsigned char gray = red * 0.212 + green * 0.715 + blue * 0.072;

Answer 1

Since the RGB components tend to be a scale from no-colour to full-colour for each primary colour (primary in the general sense, meaning colours combined to form others), I would probably convert to RGB up front, then use the normal grey-scaling algorithm (any of the ones you state that "work good for 24 bit RGB888").
That first bit could probably be done with (upper case is the eight-bit value, lower case the 5/6-bit value):
R = r * 8 ; 256/32, 8-bit from 5-bit
B = b * 4 ; 256/64, 8-bit from 6-bit
G = g * 8 ; 256/32, 8-bit from 5-bit
Just ensure you get the order right when extracting the bits, because you're converting RBG to RGB.
For example here's a complete C program (since you didn't provide a language tag) containing a function which will do that, except that it uses slightly different scaling which relies on percentages rather than fixed values that need 0..255 inputs:
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
uint16_t greyScale(uint16_t rbg565) {
// Get the values (32-bit to hold larger intermediate values).
uint32_t r = (rbg565 >> 11) & 31U; // XXXXX___________
uint32_t g = rbg565 & 31U; // ___________XXXXX
uint32_t b = (rbg565 >> 5) & 63U; // _____XXXXXX_____
// Scale each of them up to the range 0..500.
g = g * 500 / 31;
b = b * 500 / 63;
r = r * 500 / 31;
// Use example RGB weights of 299/587/114 (summing to 1,000).
// Range then 0..500,000 so divide by 500 to get grey 0..1,000.
uint32_t grey = (r * 299 + g * 587 + b * 114);
grey /= 500;
return (uint16_t)grey;
}
int main(int argc, char *argv[])
{
for (int i = 1; i < argc; i++) {
uint16_t rbg = atoi(argv[i]);
printf("%5d -> %d\n", rbg, greyScale(rbg));
}
return 0;
}
If you run it with some sample values, you'll see the greyscale values come out (comments are added by me):
pax:~> ./prog 0 65535 31 $((63*32)) $((31*2048)) $((16*2048+32*32+16))
0 -> 0 # No colour components.
65535 -> 1000 # Max RGB (white).
31 -> 587 # Max green, nothing else.
2016 -> 114 # Max blue, nothing else.
63488 -> 299 # Max red, nothing else.
33808 -> 514 # A little more than half of everything.
If you want to use weightings different from the ones I provided (29.9%, 58.7%, and 11.4%), just change this line to match, making sure they still sum to a thousand:
uint32_t grey = (r * 299 + g * 587 + b * 114);