Modifying header of JPEG file to properly match format [closed] - image

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 11 years ago.
I have been around the world twice and a half trying to fix a strange issue with a large sum of images I have.
What I need is to know how to read and write the first 4 and 18th bytes in the header of a JPEG file. If they match certain properties, I need to do some certain work and tweak these bytes to reflect something else. I'm basically fixing the format of these pictures to a more standard format, as Delphi doesn't recognize the format they're in.
So how do I read/write these bytes? What do I use? I know nothing about reading the raw data of an image file, let alone tweaking it.
NOTE
Deleted most of the question as I had put way too much information from the start.

Answer 1

The mechanics of actually changing the JPG header are very easy. That doesn't mean fixing the JPG is easy, it's just that if you know what to change, you can easily do it. Since that's what you're asking, here's how to change the JPG header in-memory, load the modified JPG into a TJpgImage and convert to TBitmap.
Please note I don't think this is a good approach. Fixing the resulting bitmap is so much easier! See my fresh answer to your other question for how to fix the bitmap here.
And here's the code you asked for (how to change the JPG header):
function LoadJpegIntoBitmap_HeaderFix(const FileName:string): TBitmap;
var M: TMemoryStream;
P: PByteArray;
Jpg: TJPEGImage;
begin
M := TMemoryStream.Create;
try
M.LoadFromFile(FileName);
if M.Size < 18 then raise Exception.Create('File too short.');
P := M.Memory;
// Here you can manipulate the header of the JPG file any way you want.
if P[0] = $07 then P[3] := P[17] - P[0]*3;
// Now load the modified JPG into a TJpgImage
Jpg := TJPEGImage.Create;
try
Jpg.LoadFromStream(M);
// Convert to bitmap
Result := TBitmap.Create;
Result.Assign(Jpg);
finally Jpg.Free;
end;
finally M.Free;
end;
end;

Answer 2

Don't even think you can tweak manually the first x bytes of your jpeg files.
As it has been explained already, the jpeg format is multiform and very complex. So much that some commonly used libraries do not handle all the acceptable formats. Open a libjpeg.h and see the bunch of header structures you can find in a jpeg file.
If you want to modify your header without changing the data, you still have to open the jpeg with a library that will hand over the proper structures for you to modify the relevant flags and save it back with the wanted format.
Either find a library written in Delphi or with a Delphi interface and use it to build your batch converter or to transform the format on the fly when opening a jpeg in your application.
If you know the exact combination of properties/flags defining your problem files, you can tweak the jpeg.pas unit to suit your need as I've shown in the previous answer.

Answer 3

Here's some pseudo code really quick. I'll improve it later. I have to run.
Assign the Adobe JPEG image file to a TFileStream
Read first 18 bytes and use CompareMem to see if signature matches Adobe RGB JPEG
If RGB JPEG then
We'll either:
Load from stream and tweak the header as we load
OR
Load from stream, copy to TBitmap, and use ScanLine to fix RGB
Else
Load from stream, normally
Hint, see LoadFromStream() instead of LoadFromFile().
I don't know what you're doing with the image afterward, so there may be some more work to be done.

Answer 4

Right, so your options here are (since we've completely ruled out any 3rd party code whatsoever):
Some Delphi guru (which I am certainly not) coming out of the woodwork and illuminating us with the existence of standard Delphi library code which handles this, or,
You write your own JPEG metadata decoding library.
Since I can't help you with the first option, here are some references you'll need while pursuing the second:
Wikipedia's JPEG article - one of the better written articles on the wiki. Great introductory material to this hairy subject.
ITU T.81 - The original JPEG specification. The most important bit is in Annex B, but this actually describes a format known as JIF which isn't actually in use. However, both JFIF and EXIF are based on it.
ICC - This specifies ICC (International Color Consortium) profiles, which are the bit that seems to be wrong with your headers.
ICC 2010 - New version of above specification, with Errata.
JFIF - The format most JPEG files actually use.
EXIF - Another format JPEG files use, especially those originating from digital cameras.
ITU T.84 - Less useful, this describes JPEG extensions. I'm including it here for completeness.
Sadly, none of the public domain JPEG implementations that I'm aware of (in any language) actually handle the relevant bits of the standards, namely EXIF and ICC profiles, so I can't give you any code you could draw inspiration from. The best place to look would probably be libexif, but that's GPL'ed.
What you're going to want to do is to read in the JPEG file as a regular file, parse the input according to information gleaned from the above documents, make the necessary changes, and write it back out. I don't think this is going to be easy, but apparently this is the only solution you'll accept.
Good luck!