mejor - el tamaño de una imagen jpeg(jfif)

jpeg jfif compliant

Question

Necesito encontrar el tamaño de una imagen jpeg (jfif). La imagen no se guarda como un archivo independiente, por lo que no puedo usar GetFileSize o cualquier otra API como esta (la imagen se coloca en una secuencia y no hay ningún otro encabezado, excepto el encabezado jpeg / jfif habitual (s ).

Investigué un poco y descubrí que las imágenes JPEG se componen de partes diferentes, cada parte comienza con un marcador de cuadro (0xFF; XX) y el tamaño de este cuadro. Usando esta información pude analizar mucha información del archivo.

El problema es que no puedo encontrar el tamaño de los datos comprimidos, ya que parece que no hay un marcador de cuadro para los datos comprimidos. Además, parece que los datos comprimidos siguen al marcador SOS (FF; DA) y la imagen termina con el marcador de Fin de imagen (EOI) (FF; D9).

Una forma de lograr esto sería buscar el marcador EOI de byte a byte, pero creo que los datos comprimidos pueden contener esta combinación de bytes, ¿no?

¿Conoces una forma fácil y correcta de encontrar el tamaño total de la imagen? (Preferiría mucho algún código / idea sin ninguna biblioteca externa, por favor :))?

Básicamente, necesito la distancia (en bytes) entre el inicio de la imagen (SOI-FFE0) y el final de la imagen (EOI-FFD9).

Answer 1

Este código es para tomar menos de 500kb de tamaño y formato .jpg antes de cargar la imagen

protected void btnOk_Click(object sender, EventArgs e)
{
    long maxsize = 512000;
    string str = Path.GetFileName(FileUpload1.FileName);
    int filesize = FileUpload1.PostedFile.ContentLength;
    string fileexe = Path.GetExtension(FileUpload1.FileName);
    if (filesize <= maxsize )
    {
        if (fileexe == ".jpg" || fileexe == ".jpeg")
        {
            FileUpload1.SaveAs(Server.MapPath("~/Image/" + str));
        }
        else
        {
            lblMsg.Text = "Image extension must be jpg or jpeg";
        }
    }
    else
    {
        lblMsg.Text = "File size is too large.";
    }

}

Answer 2

Como no tienes ningún idioma publicado, no estoy seguro de que esto funcione, pero:

¿Puedes Stream.Seek(0, StreamOffset.End); y luego tomar la posición de la corriente?

Por favor, sea específico sobre qué marco está utilizando.

El hecho real del asunto es que, si el encabezado del archivo no especifica el tamaño esperado, debe buscar (o leer) hasta el final de la imagen.

EDITAR

Ya que está intentando transmitir múltiples archivos, deseará usar un formato de contenedor compatible con la transmisión.

OGG debería ser un buen ajuste para esto.

En realidad, JPEG ya es compatible con la transmisión, pero debe garantizar que cada archivo tenga un terminador válido antes de enviarlo a la red o correrá el riesgo de bloquear su aplicación con una entrada inesperada.

Answer 3

En Python, puede leer todo el archivo en un objeto de cadena y encontrar la primera aparición de FF E0 y la última aparición de FF D9. ¿Presumiblemente, estos son el comienzo y el final que estás buscando?

f = open("filename.jpg", "r")
s = f.read()
start = s.find("/xff/xe0")
end = s.rfind("/xff/xd9")
imagesize = end - start

Answer 4

Los datos comprimidos no incluirán los bytes SOI o EOI, por lo que estará seguro allí. Pero el comentario, los datos de la aplicación, u otros encabezados podrían. Afortunadamente, puede identificar y omitir estas secciones a medida que se especifica la longitud.

La especificación JPEG le dice lo que necesita:
http://www.w3.org/Graphics/JPEG/itu-t81.pdf

Mire la Tabla B.1, en la página 32. Los símbolos que tienen un * no tienen un campo de longitud que lo siga (RST, SOI, EOI, TEM). Los otros lo hacen.

Deberá omitir los distintos campos, pero no está tan mal.

Cómo pasar:

1. Empieza a leer SOI ( FFD8 ). Este es el comienzo. Debería ser lo primero en la corriente.

   • Luego, avanza por el archivo, encuentra más marcadores y salta sobre los encabezados:

   • Marcador SOI ( FFD8 ): Imagen FFD8 . ¡Ya deberías haber encontrado un EOI!

   • TEM ( FF01 ): marcador independiente, seguir adelante.

   • RST ( FFD0 a FFD7 ): marcador independiente, sigue adelante. Puede validar que los marcadores de reinicio cuenten desde FFD0 hasta FFD7 y repita, pero eso no es necesario para medir la longitud.

   • Marcador EOI ( FFD9 ): ¡ FFD9 !

   • Cualquier marcador que no sea RST, SOI, EOI, TEM ( FF01 a FFFE , menos las excepciones anteriores): después del marcador, lea los siguientes 2 bytes, esta es la longitud de 16 bits big-endian de ese encabezado de marco (sin incluir el marcador de 2 bytes, pero incluyendo el campo de longitud). Omita la cantidad dada (normalmente longitud menos 2, ya que ya tiene esos bytes).

   • Si obtiene un final de archivo antes de EOI, entonces tiene una imagen dañada.

   • Una vez que tienes un EOI, has atravesado el JPEG y debes tener la longitud. Puede comenzar de nuevo leyendo otro SOI si espera más de un JPEG en su transmisión.

Answer 5

Tal vez algo como esto

int GetJpgSize(unsigned char *pData, DWORD FileSizeLow, unsigned short *pWidth, unsigned short *pHeight)
{
  unsigned int i = 0;


  if ((pData[i] == 0xFF) && (pData[i + 1] == 0xD8) && (pData[i + 2] == 0xFF) && (pData[i + 3] == 0xE0)) {
    i += 4;

    // Check for valid JPEG header (null terminated JFIF)
    if ((pData[i + 2] == ''J'') && (pData[i + 3] == ''F'') && (pData[i + 4] == ''I'') && (pData[i + 5] == ''F'')
        && (pData[i + 6] == 0x00)) {

      //Retrieve the block length of the first block since the first block will not contain the size of file
      unsigned short block_length = pData[i] * 256 + pData[i + 1];

      while (i < FileSizeLow) {
        //Increase the file index to get to the next block
        i += block_length; 

        if (i >= FileSizeLow) {
          //Check to protect against segmentation faults
          return -1;
        }

        if (pData[i] != 0xFF) {
          return -2;
        } 

        if (pData[i + 1] == 0xC0) {
          //0xFFC0 is the "Start of frame" marker which contains the file size
          //The structure of the 0xFFC0 block is quite simple [0xFFC0][ushort length][uchar precision][ushort x][ushort y]
          *pHeight = pData[i + 5] * 256 + pData[i + 6];
          *pWidth = pData[i + 7] * 256 + pData[i + 8];

          return 0;
        }
        else {
          i += 2; //Skip the block marker

          //Go to the next block
          block_length = pData[i] * 256 + pData[i + 1];
        }
      }

      //If this point is reached then no size was found
      return -3;
    }
    else {
      return -4;
    } //Not a valid JFIF string
  }
  else {
    return -5;
  } //Not a valid SOI header

  return -6;
}  // GetJpgSize