Wie erhalte ich die Breite/Höhe einer JPEG-Datei, ohne die Bibliothek zu verwenden?

Zunächst möchte ich sagen, dass ich viele Male versucht habe, die Antwort mithilfe der Google-Suche zu finden, und ich habe viele Ergebnisse gefunden, aber ich habe sie nicht verstanden, weil ich die Idee nicht kenne, eine Binärdatei zu lesen und den erhaltenen Wert zu konvertieren ablesbarer Wert.

Was ich dabei versucht habe.

unsigned char fbuff[16];
FILE *file;
file = fopen("C:\\loser.jpg", "rb");
if(file != NULL){
   fseek(file, 0, SEEK_SET);
   fread(fbuff, 1, 16, file);
   printf("%d\n", fbuff[1]);
   fclose(file);
}else{
   printf("File does not exists.");
}

Ich möchte eine einfache Erklärung mit Beispielshows, wie man die Breite/Höhe einer JPEG-Datei aus ihrem Header erhält und diesen Wert dann in einen lesbaren Wert umwandelt.

Leider scheint es für JPEG nicht einfach zu sein. Sie sollten sich die Quelle dazu ansehen jhead Kommandozeilen-Tool. Es liefert diese Informationen. Wenn Sie durch die Quelle gehen, sehen Sie die Funktion ReadJpegSections. Diese Funktion durchsucht alle in der JPEG-Datei enthaltenen Segmente, um die gewünschten Informationen zu extrahieren. Die Bildbreite und -höhe wird bei der Verarbeitung der Rahmen mit einem erhalten SOFn Marker.

Ich sehe, dass die Quelle gemeinfrei ist, also zeige ich das Snippet, das die Bildinformationen erhält:

static int Get16m(const void * Short)
{
    return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
}

static void process_SOFn (const uchar * Data, int marker)
{
    int data_precision, num_components;

    data_precision = Data[2];
    ImageInfo.Height = Get16m(Data+3);
    ImageInfo.Width = Get16m(Data+5);

Aus dem Quellcode ist mir klar, dass es keinen einzigen “Header” mit diesen Informationen gibt. Sie müssen die JPEG-Datei durchsuchen und jedes Segment parsen, bis Sie das Segment mit den gewünschten Informationen darin finden. Dies ist in der beschrieben Wikipedia-Artikel:

Ein JPEG-Bild besteht aus einer Folge von Segmenten, die jeweils mit einer Markierung beginnen, die jeweils mit einem 0xFF-Byte beginnen, gefolgt von einem Byte, das angibt, um welche Art von Markierung es sich handelt. Einige Marker bestehen nur aus diesen zwei Bytes; anderen folgen zwei Bytes, die die Länge der darauffolgenden markierungsspezifischen Nutzlastdaten angeben.

Eine JPEG-Datei besteht aus einer Folge von Segmenten:

SEGMENT_0
SEGMENT_1
SEGMENT_2
...

Jedes Segment beginnt mit einer 2-Byte-Markierung. Das erste Byte ist 0xFF, das zweite Byte bestimmt den Typ des Segments. Danach folgt eine Codierung der Länge des Segments. Innerhalb des Segments befinden sich Daten, die für diesen Segmenttyp spezifisch sind.

Die Bildbreite und -höhe wird in einem Textsegment gefunden SOFnoder “Beginn des Frames [n]”, wobei “n” eine Zahl ist, die für einen JPEG-Decoder etwas Besonderes bedeutet. Es sollte ausreichen, nur nach a zu suchen SOF0und seine Byte-Bezeichnung ist 0xC0. Sobald Sie diesen Rahmen gefunden haben, können Sie ihn decodieren, um die Bildhöhe und -breite zu ermitteln.

Die Struktur eines Programms, das das tut, was Sie wollen, würde also folgendermaßen aussehen:

file_data = the data in the file
data = &file_data[0]
while (data not at end of file_data)
    segment_type = decoded JPEG segment type at data
    if (type != SOF0)
        data += byte length for segment_type
        continue
    else
        get image height and width from segment
        return

Dies ist im Wesentlichen die Struktur, die in gefunden wird Michael Petrovs get_jpeg_size() Implementierung.

dann müssen Sie die Höhen- und Breitenmarkierung von JPEG finden [ffc0].

Nachdem ffc0 im Binärformat gefunden wurde, sind die vier, fünf Bytes hoch und sechs und sieben Bytes breit.

eg: [ff c0] d8 c3 c2 [ff da] [00 ff]
                      |         |
                      |         |
                      ->height  ->width

int position;
unsigned char len_con[2];
/*Extract start of frame marker(FFC0) of width and hight and get the position*/
for(i=0;i<FILE_SIZE;i++)
{
    if((image_buffer[i]==FF) && (image_buffer[i+1]==c0) )
    {
        position=i;
    }
}
/*Moving to the particular byte position and assign byte value to pointer variable*/
position=position+5;
*height=buffer_src[position]<<8|buffer_src[position+1];
*width=buffer_src[position+2]<<8|buffer_src[position+3];

printf("height %d",*height);
printf("width %d",*width);

Die Frage ist alt und die anderen Antworten sind richtig, aber ihr Format ist nicht das einfachste. Ich benutze nur getc um schnell die Abmessungen zu erhalten, während irrelevante Markierungen übersprungen werden (es unterstützt auch Progressive JPEGs):

  int height, width;
  // start of image (SOI)
  getc(f);   // oxff
  getc(f);   // oxd8
  // Scan miscellaneous markers until we reach SOF0 marker (0xC0)
  for(;;) {
     // next marker
     int marker;
     while((marker = getc(f)) != 0xFF);
     while((marker = getc(f)) == 0xFF);
     // SOF
     if (marker == 0xC0 || marker == 0xC2) {
        getc(f);   // length (2 bytes)
        getc(f);   // #
        getc(f);   // bpp, usually 8
        height = (getc(f) << 8) + getc(f);   // height
        width = (getc(f) << 8) + getc(f);   // width
        break;
     }
  }

Bildabmessungen in JPEG-Dateien finden Sie wie folgt:

1) Suchen Sie nach FF C0

2) An den Offsets +4 und +6 nach dieser Position sind jeweils Höhe und Breite (Wörter).

In den meisten Fällen sind die absoluten Versätze von Höhe und Breite A3 bzw. A5.

Hier ist ein einfacher Code, den ich geschrieben habe und der zuverlässig zu funktionieren scheint.

#define MOTOSHORT(p) ((*(p))<<8) + *(p+1)
unsigned char cBuf[32];
int iBytes, i, j, iMarker, iFilesize;
unsigned char ucSubSample;
int iBpp, iHeight, iWidth;

         Seek(iHandle, 0, 0); // read the first 32 bytes
         iBytes = Read(iHandle, cBuf, 32);

         i = j = 2; /* Start at offset of first marker */
         iMarker = 0; /* Search for SOF (start of frame) marker */
         while (i < 32 && iMarker != 0xffc0 && j < iFileSize)
            {
            iMarker = MOTOSHORT(&cBuf[i]) & 0xfffc;
            if (iMarker < 0xff00) // invalid marker, could be generated by "Arles Image Web Page Creator" or Accusoft
               {
               i += 2;
               continue; // skip 2 bytes and try to resync
               }
            if (iMarker == 0xffc0) // the one we're looking for
               break;
            j += 2 + MOTOSHORT(&cBuf[i+2]); /* Skip to next marker */
            if (j < iFileSize) // need to read more
               {
               Seek(iHandle, j, 0); // read some more
               iBytes = Read(iHandle, cBuf, 32);
               i = 0;
               }
            else // error, abort
               break;
            } // while
         if (iMarker != 0xffc0)
            goto process_exit; // error - invalid file?
         else
            {
            iBpp = cBuf[i+4]; // bits per sample
            iHeight = MOTOSHORT(&cBuf[i+5]);
            iWidth = MOTOSHORT(&cBuf[i+7]);
            iBpp = iBpp * cBuf[i+9]; /* Bpp = number of components * bits per sample */
            ucSubSample = cBuf[i+11];
            }

int  GetJpegDimensions(
    char            *pImage,
    size_t          nSize,
    unsigned32      *u32Width,
    unsigned32      *u32Height,
    char            *szErrMsg)
{
    int             nIndex;
    int             nStartOfFrame;
    int             nError = NO_ERROR;
    bool            markerFound = false;
    unsigned char   ucWord0;
    unsigned char   ucWord1;

    // verify START OF IMAGE marker = FF D8
    nIndex = 0;
    ucWord0 = pImage[nIndex];
    ucWord1 = pImage[nIndex+1];

    // marker FF D8  starts a valid JPEG
    if ((ucWord0 == 0xFF)  && (ucWord1 == 0xD8))
    {
        // search for START OF FRAME 0  marker  FF C0
        for (nIndex = 2;
            (nIndex < nSize-2) && (markerFound == false);
             nIndex += 2)
        {
            ucWord0 = pImage[nIndex];
            ucWord1 = pImage[nIndex+1];
            if (ucWord0 == 0xFF)
            {
                if (ucWord1 == 0xC0)
                {
                    markerFound = true;
                    nStartOfFrame = nIndex;
                }
            }
            if (ucWord1 == 0xFF)
            {
                ucWord0 = pImage[nIndex+2];
                if (ucWord0 == 0xC0)
                {
                    markerFound = true;
                    nStartOfFrame = nIndex+1;
                }
            }
        } // while

        if (markerFound)
        {
            nError  = NO_ERROR;
            ucWord0 = pImage[nStartOfFrame+5];
            ucWord1 = pImage[nStartOfFrame+6];
            *u32Height = ucWord1 + (ucWord0 << 8);

            ucWord0 = pImage[nStartOfFrame+7];
            ucWord1 = pImage[nStartOfFrame+8];
            *u32Width =  ucWord1 + (ucWord0 << 8);
        }
        else
        {
            // start of frame 0 not found
            nError = -2;
            sprintf(szErrMsg,
              "Not a valid JPEG image. START OF FRAME 0 marker FFC0 not found");
        }
    }
    else   // START OF IMAGE marker not found
    {
        nError = -1;
        sprintf(szErrMsg,
          "Not a valid JPEG image. START OF IMAGE marker FFD8 not found");
    }
    return nError;
}

Hier ist ein Code, den ich in Java geschrieben habe. Funktioniert gut für JPEGs, die von einer Kamera aufgenommen wurden. Es scannt den gesamten Code, um die größte Bildgröße zu finden. Ich konnte es nicht verbessern, die Längen jedes Blocks zu überspringen, weil es nicht funktioniert. Wenn jemand den Code dafür verbessern könnte, wäre das großartig.

int getShort(byte[] p, int i)
{
   int p0 = p[i] & 0xFF;
   int p1 = p[i+1] & 0xFF;
   return p1 | (p0 << 8);
}

int[]  GetJpegDimensions(byte[] b)
{
    int nIndex;
    int height=0, width=0, size=0;
    int nSize = b.length;

    // marker FF D8  starts a valid JPEG
    if (getShort(b,0) == 0xFFD8)
       for (nIndex = 2; nIndex < nSize-1; nIndex += 4)
          if (b[nIndex] == -1/*FF*/ && b[nIndex+1] == -64/*C0*/)
          {
             int w = getShort(b,nIndex+7);
             int h = getShort(b,nIndex+5);
             if (w*h > size)
             {
                size = w*h;
                width = w;
                height = h;
             }
          }
    return new int[]{width,height};
}