15899162844

Committed 26 Jun 2025 10:14AM UTC coverage: 71.088% (+0.004%) from 71.084%

Build # 15899162844

Build Type

Pull #12623

github

Committed by

web-flow

Commit Message

Merge c704a8392 into f5cb024d4

Pull Request Pull Request #12623: gdal raster overview add: add a --overview-src option

Run Details

209 of 244 new or added lines in 5 files covered. (85.66%)

96 existing lines in 44 files now uncovered.

574014 of 807474 relevant lines covered (71.09%)

250815.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.87

/frmts/jpeg/jpegdrivercore.cpp

/******************************************************************************
 *
 * Project:  JPEG JFIF Driver
 * Purpose:  Implement GDAL JPEG Support based on IJG libjpeg.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2000, Frank Warmerdam
 * Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
 *
 * Portions Copyright (c) Her majesty the Queen in right of Canada as
 * represented by the Minister of National Defence, 2006.
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "jpegdrivercore.h"

// So that D_LOSSLESS_SUPPORTED is visible if defined in jmorecfg of libjpeg-turbo >= 2.2
#define JPEG_INTERNAL_OPTIONS
#include "jpeglib.h"

/************************************************************************/
/*                    JPEGDatasetIsJPEGLS()                             */
/************************************************************************/

bool JPEGDatasetIsJPEGLS(GDALOpenInfo *poOpenInfo)

{
    GByte *pabyHeader = poOpenInfo->pabyHeader;
    int nHeaderBytes = poOpenInfo->nHeaderBytes;

    if (nHeaderBytes < 10)
        return false;

    if (pabyHeader[0] != 0xff || pabyHeader[1] != 0xd8)
        return false;

    for (int nOffset = 2; nOffset + 4 < nHeaderBytes;)
    {
        if (pabyHeader[nOffset] != 0xFF)
            return false;

        int nMarker = pabyHeader[nOffset + 1];
        if (nMarker == 0xDA)
            return false;

        if (nMarker == 0xF7)  // JPEG Extension 7, JPEG-LS.
            return true;
        if (nMarker == 0xF8)  // JPEG Extension 8, JPEG-LS Extension.
            return true;
        if (nMarker == 0xC3)  // Start of Frame 3 (Lossless Huffman)
            return true;
        if (nMarker ==
            0xC7)  // Start of Frame 7 (Differential Lossless Huffman)
            return true;
        if (nMarker == 0xCB)  // Start of Frame 11 (Lossless Arithmetic)
            return true;
        if (nMarker ==
            0xCF)  // Start of Frame 15 (Differential Lossless Arithmetic)
            return true;

        nOffset += 2 + pabyHeader[nOffset + 2] * 256 + pabyHeader[nOffset + 3];
    }

    return false;
}

/************************************************************************/
/*                     JPEGDriverIdentify()                             */
/************************************************************************/

int JPEGDriverIdentify(GDALOpenInfo *poOpenInfo)

{
    // If it is a subfile, read the JPEG header.
    if (STARTS_WITH_CI(poOpenInfo->pszFilename, "JPEG_SUBFILE:"))
        return TRUE;
    if (STARTS_WITH(poOpenInfo->pszFilename, "JPEG:"))
        return TRUE;

    // First we check to see if the file has the expected header bytes.
    const int nHeaderBytes = poOpenInfo->nHeaderBytes;

    if (nHeaderBytes < 10)
        return FALSE;

    GByte *const pabyHeader = poOpenInfo->pabyHeader;
    if (pabyHeader[0] != 0xff || pabyHeader[1] != 0xd8 || pabyHeader[2] != 0xff)
        return FALSE;

        // libjpeg-turbo >= 2.2 supports lossless mode
#if !defined(D_LOSSLESS_SUPPORTED)
    if (JPEGDatasetIsJPEGLS(poOpenInfo))
    {
        return FALSE;
    }
#endif

    // Some files like
    // http://dionecanali.hd.free.fr/~mdione/mapzen/N65E039.hgt.gz could be
    // mis-identfied as JPEG
    CPLString osFilenameLower = CPLString(poOpenInfo->pszFilename).tolower();
    if (osFilenameLower.endsWith(".hgt") ||
        osFilenameLower.endsWith(".hgt.gz") ||
        osFilenameLower.endsWith(".hgt.zip"))
    {
        return FALSE;
    }

    return TRUE;
}

/************************************************************************/
/*                     JPEGDriverSetCommonMetadata()                    */
/************************************************************************/

void JPEGDriverSetCommonMetadata(GDALDriver *poDriver)
{
    poDriver->SetDescription(DRIVER_NAME);
    poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
    poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "JPEG JFIF");
    poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC, "drivers/raster/jpeg.html");
    poDriver->SetMetadataItem(GDAL_DMD_EXTENSION, "jpg");
    poDriver->SetMetadataItem(GDAL_DMD_EXTENSIONS, "jpg jpeg");
    poDriver->SetMetadataItem(GDAL_DMD_MIMETYPE, "image/jpeg");

#if defined(JPEG_LIB_MK1_OR_12BIT) || defined(JPEG_DUAL_MODE_8_12)
    poDriver->SetMetadataItem(GDAL_DMD_CREATIONDATATYPES, "Byte UInt16");
#else
    poDriver->SetMetadataItem(GDAL_DMD_CREATIONDATATYPES, "Byte");
#endif
    poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");

    const char *pszOpenOptions =
        "<OpenOptionList>\n"
        "   <Option name='USE_INTERNAL_OVERVIEWS' type='boolean' "
        "description='whether to use implicit internal overviews' "
        "default='YES'/>\n"
        "   <Option name='APPLY_ORIENTATION' type='boolean' "
        "description='whether to take into account EXIF Orientation to "
        "rotate/flip the image' default='NO'/>\n"
        "</OpenOptionList>\n";
    poDriver->SetMetadataItem(GDAL_DMD_OPENOPTIONLIST, pszOpenOptions);

#ifdef D_LOSSLESS_SUPPORTED
    // For autotest purposes
    poDriver->SetMetadataItem("LOSSLESS_JPEG_SUPPORTED", "YES", "JPEG");
#endif

    poDriver->pfnIdentify = JPEGDriverIdentify;
    poDriver->SetMetadataItem(GDAL_DCAP_OPEN, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_CREATECOPY, "YES");
}

/************************************************************************/
/*                    DeclareDeferredJPEGPlugin()                       */
/************************************************************************/

#ifdef PLUGIN_FILENAME
void DeclareDeferredJPEGPlugin()
{
    if (GDALGetDriverByName(DRIVER_NAME) != nullptr)
    {
        return;
    }
    auto poDriver = new GDALPluginDriverProxy(PLUGIN_FILENAME);
#ifdef PLUGIN_INSTALLATION_MESSAGE
    poDriver->SetMetadataItem(GDAL_DMD_PLUGIN_INSTALLATION_MESSAGE,
                              PLUGIN_INSTALLATION_MESSAGE);
#endif
    JPEGDriverSetCommonMetadata(poDriver);
    GetGDALDriverManager()->DeclareDeferredPluginDriver(poDriver);
}
#endif

1	/******************************************************************************
2	*
3	* Project: JPEG JFIF Driver
4	* Purpose: Implement GDAL JPEG Support based on IJG libjpeg.
5	* Author: Frank Warmerdam, warmerdam@pobox.com
6	*
7	******************************************************************************
8	* Copyright (c) 2000, Frank Warmerdam
9	* Copyright (c) 2007-2014, Even Rouault <even dot rouault at spatialys.com>
10	*
11	* Portions Copyright (c) Her majesty the Queen in right of Canada as
12	* represented by the Minister of National Defence, 2006.
13	*
14	* SPDX-License-Identifier: MIT
15	****************************************************************************/
16
17	#include "jpegdrivercore.h"
18
19	// So that D_LOSSLESS_SUPPORTED is visible if defined in jmorecfg of libjpeg-turbo >= 2.2
20	#define JPEG_INTERNAL_OPTIONS
21	#include "jpeglib.h"
22
23	/************************************************************************/
24	/* JPEGDatasetIsJPEGLS() */
25	/************************************************************************/
26
27	bool JPEGDatasetIsJPEGLS(GDALOpenInfo *poOpenInfo)	6,626✔
28
29	{
30	GByte *pabyHeader = poOpenInfo->pabyHeader;	6,626✔
31	int nHeaderBytes = poOpenInfo->nHeaderBytes;	6,626✔
32
33	if (nHeaderBytes < 10)	6,626✔
34	return false;	×
35
36	if (pabyHeader[0] != 0xff \|\| pabyHeader[1] != 0xd8)	6,626✔
37	return false;	×
38
39	for (int nOffset = 2; nOffset + 4 < nHeaderBytes;)	30,390✔
40	{
41	if (pabyHeader[nOffset] != 0xFF)	25,952✔
42	return false;	6✔
43
44	int nMarker = pabyHeader[nOffset + 1];	25,946✔
45	if (nMarker == 0xDA)	25,946✔
46	return false;	2,182✔
47
48	if (nMarker == 0xF7) // JPEG Extension 7, JPEG-LS.	23,764✔
49	return true;	×
50	if (nMarker == 0xF8) // JPEG Extension 8, JPEG-LS Extension.	23,764✔
51	return true;	×
52	if (nMarker == 0xC3) // Start of Frame 3 (Lossless Huffman)	23,764✔
53	return true;	×
54	if (nMarker ==	23,764✔
55	0xC7) // Start of Frame 7 (Differential Lossless Huffman)
56	return true;	×
57	if (nMarker == 0xCB) // Start of Frame 11 (Lossless Arithmetic)	23,764✔
58	return true;	×
59	if (nMarker ==	23,764✔
60	0xCF) // Start of Frame 15 (Differential Lossless Arithmetic)
UNCOV 61	return true;	×
62
63	nOffset += 2 + pabyHeader[nOffset + 2] * 256 + pabyHeader[nOffset + 3];	23,764✔
64	}
65
66	return false;	4,438✔
67	}
68
69	/************************************************************************/
70	/* JPEGDriverIdentify() */
71	/************************************************************************/
72
73	int JPEGDriverIdentify(GDALOpenInfo *poOpenInfo)	64,271✔
74
75	{
76	// If it is a subfile, read the JPEG header.
77	if (STARTS_WITH_CI(poOpenInfo->pszFilename, "JPEG_SUBFILE:"))	64,271✔
78	return TRUE;	300✔
79	if (STARTS_WITH(poOpenInfo->pszFilename, "JPEG:"))	63,971✔
80	return TRUE;	12✔
81
82	// First we check to see if the file has the expected header bytes.
83	const int nHeaderBytes = poOpenInfo->nHeaderBytes;	63,959✔
84
85	if (nHeaderBytes < 10)	63,959✔
86	return FALSE;	53,546✔
87
88	GByte *const pabyHeader = poOpenInfo->pabyHeader;	10,413✔
89	if (pabyHeader[0] != 0xff \|\| pabyHeader[1] != 0xd8 \|\| pabyHeader[2] != 0xff)	10,413✔
90	return FALSE;	3,787✔
91
92	// libjpeg-turbo >= 2.2 supports lossless mode
93	#if !defined(D_LOSSLESS_SUPPORTED)
94	if (JPEGDatasetIsJPEGLS(poOpenInfo))	6,626✔
95	{
96	return FALSE;	×
97	}
98	#endif
99
100	// Some files like
101	// http://dionecanali.hd.free.fr/~mdione/mapzen/N65E039.hgt.gz could be
102	// mis-identfied as JPEG
103	CPLString osFilenameLower = CPLString(poOpenInfo->pszFilename).tolower();	13,252✔
104	if (osFilenameLower.endsWith(".hgt") \|\|	13,252✔
105	osFilenameLower.endsWith(".hgt.gz") \|\|	26,504✔
106	osFilenameLower.endsWith(".hgt.zip"))	13,252✔
107	{
108	return FALSE;	×
109	}
110
111	return TRUE;	6,626✔
112	}
113
114	/************************************************************************/
115	/* JPEGDriverSetCommonMetadata() */
116	/************************************************************************/
117
118	void JPEGDriverSetCommonMetadata(GDALDriver *poDriver)	1,629✔
119	{
120	poDriver->SetDescription(DRIVER_NAME);	1,629✔
121	poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");	1,629✔
122	poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "JPEG JFIF");	1,629✔
123	poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC, "drivers/raster/jpeg.html");	1,629✔
124	poDriver->SetMetadataItem(GDAL_DMD_EXTENSION, "jpg");	1,629✔
125	poDriver->SetMetadataItem(GDAL_DMD_EXTENSIONS, "jpg jpeg");	1,629✔
126	poDriver->SetMetadataItem(GDAL_DMD_MIMETYPE, "image/jpeg");	1,629✔
127
128	#if defined(JPEG_LIB_MK1_OR_12BIT) \|\| defined(JPEG_DUAL_MODE_8_12)
129	poDriver->SetMetadataItem(GDAL_DMD_CREATIONDATATYPES, "Byte UInt16");	1,629✔
130	#else
131	poDriver->SetMetadataItem(GDAL_DMD_CREATIONDATATYPES, "Byte");
132	#endif
133	poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");	1,629✔
134
135	const char *pszOpenOptions =	1,629✔
136	"<OpenOptionList>\n"
137	" <Option name='USE_INTERNAL_OVERVIEWS' type='boolean' "
138	"description='whether to use implicit internal overviews' "
139	"default='YES'/>\n"
140	" <Option name='APPLY_ORIENTATION' type='boolean' "
141	"description='whether to take into account EXIF Orientation to "
142	"rotate/flip the image' default='NO'/>\n"
143	"</OpenOptionList>\n";
144	poDriver->SetMetadataItem(GDAL_DMD_OPENOPTIONLIST, pszOpenOptions);	1,629✔
145
146	#ifdef D_LOSSLESS_SUPPORTED
147	// For autotest purposes
148	poDriver->SetMetadataItem("LOSSLESS_JPEG_SUPPORTED", "YES", "JPEG");
149	#endif
150
151	poDriver->pfnIdentify = JPEGDriverIdentify;	1,629✔
152	poDriver->SetMetadataItem(GDAL_DCAP_OPEN, "YES");	1,629✔
153	poDriver->SetMetadataItem(GDAL_DCAP_CREATECOPY, "YES");	1,629✔
154	}	1,629✔
155
156	/************************************************************************/
157	/* DeclareDeferredJPEGPlugin() */
158	/************************************************************************/
159
160	#ifdef PLUGIN_FILENAME
161	void DeclareDeferredJPEGPlugin()
162	{
163	if (GDALGetDriverByName(DRIVER_NAME) != nullptr)
164	{
165	return;
166	}
167	auto poDriver = new GDALPluginDriverProxy(PLUGIN_FILENAME);
168	#ifdef PLUGIN_INSTALLATION_MESSAGE
169	poDriver->SetMetadataItem(GDAL_DMD_PLUGIN_INSTALLATION_MESSAGE,
170	PLUGIN_INSTALLATION_MESSAGE);
171	#endif
172	JPEGDriverSetCommonMetadata(poDriver);
173	GetGDALDriverManager()->DeclareDeferredPluginDriver(poDriver);
174	}
175	#endif

OSGeo / gdal / 15899162844

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous