Comment obtenir la largeur/hauteur de fichier jpeg sans l'aide de la bibliothèque?

Malheureusement, il ne semble pas être simple pour JPEG. Vous devriez regarder le source de la jhead outil de ligne de commande. Il fournit cette information. Lorsque vous allez à travers la source, vous verrez que la fonction ReadJpegSections. Cette fonction balaie toutes les segments contenus dans le fichier JPEG pour en extraire les informations souhaitées. La largeur de l'image et la hauteur est obtenue lors du traitement des images qui ont un SOFn marqueur.

Je vois la source est dans le domaine public, donc je vais vous montrer le morceau de code qui obtient l'image d'infos:

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);

À partir du code source, il est clair pour moi il n'y a pas une seule "en-tête" avec cette information. Vous devez parcourir le fichier JPEG, analyser chaque segment, jusqu'à ce que vous trouver le segment avec les informations que vous souhaitez. Ceci est décrit dans le article de wikipedia:

Une image JPEG est constitué d'une séquence de segments, chaque début avec un marqueur, dont chacun commence par un octet 0xFF suivie par un octet indiquant quel type de marqueur, il est. Certains marqueurs sont constitués de ces deux octets; d'autres sont suivis par deux octets indiquant la longueur de marqueur spécifique des données de la charge utile qui suit.

---

Un fichier JPEG est constitué d'une séquence de segments:

SEGMENT_0
SEGMENT_1
SEGMENT_2
...

Chaque segment commence avec une 2 octets marqueur. Le premier octet est 0xFF, le deuxième octet détermine le type du segment. Il est suivi par un codage de la longueur du segment. Dans le segment de données spécifiques à ce type de segment.

La largeur de l'image et la hauteur est trouvé dans un segment de type SOFn, ou "Démarrage de la trame [n]", où "n" est un nombre qui signifie quelque chose de spécial à un décodeur JPEG. Il devrait être assez bon pour le look que pour un SOF0, et ses octet désignation est 0xC0. Une fois que vous trouverez ce cadre, vous pouvez décoder de manière à trouver l'image en hauteur et en largeur.

De sorte que la structure d'un programme à faire ce que vous voulez ressemblerait à:

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

C'est essentiellement la structure des Michael de Petrov get_jpeg_size() de la mise en œuvre.

OriginalL'auteur jxh

la question est ancienne et les autres réponses sont correctes, mais leur format n'est pas le plus facile. Je viens de l'utiliser getc d'obtenir rapidement les dimensions, tout en sautant hors de propos marqueurs (il prend également en charge Progressive Jpeg):

  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;
     }
  }

OriginalL'auteur user6096479

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;
}

OriginalL'auteur Mike