WebPHandler::extractMetadataFromChunks() - Code Metrics - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

WebPHandler::extractMetadataFromChunks() B
last analyzed 2016-11-13 17:42 UTC

↳ Parent: WebPHandler

Complexity

Conditions	6
Paths	6

Size

Total Lines	29
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	20
nc	6
nop	2
dl	0
loc	29
rs	8.439
c	0
b	0
f	0

<?php
/**
 * Handler for Google's WebP format <https://developers.google.com/speed/webp/>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @ingroup Media
 */

/**
 * Handler for Google's WebP format <https://developers.google.com/speed/webp/>
 *
 * @ingroup Media
 */
class WebPHandler extends BitmapHandler {
	const BROKEN_FILE = '0'; // value to store in img_metadata if error extracting metadata.
	/**
	 * @var int Minimum chunk header size to be able to read all header types
	 */
	const MINIMUM_CHUNK_HEADER_LENGTH = 18;
	/**
	 * @var int version of the metadata stored in db records
	 */
	const _MW_WEBP_VERSION = 1;

	const VP8X_ICC = 32;
	const VP8X_ALPHA = 16;
	const VP8X_EXIF = 8;
	const VP8X_XMP = 4;
	const VP8X_ANIM = 2;

	public function getMetadata( $image, $filename ) {
		$parsedWebPData = self::extractMetadata( $filename );
		if ( !$parsedWebPData ) {
			return self::BROKEN_FILE;
		}

		$parsedWebPData['metadata']['_MW_WEBP_VERSION'] = self::_MW_WEBP_VERSION;
		return serialize( $parsedWebPData );
	}

	public function getMetadataType( $image ) {
		return 'parsed-webp';
	}

	public function isMetadataValid( $image, $metadata ) {
		if ( $metadata === self::BROKEN_FILE ) {
				// Do not repetitivly regenerate metadata on broken file.
				return self::METADATA_GOOD;
		}

		MediaWiki\suppressWarnings();
		$data = unserialize( $metadata );
		MediaWiki\restoreWarnings();

		if ( !$data || !is_array( $data ) ) {
				wfDebug( __METHOD__ . " invalid WebP metadata\n" );

				return self::METADATA_BAD;
		}

		if ( !isset( $data['metadata']['_MW_WEBP_VERSION'] )
				|| $data['metadata']['_MW_WEBP_VERSION'] != self::_MW_WEBP_VERSION
		) {
				wfDebug( __METHOD__ . " old but compatible WebP metadata\n" );

				return self::METADATA_COMPATIBLE;
		}
		return self::METADATA_GOOD;
	}

	/**
	 * Extracts the image size and WebP type from a file
	 *
	 * @param string $chunks Chunks as extracted by RiffExtractor
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @return array|bool Header data array with entries 'compression', 'width' and 'height',
	 * where 'compression' can be 'lossy', 'lossless', 'animated' or 'unknown'. False if
	 * file is not a valid WebP file.
	 */
	public static function extractMetadata( $filename ) {
		wfDebugLog( 'WebP', __METHOD__ . ": Extracting metadata from $filename\n" );

		$info = RiffExtractor::findChunksFromFile( $filename, 100 );
		if ( $info === false ) {
			wfDebugLog( 'WebP', __METHOD__ . ": Not a valid RIFF file\n" );
			return false;
		}

		if ( $info['fourCC'] != 'WEBP' ) {
			wfDebugLog( 'WebP', __METHOD__ . ': FourCC was not WEBP: ' .
				bin2hex( $info['fourCC'] ) . " \n" );
			return false;
		}

		$metadata = self::extractMetadataFromChunks( $info['chunks'], $filename );
		if ( !$metadata ) {
			wfDebugLog( 'WebP', __METHOD__ . ": No VP8 chunks found\n" );
			return false;
		}

		return $metadata;
	}

	/**
	 * Extracts the image size and WebP type from a file based on the chunk list
	 * @param array $chunks Chunks as extracted by RiffExtractor
	 * @return array Header data array with entries 'compression', 'width' and 'height', where
	 * 'compression' can be 'lossy', 'lossless', 'animated' or 'unknown'
	 */
	public static function extractMetadataFromChunks( $chunks, $filename ) {
		$vp8Info = [];

		foreach ( $chunks as $chunk ) {
			if ( !in_array( $chunk['fourCC'], [ 'VP8 ', 'VP8L', 'VP8X' ] ) ) {
				// Not a chunk containing interesting metadata
				continue;
			}

			$chunkHeader = file_get_contents( $filename, false, null,
				$chunk['start'], self::MINIMUM_CHUNK_HEADER_LENGTH );
			wfDebugLog( 'WebP', __METHOD__ . ": {$chunk['fourCC']}\n" );

			switch ( $chunk['fourCC'] ) {
				case 'VP8 ':
					return array_merge( $vp8Info,
						self::decodeLossyChunkHeader( $chunkHeader ) );
				case 'VP8L':
					return array_merge( $vp8Info,
						self::decodeLosslessChunkHeader( $chunkHeader ) );
				case 'VP8X':
					$vp8Info = array_merge( $vp8Info,
						self::decodeExtendedChunkHeader( $chunkHeader ) );
					// Continue looking for other chunks to improve the metadata
					break;
			}
		}
		return $vp8Info;
	}

	/**
	 * Decodes a lossy chunk header
	 * @param string $header Header string
	 * @return bool|array See WebPHandler::decodeHeader
	 */
	protected static function decodeLossyChunkHeader( $header ) {
		// Bytes 0-3 are 'VP8 '
		// Bytes 4-7 are the VP8 stream size
		// Bytes 8-10 are the frame tag
		// Bytes 11-13 are 0x9D 0x01 0x2A called the sync code
		$syncCode = substr( $header, 11, 3 );
		if ( $syncCode != "\x9D\x01\x2A" ) {
			wfDebugLog( 'WebP', __METHOD__ . ': Invalid sync code: ' .
				bin2hex( $syncCode ) . "\n" );
			return [];
		}
		// Bytes 14-17 are image size
		$imageSize = unpack( 'v2', substr( $header, 14, 4 ) );
		// Image sizes are 14 bit, 2 MSB are scaling parameters which are ignored here
		return [
			'compression' => 'lossy',
			'width' => $imageSize[1] & 0x3FFF,
			'height' => $imageSize[2] & 0x3FFF
		];
	}

	/**
	 * Decodes a lossless chunk header
	 * @param string $header Header string
	 * @return bool|array See WebPHandler::decodeHeader
	 */
	public static function decodeLosslessChunkHeader( $header ) {
		// Bytes 0-3 are 'VP8L'
		// Bytes 4-7 are chunk stream size
		// Byte 8 is 0x2F called the signature
		if ( $header{8} != "\x2F" ) {
			wfDebugLog( 'WebP', __METHOD__ . ': Invalid signature: ' .
				bin2hex( $header{8} ) . "\n" );
			return [];
		}
		// Bytes 9-12 contain the image size
		// Bits 0-13 are width-1; bits 15-27 are height-1
		$imageSize = unpack( 'C4', substr( $header, 9, 4 ) );
		return [
				'compression' => 'lossless',
				'width' => ( $imageSize[1] | ( ( $imageSize[2] & 0x3F ) << 8 ) ) + 1,
				'height' => ( ( ( $imageSize[2] & 0xC0 ) >> 6 ) |
						( $imageSize[3] << 2 ) | ( ( $imageSize[4] & 0x03 ) << 10 ) ) + 1
		];
	}

	/**
	 * Decodes an extended chunk header
	 * @param string $header Header string
	 * @return bool|array See WebPHandler::decodeHeader
	 */
	public static function decodeExtendedChunkHeader( $header ) {
		// Bytes 0-3 are 'VP8X'
		// Byte 4-7 are chunk length
		// Byte 8-11 are a flag bytes
		$flags = unpack( 'c', substr( $header, 8, 1 ) );

		// Byte 12-17 are image size (24 bits)
		$width = unpack( 'V', substr( $header, 12, 3 ) . "\x00" );
		$height = unpack( 'V', substr( $header, 15, 3 ) . "\x00" );

		return [
			'compression' => 'unknown',
			'animated' => ( $flags[1] & self::VP8X_ANIM ) == self::VP8X_ANIM,
			'transparency' => ( $flags[1] & self::VP8X_ALPHA ) == self::VP8X_ALPHA,
			'width' => ( $width[1] & 0xFFFFFF ) + 1,
			'height' => ( $height[1] & 0xFFFFFF ) + 1
		];
	}

	public function getImageSize( $file, $path, $metadata = false ) {
		if ( $file === null ) {
			$metadata = self::getMetadata( $file, $path );
		}
		if ( $metadata === false && $file instanceof File ) {
			$metadata = $file->getMetadata();
		}

		MediaWiki\suppressWarnings();
		$metadata = unserialize( $metadata );
		MediaWiki\restoreWarnings();

		if ( $metadata == false ) {
			return false;
		}
		return [ $metadata['width'], $metadata['height'] ];
	}

	/**
	 * @param $file
	 * @return bool True, not all browsers support WebP
	 */
	public function mustRender( $file ) {
		return true;
	}

	/**
	 * @param $file
	 * @return bool False if we are unable to render this image
	 */
	public function canRender( $file ) {
		if ( self::isAnimatedImage( $file ) ) {
			return false;
		}
		return true;
	}

	/**
	 * @param File $image
	 * @return bool
	 */
	public function isAnimatedImage( $image ) {
		$ser = $image->getMetadata();
		if ( $ser ) {
			$metadata = unserialize( $ser );
			if ( isset( $metadata['animated'] ) && $metadata['animated'] === true ) {
				return true;
			}
		}

		return false;
	}

	public function canAnimateThumbnail( $file ) {
		return false;
	}

	/**
	 * Render files as PNG
	 *
	 * @param $ext
	 * @param $mime
	 * @param $params
	 * @return array
	 */
	public function getThumbType( $ext, $mime, $params = null ) {
		return [ 'png', 'image/png' ];
	}

	/**
	 * Must use "im" for XCF
	 *
	 * @return string
	 */
	protected function getScalerType( $dstPath, $checkDstPath = true ) {
		return 'im';
	}
}


1		<?php
2		/**
3		* Handler for Google's WebP format <https://developers.google.com/speed/webp/>
4		*
5		* This program is free software; you can redistribute it and/or modify
6		* it under the terms of the GNU General Public License as published by
7		* the Free Software Foundation; either version 2 of the License, or
8		* (at your option) any later version.
9		*
10		* This program is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU General Public License for more details.
14		*
15		* You should have received a copy of the GNU General Public License along
16		* with this program; if not, write to the Free Software Foundation, Inc.,
17		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18		* http://www.gnu.org/copyleft/gpl.html
19		*
20		* @file
21		* @ingroup Media
22		*/
23
24		/**
25		* Handler for Google's WebP format <https://developers.google.com/speed/webp/>
26		*
27		* @ingroup Media
28		*/
29		class WebPHandler extends BitmapHandler {
30		const BROKEN_FILE = '0'; // value to store in img_metadata if error extracting metadata.
31		/**
32		* @var int Minimum chunk header size to be able to read all header types
33		*/
34		const MINIMUM_CHUNK_HEADER_LENGTH = 18;
35		/**
36		* @var int version of the metadata stored in db records
37		*/
38		const _MW_WEBP_VERSION = 1;
39
40		const VP8X_ICC = 32;
41		const VP8X_ALPHA = 16;
42		const VP8X_EXIF = 8;
43		const VP8X_XMP = 4;
44		const VP8X_ANIM = 2;
45
46		public function getMetadata( $image, $filename ) {
47		$parsedWebPData = self::extractMetadata( $filename );
48		if ( !$parsedWebPData ) {
49		return self::BROKEN_FILE;
50		}
51
52		$parsedWebPData['metadata']['_MW_WEBP_VERSION'] = self::_MW_WEBP_VERSION;
53		return serialize( $parsedWebPData );
54		}
55
56		public function getMetadataType( $image ) {
57		return 'parsed-webp';
58		}
59
60	View Code Duplication	public function isMetadataValid( $image, $metadata ) {
61		if ( $metadata === self::BROKEN_FILE ) {
62		// Do not repetitivly regenerate metadata on broken file.
63		return self::METADATA_GOOD;
64		}
65
66		MediaWiki\suppressWarnings();
67		$data = unserialize( $metadata );
68		MediaWiki\restoreWarnings();
69
70		if ( !$data \|\| !is_array( $data ) ) {
71		wfDebug( __METHOD__ . " invalid WebP metadata\n" );
72
73		return self::METADATA_BAD;
74		}
75
76		if ( !isset( $data['metadata']['_MW_WEBP_VERSION'] )
77		\|\| $data['metadata']['_MW_WEBP_VERSION'] != self::_MW_WEBP_VERSION
78		) {
79		wfDebug( __METHOD__ . " old but compatible WebP metadata\n" );
80
81		return self::METADATA_COMPATIBLE;
82		}
83		return self::METADATA_GOOD;
84		}
85
86		/**
87		* Extracts the image size and WebP type from a file
88		*
89		* @param string $chunks Chunks as extracted by RiffExtractor
		0 ignored issues – show Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report There is no parameter named `$chunks`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
90		* @return array\|bool Header data array with entries 'compression', 'width' and 'height',
91		* where 'compression' can be 'lossy', 'lossless', 'animated' or 'unknown'. False if
92		* file is not a valid WebP file.
93		*/
94		public static function extractMetadata( $filename ) {
95		wfDebugLog( 'WebP', __METHOD__ . ": Extracting metadata from $filename\n" );
96
97		$info = RiffExtractor::findChunksFromFile( $filename, 100 );
98		if ( $info === false ) {
99		wfDebugLog( 'WebP', __METHOD__ . ": Not a valid RIFF file\n" );
100		return false;
101		}
102
103		if ( $info['fourCC'] != 'WEBP' ) {
104		wfDebugLog( 'WebP', __METHOD__ . ': FourCC was not WEBP: ' .
105		bin2hex( $info['fourCC'] ) . " \n" );
106		return false;
107		}
108
109		$metadata = self::extractMetadataFromChunks( $info['chunks'], $filename );
110		if ( !$metadata ) {
111		wfDebugLog( 'WebP', __METHOD__ . ": No VP8 chunks found\n" );
112		return false;
113		}
114
115		return $metadata;
116		}
117
118		/**
119		* Extracts the image size and WebP type from a file based on the chunk list
120		* @param array $chunks Chunks as extracted by RiffExtractor
121		* @return array Header data array with entries 'compression', 'width' and 'height', where
122		* 'compression' can be 'lossy', 'lossless', 'animated' or 'unknown'
123		*/
124		public static function extractMetadataFromChunks( $chunks, $filename ) {
125		$vp8Info = [];
126
127		foreach ( $chunks as $chunk ) {
128		if ( !in_array( $chunk['fourCC'], [ 'VP8 ', 'VP8L', 'VP8X' ] ) ) {
129		// Not a chunk containing interesting metadata
130		continue;
131		}
132
133		$chunkHeader = file_get_contents( $filename, false, null,
134		$chunk['start'], self::MINIMUM_CHUNK_HEADER_LENGTH );
135		wfDebugLog( 'WebP', __METHOD__ . ": {$chunk['fourCC']}\n" );
136
137		switch ( $chunk['fourCC'] ) {
138		case 'VP8 ':
139		return array_merge( $vp8Info,
140		self::decodeLossyChunkHeader( $chunkHeader ) );
141		case 'VP8L':
142		return array_merge( $vp8Info,
143		self::decodeLosslessChunkHeader( $chunkHeader ) );
144		case 'VP8X':
145		$vp8Info = array_merge( $vp8Info,
146		self::decodeExtendedChunkHeader( $chunkHeader ) );
147		// Continue looking for other chunks to improve the metadata
148		break;
149		}
150		}
151		return $vp8Info;
152		}
153
154		/**
155		* Decodes a lossy chunk header
156		* @param string $header Header string
157		* @return bool\|array See WebPHandler::decodeHeader
158		*/
159		protected static function decodeLossyChunkHeader( $header ) {
160		// Bytes 0-3 are 'VP8 '
161		// Bytes 4-7 are the VP8 stream size
162		// Bytes 8-10 are the frame tag
163		// Bytes 11-13 are 0x9D 0x01 0x2A called the sync code
164		$syncCode = substr( $header, 11, 3 );
165		if ( $syncCode != "\x9D\x01\x2A" ) {
166		wfDebugLog( 'WebP', __METHOD__ . ': Invalid sync code: ' .
167		bin2hex( $syncCode ) . "\n" );
168		return [];
169		}
170		// Bytes 14-17 are image size
171		$imageSize = unpack( 'v2', substr( $header, 14, 4 ) );
172		// Image sizes are 14 bit, 2 MSB are scaling parameters which are ignored here
173		return [
174		'compression' => 'lossy',
175		'width' => $imageSize[1] & 0x3FFF,
176		'height' => $imageSize[2] & 0x3FFF
177		];
178		}
179
180		/**
181		* Decodes a lossless chunk header
182		* @param string $header Header string
183		* @return bool\|array See WebPHandler::decodeHeader
184		*/
185		public static function decodeLosslessChunkHeader( $header ) {
186		// Bytes 0-3 are 'VP8L'
187		// Bytes 4-7 are chunk stream size
188		// Byte 8 is 0x2F called the signature
189		if ( $header{8} != "\x2F" ) {
190		wfDebugLog( 'WebP', __METHOD__ . ': Invalid signature: ' .
191		bin2hex( $header{8} ) . "\n" );
192		return [];
193		}
194		// Bytes 9-12 contain the image size
195		// Bits 0-13 are width-1; bits 15-27 are height-1
196		$imageSize = unpack( 'C4', substr( $header, 9, 4 ) );
197		return [
198		'compression' => 'lossless',
199		'width' => ( $imageSize[1] \| ( ( $imageSize[2] & 0x3F ) << 8 ) ) + 1,
200		'height' => ( ( ( $imageSize[2] & 0xC0 ) >> 6 ) \|
201		( $imageSize[3] << 2 ) \| ( ( $imageSize[4] & 0x03 ) << 10 ) ) + 1
202		];
203		}
204
205		/**
206		* Decodes an extended chunk header
207		* @param string $header Header string
208		* @return bool\|array See WebPHandler::decodeHeader
209		*/
210		public static function decodeExtendedChunkHeader( $header ) {
211		// Bytes 0-3 are 'VP8X'
212		// Byte 4-7 are chunk length
213		// Byte 8-11 are a flag bytes
214		$flags = unpack( 'c', substr( $header, 8, 1 ) );
215
216		// Byte 12-17 are image size (24 bits)
217		$width = unpack( 'V', substr( $header, 12, 3 ) . "\x00" );
218		$height = unpack( 'V', substr( $header, 15, 3 ) . "\x00" );
219
220		return [
221		'compression' => 'unknown',
222		'animated' => ( $flags[1] & self::VP8X_ANIM ) == self::VP8X_ANIM,
223		'transparency' => ( $flags[1] & self::VP8X_ALPHA ) == self::VP8X_ALPHA,
224		'width' => ( $width[1] & 0xFFFFFF ) + 1,
225		'height' => ( $height[1] & 0xFFFFFF ) + 1
226		];
227		}
228
229		public function getImageSize( $file, $path, $metadata = false ) {
230		if ( $file === null ) {
231		$metadata = self::getMetadata( $file, $path );
232		}
233		if ( $metadata === false && $file instanceof File ) {
234		$metadata = $file->getMetadata();
235		}
236
237		MediaWiki\suppressWarnings();
238		$metadata = unserialize( $metadata );
239		MediaWiki\restoreWarnings();
240
241		if ( $metadata == false ) {
242		return false;
243		}
244		return [ $metadata['width'], $metadata['height'] ];
245		}
246
247		/**
248		* @param $file
249		* @return bool True, not all browsers support WebP
250		*/
251		public function mustRender( $file ) {
252		return true;
253		}
254
255		/**
256		* @param $file
257		* @return bool False if we are unable to render this image
258		*/
259		public function canRender( $file ) {
260		if ( self::isAnimatedImage( $file ) ) {
261		return false;
262		}
263		return true;
264		}
265
266		/**
267		* @param File $image
268		* @return bool
269		*/
270	View Code Duplication	public function isAnimatedImage( $image ) {
271		$ser = $image->getMetadata();
272		if ( $ser ) {
273		$metadata = unserialize( $ser );
274		if ( isset( $metadata['animated'] ) && $metadata['animated'] === true ) {
275		return true;
276		}
277		}
278
279		return false;
280		}
281
282		public function canAnimateThumbnail( $file ) {
283		return false;
284		}
285
286		/**
287		* Render files as PNG
288		*
289		* @param $ext
290		* @param $mime
291		* @param $params
292		* @return array
293		*/
294		public function getThumbType( $ext, $mime, $params = null ) {
295		return [ 'png', 'image/png' ];
296		}
297
298		/**
299		* Must use "im" for XCF
300		*
301		* @return string
302		*/
303		protected function getScalerType( $dstPath, $checkDstPath = true ) {
304		return 'im';
305		}
306		}
307

wikimedia / mediawiki

WebPHandler::extractMetadataFromChunks() B last analyzed 2016-11-13 17:42 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WebPHandler::extractMetadataFromChunks() B
last analyzed 2016-11-13 17:42 UTC