class.jetpack-post-images.php — Jetpack – WP Security, Backup, Speed, & Growth 14.7.1

jetpack / class.jetpack-post-images.php

jetpack Last commit date

class.jetpack-post-images.php

1171 lines

1	<?php // phpcs:ignore WordPress.Files.FileName.InvalidClassFileName
2	/**
3	* Useful for finding an image to display alongside/in representation of a specific post.
4	*
5	* @package automattic/jetpack
6	*/
7
8	use Automattic\Jetpack\Image_CDN\Image_CDN_Core;
9
10	/**
11	* Useful for finding an image to display alongside/in representation of a specific post.
12	*
13	* Includes a few different methods, all of which return a similar-format array containing
14	* details of any images found. Everything can (should) be called statically, it's just a
15	* function-bucket. You can also call Jetpack_PostImages::get_image() to cycle through all of the methods until
16	* one of them finds something useful.
17	*
18	* This file is included verbatim in Jetpack
19	*/
20	class Jetpack_PostImages {
21	/**
22	* If a slideshow is embedded within a post, then parse out the images involved and return them
23	*
24	* @param int $post_id Post ID.
25	* @param int $width Image width.
26	* @param int $height Image height.
27	* @return array Images.
28	*/
29	public static function from_slideshow( $post_id, $width = 200, $height = 200 ) {
30	$images = array();
31
32	$post = get_post( $post_id );
33
34	if ( ! $post ) {
35	return $images;
36	}
37
38	if ( ! empty( $post->post_password ) ) {
39	return $images;
40	}
41
42	if ( false === has_shortcode( $post->post_content, 'slideshow' ) ) {
43	return $images; // no slideshow - bail.
44	}
45
46	$permalink = get_permalink( $post->ID );
47
48	// Mechanic: Somebody set us up the bomb.
49	$old_post = $GLOBALS['post'] ?? null;
50	$GLOBALS['post'] = $post; // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
51	$old_shortcodes = $GLOBALS['shortcode_tags'];
52	$GLOBALS['shortcode_tags'] = array( 'slideshow' => $old_shortcodes['slideshow'] ); // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
53
54	// Find all the slideshows.
55	preg_match_all( '/' . get_shortcode_regex() . '/sx', $post->post_content, $slideshow_matches, PREG_SET_ORDER );
56
57	ob_start(); // The slideshow shortcode handler calls wp_print_scripts and wp_print_styles... not too happy about that.
58
59	foreach ( $slideshow_matches as $slideshow_match ) {
60	$slideshow = do_shortcode_tag( $slideshow_match );
61	$pos = stripos( $slideshow, 'jetpack-slideshow' );
62	if ( false === $pos ) { // must be something wrong - or we changed the output format in which case none of the following will work.
63	continue;
64	}
65	$start = strpos( $slideshow, '[', $pos );
66	$end = strpos( $slideshow, ']', $start );
67	$post_images = json_decode( wp_specialchars_decode( str_replace( "'", '"', substr( $slideshow, $start, $end - $start + 1 ) ), ENT_QUOTES ) ); // parse via JSON
68	// If the JSON didn't decode don't try and act on it.
69	if ( is_array( $post_images ) ) {
70	foreach ( $post_images as $post_image ) {
71	$post_image_id = absint( $post_image->id );
72	if ( ! $post_image_id ) {
73	continue;
74	}
75
76	$meta = wp_get_attachment_metadata( $post_image_id );
77
78	// Must be larger than 200x200 (or user-specified).
79	if ( ! isset( $meta['width'] ) \|\| $meta['width'] < $width ) {
80	continue;
81	}
82	if ( ! isset( $meta['height'] ) \|\| $meta['height'] < $height ) {
83	continue;
84	}
85
86	$url = wp_get_attachment_url( $post_image_id );
87
88	$images[] = array(
89	'type' => 'image',
90	'from' => 'slideshow',
91	'src' => $url,
92	'src_width' => $meta['width'],
93	'src_height' => $meta['height'],
94	'href' => $permalink,
95	);
96	}
97	}
98	}
99	ob_end_clean();
100
101	// Operator: Main screen turn on.
102	$GLOBALS['shortcode_tags'] = $old_shortcodes; // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
103	$GLOBALS['post'] = $old_post; // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited
104
105	return $images;
106	}
107
108	/**
109	* Filtering out images with broken URL from galleries.
110	*
111	* @param array $galleries Galleries.
112	* @return array $filtered_galleries
113	*/
114	public static function filter_gallery_urls( $galleries ) {
115	$filtered_galleries = array();
116	foreach ( $galleries as $this_gallery ) {
117	if ( ! isset( $this_gallery['src'] ) ) {
118	continue;
119	}
120	$ids = isset( $this_gallery['ids'] ) ? explode( ',', $this_gallery['ids'] ) : array();
121	// Make sure 'src' array isn't associative and has no holes.
122	$this_gallery['src'] = array_values( $this_gallery['src'] );
123	foreach ( $this_gallery['src'] as $idx => $src_url ) {
124	if ( filter_var( $src_url, FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED ) === false ) {
125	unset( $this_gallery['src'][ $idx ] );
126	unset( $ids[ $idx ] );
127	}
128	}
129	if ( isset( $this_gallery['ids'] ) ) {
130	$this_gallery['ids'] = implode( ',', $ids );
131	}
132	// Remove any holes we introduced.
133	$this_gallery['src'] = array_values( $this_gallery['src'] );
134	$filtered_galleries[] = $this_gallery;
135	}
136
137	return $filtered_galleries;
138	}
139
140	/**
141	* If a gallery is detected, then get all the images from it.
142	*
143	* @param int $post_id Post ID.
144	* @param int $width Minimum image width to consider.
145	* @param int $height Minimum image height to consider.
146	* @return array Images.
147	*/
148	public static function from_gallery( $post_id, $width = 200, $height = 200 ) {
149	$images = array();
150
151	$post = get_post( $post_id );
152
153	if ( ! $post ) {
154	return $images;
155	}
156
157	if ( ! empty( $post->post_password ) ) {
158	return $images;
159	}
160	add_filter( 'get_post_galleries', array( __CLASS__, 'filter_gallery_urls' ), 999999 );
161
162	$permalink = get_permalink( $post->ID );
163
164	/**
165	* Juggle global post object because the gallery shortcode uses the
166	* global object.
167	*
168	* See core ticket:
169	* https://core.trac.wordpress.org/ticket/39304
170	*/
171	// phpcs:disable WordPress.WP.GlobalVariablesOverride.Prohibited
172	if ( isset( $GLOBALS['post'] ) ) {
173	$juggle_post = $GLOBALS['post'];
174	$GLOBALS['post'] = $post;
175	$galleries = get_post_galleries( $post->ID, false );
176	$GLOBALS['post'] = $juggle_post;
177	} else {
178	$GLOBALS['post'] = $post;
179	$galleries = get_post_galleries( $post->ID, false );
180	unset( $GLOBALS['post'] );
181	}
182	// phpcs:enable WordPress.WP.GlobalVariablesOverride.Prohibited
183
184	foreach ( $galleries as $gallery ) {
185	if ( ! empty( $gallery['ids'] ) ) {
186	$image_ids = explode( ',', $gallery['ids'] );
187	$image_size = isset( $gallery['size'] ) ? $gallery['size'] : 'thumbnail';
188	foreach ( $image_ids as $image_id ) {
189	$image = wp_get_attachment_image_src( $image_id, $image_size );
190	$meta = wp_get_attachment_metadata( $image_id );
191
192	if ( isset( $gallery['type'] ) && 'slideshow' === $gallery['type'] ) {
193	// Must be larger than 200x200 (or user-specified).
194	if ( ! isset( $meta['width'] ) \|\| $meta['width'] < $width ) {
195	continue;
196	}
197	if ( ! isset( $meta['height'] ) \|\| $meta['height'] < $height ) {
198	continue;
199	}
200	}
201
202	if ( ! empty( $image[0] ) ) {
203	list( $raw_src ) = explode( '?', $image[0] ); // pull off any Query string (?w=250).
204	$raw_src = wp_specialchars_decode( $raw_src ); // rawify it.
205	$raw_src = esc_url_raw( $raw_src ); // clean it.
206	$images[] = array(
207	'type' => 'image',
208	'from' => 'gallery',
209	'src' => $raw_src,
210	'src_width' => $meta['width'] ?? 0,
211	'src_height' => $meta['height'] ?? 0,
212	'href' => $permalink,
213	'alt_text' => self::get_alt_text( $image_id ),
214	);
215	}
216	}
217	} elseif ( ! empty( $gallery['src'] ) ) {
218	foreach ( $gallery['src'] as $src ) {
219	list( $raw_src ) = explode( '?', $src ); // pull off any Query string (?w=250).
220	$raw_src = wp_specialchars_decode( $raw_src ); // rawify it.
221	$raw_src = esc_url_raw( $raw_src ); // clean it.
222	$images[] = array(
223	'type' => 'image',
224	'from' => 'gallery',
225	'src' => $raw_src,
226	'href' => $permalink,
227	);
228	}
229	}
230	}
231
232	return $images;
233	}
234
235	/**
236	* Get attachment images for a specified post and return them. Also make sure
237	* their dimensions are at or above a required minimum.
238	*
239	* @param int $post_id The post ID to check.
240	* @param int $width Image width.
241	* @param int $height Image height.
242	* @return array Containing details of the image, or empty array if none.
243	*/
244	public static function from_attachment( $post_id, $width = 200, $height = 200 ) {
245	$images = array();
246
247	$post = get_post( $post_id );
248
249	if ( ! empty( $post->post_password ) ) {
250	return $images;
251	}
252
253	$post_images = get_posts(
254	array(
255	'post_parent' => $post_id, // Must be children of post.
256	'numberposts' => 5, // No more than 5.
257	'post_type' => 'attachment', // Must be attachments.
258	'post_mime_type' => 'image', // Must be images.
259	'suppress_filters' => false,
260	)
261	);
262
263	if ( ! $post_images ) {
264	return $images;
265	}
266
267	$permalink = get_permalink( $post_id );
268
269	foreach ( $post_images as $post_image ) {
270	$current_image = self::get_attachment_data( $post_image->ID, $permalink, $width, $height );
271	if ( false !== $current_image ) {
272	$images[] = $current_image;
273	}
274	}
275
276	/*
277	* We only want to pass back attached images that were actually inserted.
278	* We can load up all the images found in the HTML source and then
279	* compare URLs to see if an image is attached AND inserted.
280	*/
281	$html_images = self::from_html( $post_id );
282	$inserted_images = array();
283
284	foreach ( $html_images as $html_image ) {
285	$src = wp_parse_url( $html_image['src'] );
286	if ( ! $src \|\| empty( $src['path'] ) ) {
287	continue;
288	}
289
290	// strip off any query strings from src.
291	if ( ! empty( $src['scheme'] ) && ! empty( $src['host'] ) ) {
292	$inserted_images[] = $src['scheme'] . '://' . $src['host'] . $src['path'];
293	} elseif ( ! empty( $src['host'] ) ) {
294	$inserted_images[] = set_url_scheme( 'http://' . $src['host'] . $src['path'] );
295	} else {
296	$inserted_images[] = site_url( '/' ) . $src['path'];
297	}
298	}
299	foreach ( $images as $i => $image ) {
300	if ( ! in_array( $image['src'], $inserted_images, true ) ) {
301	unset( $images[ $i ] );
302	}
303	}
304
305	return $images;
306	}
307
308	/**
309	* Check if a Featured Image is set for this post, and return it in a similar
310	* format to the other images?_from_*() methods.
311	*
312	* @param int $post_id The post ID to check.
313	* @param int $width Image width.
314	* @param int $height Image height.
315	* @return array containing details of the Featured Image, or empty array if none.
316	*/
317	public static function from_thumbnail( $post_id, $width = 200, $height = 200 ) {
318	$images = array();
319
320	$post = get_post( $post_id );
321
322	if ( ! empty( $post->post_password ) ) {
323	return $images;
324	}
325
326	if ( 'attachment' === get_post_type( $post ) && wp_attachment_is_image( $post ) ) {
327	$thumb = $post_id;
328	} else {
329	$thumb = get_post_thumbnail_id( $post );
330	}
331
332	if ( $thumb ) {
333	$meta = wp_get_attachment_metadata( $thumb );
334	// Must be larger than requested minimums.
335	if ( ! isset( $meta['width'] ) \|\| $meta['width'] < $width ) {
336	return $images;
337	}
338	if ( ! isset( $meta['height'] ) \|\| $meta['height'] < $height ) {
339	return $images;
340	}
341	$max_dimension = self::get_max_thumbnail_dimension();
342	$too_big = ( ( ! empty( $meta['width'] ) && $meta['width'] > $max_dimension ) \|\| ( ! empty( $meta['height'] ) && $meta['height'] > $max_dimension ) );
343
344	if (
345	$too_big &&
346	(
347	( method_exists( 'Jetpack', 'is_module_active' ) && Jetpack::is_module_active( 'photon' ) ) \|\|
348	( defined( 'IS_WPCOM' ) && IS_WPCOM )
349	)
350	) {
351	$size = self::determine_thumbnail_size_for_photon( $meta['width'], $meta['height'] );
352	$photon_args = array(
353	'fit' => $size['width'] . ',' . $size['height'],
354	);
355	$img_src = array( Image_CDN_Core::cdn_url( wp_get_attachment_url( $thumb ), $photon_args ), $size['width'], $size['height'], true ); // Match the signature of wp_get_attachment_image_src
356	} else {
357	$img_src = wp_get_attachment_image_src( $thumb, 'full' );
358	}
359	if ( ! is_array( $img_src ) ) {
360	// If wp_get_attachment_image_src returns false but we know that there should be an image that could be used.
361	// we try a bit harder and user the data that we have.
362	$thumb_post_data = get_post( $thumb );
363	$img_src = array( $thumb_post_data->guid ?? null, $meta['width'], $meta['height'] );
364	}
365
366	// Let's try to use the postmeta if we can, since it seems to be
367	// more reliable
368	if ( defined( 'IS_WPCOM' ) && IS_WPCOM ) {
369	$featured_image = get_post_meta( $post->ID, '_jetpack_featured_image' );
370	if ( $featured_image ) {
371	$url = $featured_image[0];
372	} else {
373	$url = $img_src[0];
374	}
375	} else {
376	$url = $img_src[0];
377	}
378	$images = array(
379	array( // Other methods below all return an array of arrays.
380	'type' => 'image',
381	'from' => 'thumbnail',
382	'src' => $url,
383	'src_width' => $img_src[1],
384	'src_height' => $img_src[2],
385	'href' => get_permalink( $thumb ),
386	'alt_text' => self::get_alt_text( $thumb ),
387	),
388	);
389
390	}
391
392	if ( empty( $images ) && ( defined( 'IS_WPCOM' ) && IS_WPCOM ) ) {
393	$meta_thumbnail = get_post_meta( $post_id, '_jetpack_post_thumbnail', true );
394	if ( ! empty( $meta_thumbnail ) ) {
395	if ( ! isset( $meta_thumbnail['width'] ) \|\| $meta_thumbnail['width'] < $width ) {
396	return $images;
397	}
398
399	if ( ! isset( $meta_thumbnail['height'] ) \|\| $meta_thumbnail['height'] < $height ) {
400	return $images;
401	}
402
403	$images = array(
404	array( // Other methods below all return an array of arrays.
405	'type' => 'image',
406	'from' => 'thumbnail',
407	'src' => $meta_thumbnail['URL'],
408	'src_width' => $meta_thumbnail['width'],
409	'src_height' => $meta_thumbnail['height'],
410	'href' => $meta_thumbnail['URL'],
411	'alt_text' => self::get_alt_text( $thumb ),
412	),
413	);
414	}
415	}
416
417	return $images;
418	}
419
420	/**
421	* Get images from Gutenberg Image blocks.
422	*
423	* @since 6.9.0
424	*
425	* @param mixed $html_or_id The HTML string to parse for images, or a post id.
426	* @param int $width Minimum Image width.
427	* @param int $height Minimum Image height.
428	*/
429	public static function from_blocks( $html_or_id, $width = 200, $height = 200 ) {
430	$images = array();
431
432	$html_info = self::get_post_html( $html_or_id );
433
434	if ( empty( $html_info['html'] ) ) {
435	return $images;
436	}
437
438	// Look for block information in the HTML.
439	$blocks = parse_blocks( $html_info['html'] );
440	if ( empty( $blocks ) ) {
441	return $images;
442	}
443
444	/*
445	* Let's loop through our blocks.
446	* Some blocks may include some other blocks. Let's go 2 levels deep to look for blocks
447	* that we support and that may include images (see get_images_from_block)
448	*
449	* @to-do: instead of looping manually (that's a lot of if and loops), search recursively instead.
450	*/
451	foreach ( $blocks as $block ) {
452	if ( ! self::is_nested_block( $block ) \|\| 'core/media-text' === $block['blockName'] ) {
453	$images = self::get_images_from_block( $images, $block, $html_info, $width, $height );
454	} else {
455	foreach ( $block['innerBlocks'] as $inner_block ) {
456	if ( ! self::is_nested_block( $inner_block ) ) {
457	$images = self::get_images_from_block( $images, $inner_block, $html_info, $width, $height );
458	} else {
459	foreach ( $inner_block['innerBlocks'] as $inner_inner_block ) {
460	$images = self::get_images_from_block( $images, $inner_inner_block, $html_info, $width, $height );
461	}
462	}
463	}
464	}
465	}
466
467	/**
468	* Returning a filtered array because get_attachment_data returns false
469	* for unsuccessful attempts.
470	*/
471	return array_filter( $images );
472	}
473
474	/**
475	* Very raw -- just parse the HTML and pull out any/all img tags and return their src
476	*
477	* @param mixed $html_or_id The HTML string to parse for images, or a post id.
478	* @param int $width Minimum Image width.
479	* @param int $height Minimum Image height.
480	*
481	* @uses DOMDocument
482	*
483	* @return array containing images
484	*/
485	public static function from_html( $html_or_id, $width = 200, $height = 200 ) {
486	$images = array();
487
488	$html_info = self::get_post_html( $html_or_id );
489
490	if ( empty( $html_info['html'] ) ) {
491	return $images;
492	}
493
494	// Do not go any further if DOMDocument is disabled on the server.
495	if ( ! class_exists( 'DOMDocument' ) ) {
496	return $images;
497	}
498
499	// Let's grab all image tags from the HTML.
500	$dom_doc = new DOMDocument();
501
502	// DOMDocument defaults to ISO-8859 because we're loading only the post content, without head tag.
503	// Fix: Enforce encoding with meta tag.
504	$charset = get_option( 'blog_charset' );
505	if ( empty( $charset ) \|\| ! preg_match( '/^[a-zA-Z0-9_-]+$/', $charset ) ) {
506	$charset = 'UTF-8';
507	}
508	$html_prefix = sprintf( '<meta http-equiv="Content-Type" content="text/html; charset=%s">', esc_attr( $charset ) );
509
510	// The @ is not enough to suppress errors when dealing with libxml,
511	// we have to tell it directly how we want to handle errors.
512	libxml_use_internal_errors( true );
513	@$dom_doc->loadHTML( $html_prefix . $html_info['html'] ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
514	libxml_use_internal_errors( false );
515
516	$image_tags = $dom_doc->getElementsByTagName( 'img' );
517
518	// For each image Tag, make sure it can be added to the $images array, and add it.
519	foreach ( $image_tags as $image_tag ) {
520	$img_src = $image_tag->getAttribute( 'src' );
521
522	if ( empty( $img_src ) ) {
523	continue;
524	}
525
526	// Do not grab smiley images that were automatically created by WP when entering text smilies.
527	if ( stripos( $img_src, '/smilies/' ) ) {
528	continue;
529	}
530
531	// Do not grab Gravatar images.
532	if ( stripos( $img_src, 'gravatar.com' ) ) {
533	continue;
534	}
535
536	// First try to get the width and height from the img attributes, but if they are not set, check to see if they are specified in the url. WordPress automatically names files like foo-1024x768.jpg during the upload process
537	$width = (int) $image_tag->getAttribute( 'width' );
538	$height = (int) $image_tag->getAttribute( 'height' );
539	if ( 0 === $width && 0 === $height ) {
540	preg_match( '/-([0-9]{1,5})x([0-9]{1,5})\.(?:jpg\|jpeg\|png\|gif\|webp)$/i', $img_src, $matches );
541	if ( ! empty( $matches[1] ) ) {
542	$width = (int) $matches[1];
543	}
544	if ( ! empty( $matches[2] ) ) {
545	$height = (int) $matches[2];
546	}
547	}
548	// If width and height are still 0, try to get the id of the image from the class, e.g. wp-image-1234
549	if ( 0 === $width && 0 === $height ) {
550
551	preg_match( '/wp-image-([0-9]+)/', $image_tag->getAttribute( 'class' ), $matches );
552	if ( ! empty( $matches[1] ) ) {
553	$attachment_id = $matches[1];
554	$meta = wp_get_attachment_metadata( $attachment_id );
555	$height = $meta['height'] ?? 0;
556	$width = $meta['width'] ?? 0;
557	}
558	}
559
560	$meta = array(
561	'width' => $width,
562	'height' => $height,
563	'alt_text' => $image_tag->getAttribute( 'alt' ),
564	);
565
566	/**
567	* Filters the switch to ignore minimum image size requirements. Can be used
568	* to add custom logic to image dimensions, like only enforcing one of the dimensions,
569	* or disabling it entirely.
570	*
571	* @since 6.4.0
572	*
573	* @param bool $ignore Should the image dimensions be ignored?
574	* @param array $meta Array containing image dimensions parsed from the markup.
575	*/
576	$ignore_dimensions = apply_filters( 'jetpack_postimages_ignore_minimum_dimensions', false, $meta );
577
578	// Must be larger than 200x200 (or user-specified).
579	if (
580	! $ignore_dimensions
581	&& (
582	empty( $meta['width'] )
583	\|\| empty( $meta['height'] )
584	\|\| $meta['width'] < $width
585	\|\| $meta['height'] < $height
586	)
587	) {
588	continue;
589	}
590
591	$image = array(
592	'type' => 'image',
593	'from' => 'html',
594	'src' => $img_src,
595	'src_width' => $meta['width'],
596	'src_height' => $meta['height'],
597	'href' => $html_info['post_url'],
598	);
599	if ( ! empty( $meta['alt_text'] ) ) {
600	$image['alt_text'] = $meta['alt_text'];
601	}
602	$images[] = $image;
603	}
604	return $images;
605	}
606
607	/**
608	* Data from blavatar.
609	*
610	* @param int $post_id The post ID to check.
611	* @param int $size Size.
612	* @return array containing details of the image, or empty array if none.
613	*/
614	public static function from_blavatar( $post_id, $size = 96 ) {
615
616	$permalink = get_permalink( $post_id );
617
618	if ( function_exists( 'blavatar_domain' ) && function_exists( 'blavatar_exists' ) && function_exists( 'blavatar_url' ) ) {
619	$domain = blavatar_domain( $permalink );
620
621	if ( ! blavatar_exists( $domain ) ) {
622	return array();
623	}
624
625	$url = blavatar_url( $domain, 'img', $size );
626	} else {
627	$url = get_site_icon_url( $size );
628	if ( ! $url ) {
629	return array();
630	}
631	}
632
633	return array(
634	array(
635	'type' => 'image',
636	'from' => 'blavatar',
637	'src' => $url,
638	'src_width' => $size,
639	'src_height' => $size,
640	'href' => $permalink,
641	'alt_text' => '',
642	),
643	);
644	}
645
646	/**
647	* Gets a post image from the author avatar.
648	*
649	* @param int $post_id The post ID to check.
650	* @param int $size The size of the avatar to get.
651	* @param string $default The default image to use.
652	* @return array containing details of the image, or empty array if none.
653	*/
654	public static function from_gravatar( $post_id, $size = 96, $default = false ) {
655	$post = get_post( $post_id );
656	$permalink = get_permalink( $post_id );
657
658	if ( ! $post instanceof WP_Post ) {
659	return array();
660	}
661
662	if ( function_exists( 'wpcom_get_avatar_url' ) ) {
663	$url = wpcom_get_avatar_url( $post->post_author, $size, $default, true );
664	if ( $url && is_array( $url ) ) {
665	$url = $url[0];
666	}
667	} else {
668	$url = get_avatar_url(
669	$post->post_author,
670	array(
671	'size' => $size,
672	'default' => $default,
673	)
674	);
675	}
676
677	return array(
678	array(
679	'type' => 'image',
680	'from' => 'gravatar',
681	'src' => $url,
682	'src_width' => $size,
683	'src_height' => $size,
684	'href' => $permalink,
685	'alt_text' => '',
686	),
687	);
688	}
689
690	/**
691	* Run through the different methods that we have available to try to find a single good
692	* display image for this post.
693	*
694	* @param int $post_id Post ID.
695	* @param array $args Other arguments (currently width and height required for images where possible to determine).
696	* @return array\|null containing details of the best image to be used, or null if no image is found.
697	*/
698	public static function get_image( $post_id, $args = array() ) {
699	$image = null;
700
701	/**
702	* Fires before we find a single good image for a specific post.
703	*
704	* @since 2.2.0
705	*
706	* @param int $post_id Post ID.
707	*/
708	do_action( 'jetpack_postimages_pre_get_image', $post_id );
709	$media = self::get_images( $post_id, $args );
710
711	if ( is_array( $media ) ) {
712	foreach ( $media as $item ) {
713	if ( 'image' === $item['type'] ) {
714	$image = $item;
715	break;
716	}
717	}
718	}
719
720	/**
721	* Fires after we find a single good image for a specific post.
722	*
723	* @since 2.2.0
724	*
725	* @param int $post_id Post ID.
726	*/
727	do_action( 'jetpack_postimages_post_get_image', $post_id );
728
729	return $image;
730	}
731
732	/**
733	* Get an array containing a collection of possible images for this post, stopping once we hit a method
734	* that returns something useful.
735	*
736	* @param int $post_id Post ID.
737	* @param array $args Optional args, see defaults list for details.
738	* @return array containing images that would be good for representing this post
739	*/
740	public static function get_images( $post_id, $args = array() ) {
741	// Figure out which image to attach to this post.
742	$media = array();
743
744	/**
745	* Filters the array of images that would be good for a specific post.
746	* This filter is applied before options ($args) filter the original array.
747	*
748	* @since 2.0.0
749	*
750	* @param array $media Array of images that would be good for a specific post.
751	* @param int $post_id Post ID.
752	* @param array $args Array of options to get images.
753	*/
754	$media = apply_filters( 'jetpack_images_pre_get_images', $media, $post_id, $args );
755	if ( $media ) {
756	return $media;
757	}
758
759	$defaults = array(
760	'width' => 200, // Required minimum width (if possible to determine).
761	'height' => 200, // Required minimum height (if possible to determine).
762
763	'fallback_to_avatars' => false, // Optionally include Blavatar and Gravatar (in that order) in the image stack.
764	'avatar_size' => 96, // Used for both Grav and Blav.
765	'gravatar_default' => false, // Default image to use if we end up with no Gravatar.
766
767	'from_thumbnail' => true, // Use these flags to specify which methods to use to find an image.
768	'from_slideshow' => true,
769	'from_gallery' => true,
770	'from_attachment' => true,
771	'from_blocks' => true,
772	'from_html' => true,
773
774	'html_content' => '', // HTML string to pass to from_html().
775	);
776	$args = wp_parse_args( $args, $defaults );
777
778	$media = array();
779	if ( $args['from_thumbnail'] ) {
780	$media = self::from_thumbnail( $post_id, $args['width'], $args['height'] );
781	}
782	if ( ! $media && $args['from_slideshow'] ) {
783	$media = self::from_slideshow( $post_id, $args['width'], $args['height'] );
784	}
785	if ( ! $media && $args['from_gallery'] ) {
786	$media = self::from_gallery( $post_id );
787	}
788	if ( ! $media && $args['from_attachment'] ) {
789	$media = self::from_attachment( $post_id, $args['width'], $args['height'] );
790	}
791	if ( ! $media && $args['from_blocks'] ) {
792	if ( empty( $args['html_content'] ) ) {
793	$media = self::from_blocks( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content.
794	} else {
795	$media = self::from_blocks( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that.
796	}
797	}
798	if ( ! $media && $args['from_html'] ) {
799	if ( empty( $args['html_content'] ) ) {
800	$media = self::from_html( $post_id, $args['width'], $args['height'] ); // Use the post_id, which will load the content.
801	} else {
802	$media = self::from_html( $args['html_content'], $args['width'], $args['height'] ); // If html_content is provided, use that.
803	}
804	}
805
806	if ( ! $media && $args['fallback_to_avatars'] ) {
807	$media = self::from_blavatar( $post_id, $args['avatar_size'] );
808	if ( ! $media ) {
809	$media = self::from_gravatar( $post_id, $args['avatar_size'], $args['gravatar_default'] );
810	}
811	}
812
813	/**
814	* Filters the array of images that would be good for a specific post.
815	* This filter is applied after options ($args) filter the original array.
816	*
817	* @since 2.0.0
818	*
819	* @param array $media Array of images that would be good for a specific post.
820	* @param int $post_id Post ID.
821	* @param array $args Array of options to get images.
822	*/
823	return apply_filters( 'jetpack_images_get_images', $media, $post_id, $args );
824	}
825
826	/**
827	* Takes an image and base pixel dimensions and returns a srcset for the
828	* resized and cropped images, based on a fixed set of multipliers.
829	*
830	* @param array $image Array containing details of the image.
831	* @param int $base_width Base image width (i.e., the width at 1x).
832	* @param int $base_height Base image height (i.e., the height at 1x).
833	* @param bool $use_widths Whether to generate the srcset with widths instead of multipliers.
834	* @return string The srcset for the image.
835	*/
836	public static function generate_cropped_srcset( $image, $base_width, $base_height, $use_widths = false ) {
837	$srcset = '';
838
839	if ( ! is_array( $image ) \|\| empty( $image['src'] ) \|\| empty( $image['src_width'] ) ) {
840	return $srcset;
841	}
842
843	$multipliers = array( 1, 1.5, 2, 3, 4 );
844	$srcset_values = array();
845	foreach ( $multipliers as $multiplier ) {
846	$srcset_width = (int) ( $base_width * $multiplier );
847	$srcset_height = (int) ( $base_height * $multiplier );
848	if ( $srcset_width < 1 \|\| $srcset_width > $image['src_width'] ) {
849	break;
850	}
851
852	$srcset_url = self::fit_image_url(
853	$image['src'],
854	$srcset_width,
855	$srcset_height
856	);
857
858	if ( $use_widths ) {
859	$srcset_values[] = "{$srcset_url} {$srcset_width}w";
860	} else {
861	$srcset_values[] = "{$srcset_url} {$multiplier}x";
862	}
863	}
864
865	if ( count( $srcset_values ) > 1 ) {
866	$srcset = implode( ', ', $srcset_values );
867	}
868
869	return $srcset;
870	}
871
872	/**
873	* Takes an image URL and pixel dimensions then returns a URL for the
874	* resized and cropped image.
875	*
876	* @param string $src Image URL.
877	* @param int $width Image width.
878	* @param int $height Image height.
879	* @return string Transformed image URL
880	*/
881	public static function fit_image_url( $src, $width, $height ) {
882	$width = (int) $width;
883	$height = (int) $height;
884
885	if ( $width < 1 \|\| $height < 1 ) {
886	return $src;
887	}
888
889	// See if we should bypass WordPress.com SaaS resizing.
890	if ( has_filter( 'jetpack_images_fit_image_url_override' ) ) {
891	/**
892	* Filters the image URL used after dimensions are set by Photon.
893	*
894	* @since 3.3.0
895	*
896	* @param string $src Image URL.
897	* @param int $width Image width.
898	* @param int $width Image height.
899	*/
900	return apply_filters( 'jetpack_images_fit_image_url_override', $src, $width, $height );
901	}
902
903	// If WPCOM hosted image use native transformations.
904	$img_host = wp_parse_url( $src, PHP_URL_HOST );
905	if ( $img_host && str_ends_with( $img_host, '.files.wordpress.com' ) ) {
906	return add_query_arg(
907	array(
908	'w' => $width,
909	'h' => $height,
910	'crop' => 1,
911	),
912	set_url_scheme( $src )
913	);
914	}
915
916	// Use image cdn magic.
917	if ( class_exists( Image_CDN_Core::class ) && method_exists( Image_CDN_Core::class, 'cdn_url' ) ) {
918	return Image_CDN_Core::cdn_url( $src, array( 'resize' => "$width,$height" ) );
919	}
920
921	// Arg... no way to resize image using WordPress.com infrastructure!
922	return $src;
923	}
924
925	/**
926	* Get HTML from given post content.
927	*
928	* @since 6.9.0
929	*
930	* @param mixed $html_or_id The HTML string to parse for images, or a post id.
931	*
932	* @return array $html_info {
933	* @type string $html Post content.
934	* @type string $post_url Post URL.
935	* }
936	*/
937	public static function get_post_html( $html_or_id ) {
938	if ( is_numeric( $html_or_id ) ) {
939	$post = get_post( $html_or_id );
940
941	if ( empty( $post ) \|\| ! empty( $post->post_password ) ) {
942	return '';
943	}
944
945	$html_info = array(
946	'html' => $post->post_content, // DO NOT apply the_content filters here, it will cause loops.
947	'post_url' => get_permalink( $post->ID ),
948	);
949	} else {
950	$html_info = array(
951	'html' => $html_or_id,
952	'post_url' => '',
953	);
954	}
955	return $html_info;
956	}
957
958	/**
959	* Get info about a WordPress attachment.
960	*
961	* @since 6.9.0
962	*
963	* @param int $attachment_id Attachment ID.
964	* @param string $post_url URL of the post, if we have one.
965	* @param int $width Minimum Image width.
966	* @param int $height Minimum Image height.
967	* @return array\|bool Image data or false if unavailable.
968	*/
969	public static function get_attachment_data( $attachment_id, $post_url, $width, $height ) {
970	if ( empty( $attachment_id ) ) {
971	return false;
972	}
973
974	$meta = wp_get_attachment_metadata( $attachment_id );
975
976	if ( empty( $meta ) ) {
977	return false;
978	}
979
980	if ( ! empty( $meta['videopress'] ) ) {
981	// Use poster image for VideoPress videos.
982	$url = $meta['videopress']['poster'];
983	$meta_width = $meta['videopress']['width'];
984	$meta_height = $meta['videopress']['height'];
985	} elseif ( ! empty( $meta['thumb'] ) ) {
986	// On WordPress.com, VideoPress videos have a 'thumb' property with the
987	// poster image filename instead.
988	$media_url = wp_get_attachment_url( $attachment_id );
989	$url = str_replace( wp_basename( $media_url ), $meta['thumb'], $media_url );
990	$meta_width = $meta['width'];
991	$meta_height = $meta['height'];
992	} elseif ( wp_attachment_is( 'video', $attachment_id ) ) {
993	// We don't have thumbnail images for non-VideoPress videos - skip them.
994	return false;
995	} else {
996	if ( ! isset( $meta['width'] ) \|\| ! isset( $meta['height'] ) ) {
997	return false;
998	}
999	$url = wp_get_attachment_url( $attachment_id );
1000	$meta_width = $meta['width'];
1001	$meta_height = $meta['height'];
1002	}
1003
1004	if ( $meta_width < $width \|\| $meta_height < $height ) {
1005	return false;
1006	}
1007
1008	return array(
1009	'type' => 'image',
1010	'from' => 'attachment',
1011	'src' => $url,
1012	'src_width' => $meta_width,
1013	'src_height' => $meta_height,
1014	'href' => $post_url,
1015	'alt_text' => self::get_alt_text( $attachment_id ),
1016	);
1017	}
1018
1019	/**
1020	* Get the alt text for an image or other media from the Media Library.
1021	*
1022	* @since 7.1
1023	*
1024	* @param int $attachment_id The Post ID of the media.
1025	* @return string The alt text value or an empty string.
1026	*/
1027	public static function get_alt_text( $attachment_id ) {
1028	return (string) get_post_meta( $attachment_id, '_wp_attachment_image_alt', true );
1029	}
1030
1031	/**
1032	* Get an image from a block.
1033	*
1034	* @since 7.8.0
1035	*
1036	* @param array $images Images found.
1037	* @param array $block Block and its attributes.
1038	* @param array $html_info Info about the post where the block is found.
1039	* @param int $width Desired image width.
1040	* @param int $height Desired image height.
1041	*
1042	* @return array Array of images found.
1043	*/
1044	private static function get_images_from_block( $images, $block, $html_info, $width, $height ) {
1045	/**
1046	* Parse content from Core Image blocks.
1047	* If it is an image block for an image hosted on our site, it will have an ID.
1048	* If it does not have an ID, let `from_html` parse that content later,
1049	* and extract an image if it has size parameters.
1050	*/
1051	if (
1052	'core/image' === $block['blockName']
1053	&& ! empty( $block['attrs']['id'] )
1054	) {
1055	$images[] = self::get_attachment_data( $block['attrs']['id'], $html_info['post_url'], $width, $height );
1056	} elseif (
1057	'core/media-text' === $block['blockName']
1058	&& ! empty( $block['attrs']['mediaId'] )
1059	) {
1060	$images[] = self::get_attachment_data( $block['attrs']['mediaId'], $html_info['post_url'], $width, $height );
1061	} elseif (
1062	/**
1063	* Parse content from Core Gallery blocks as well from Jetpack's Tiled Gallery and Slideshow blocks.
1064	* Gallery blocks include the ID of each one of the images in the gallery.
1065	*/
1066	in_array( $block['blockName'], array( 'core/gallery', 'jetpack/tiled-gallery', 'jetpack/slideshow' ), true )
1067	&& ! empty( $block['attrs']['ids'] )
1068	) {
1069	foreach ( $block['attrs']['ids'] as $img_id ) {
1070	$images[] = self::get_attachment_data( $img_id, $html_info['post_url'], $width, $height );
1071	}
1072	} elseif (
1073	/**
1074	* Parse content from Jetpack's Story block.
1075	*/
1076	'jetpack/story' === $block['blockName']
1077	&& ! empty( $block['attrs']['mediaFiles'] )
1078	) {
1079	foreach ( $block['attrs']['mediaFiles'] as $media_file ) {
1080	if ( ! empty( $media_file['id'] ) ) {
1081	$images[] = self::get_attachment_data( $media_file['id'], $html_info['post_url'], $width, $height );
1082	}
1083	}
1084	}
1085
1086	return $images;
1087	}
1088
1089	/**
1090	* Check if a block has inner blocks.
1091	*
1092	* @since 7.8.0
1093	*
1094	* @param array $block Block and its attributes.
1095	*
1096	* @return bool
1097	*/
1098	private static function is_nested_block( $block ) {
1099	if ( ! empty( $block['innerBlocks'] ) ) {
1100	return true;
1101	}
1102
1103	return false;
1104	}
1105
1106	/**
1107	* Determine the size to use with Photon for a thumbnail image.
1108	* Images larger than the maximum thumbnail dimension in either dimension are resized to maintain aspect ratio.
1109	*
1110	* @since 14.6
1111	* @see https://github.com/Automattic/jetpack/issues/40349
1112	*
1113	* @param int $width Original image width.
1114	* @param int $height Original image height.
1115	* @return array Array containing the width and height to use with Photon (null means auto).
1116	*/
1117	public static function determine_thumbnail_size_for_photon( $width, $height ) {
1118	$max_dimension = self::get_max_thumbnail_dimension();
1119
1120	// If neither dimension exceeds max size, return original dimensions.
1121	if ( $width <= $max_dimension && $height <= $max_dimension ) {
1122	return array(
1123	'width' => $width,
1124	'height' => $height,
1125	);
1126	}
1127
1128	if ( $width >= $height ) {
1129	// For landscape or square images.
1130	$dims = image_resize_dimensions( $width, $height, $max_dimension, 0 ); // Height will be calculated automatically.
1131	} else {
1132	// For portrait images.
1133	$dims = image_resize_dimensions( $width, $height, 0, $max_dimension ); // Width will be calculated automatically.
1134	}
1135
1136	// $dims can be false if the image is virtually the same size as the max dimension, e.g. wp_fuzzy_number_match.
1137	if ( $dims && isset( $dims[4] ) && isset( $dims[5] ) ) {
1138	return array(
1139	'width' => $dims[4],
1140	'height' => $dims[5],
1141	);
1142	}
1143
1144	return array(
1145	'width' => $width,
1146	'height' => $height,
1147	);
1148	}
1149
1150	/**
1151	* Function to provide the maximum dimension for a thumbnail image.
1152	* Filterable via the `jetpack_post_images_max_dimension` filter.
1153	*
1154	* @since 14.6
1155	* @see https://github.com/Automattic/jetpack/issues/40349
1156	*
1157	* @return int The maximum dimension for a thumbnail image.
1158	*/
1159	public static function get_max_thumbnail_dimension() {
1160	/**
1161	* Filter the maximum dimension allowed for a thumbnail image.
1162	* The default value is 1200 pixels.
1163	*
1164	* @since 14.6
1165	*
1166	* @param int $max_dimension Maximum dimension in pixels.
1167	*/
1168	return (int) apply_filters( 'jetpack_post_images_max_thumbnail_dimension', 1200 );
1169	}
1170	}
1171