1 <?php

     2 /**

     3  * WordPress API for media display.

     4  *

     5  * @package WordPress

     6  * @subpackage Media

     7  */

     8 

     9 /**

    10  * Scale down the default size of an image.

    11  *

    12  * This is so that the image is a better fit for the editor and theme.

    13  *

    14  * The $size parameter accepts either an array or a string. The supported string

    15  * values are 'thumb' or 'thumbnail' for the given thumbnail size or defaults at

    16  * 128 width and 96 height in pixels. Also supported for the string value is

    17  * 'medium' and 'full'. The 'full' isn't actually supported, but any value other

    18  * than the supported will result in the content_width size or 500 if that is

    19  * not set.

    20  *

    21  * Finally, there is a filter named 'editor_max_image_size', that will be called

    22  * on the calculated array for width and height, respectively. The second

    23  * parameter will be the value that was in the $size parameter. The returned

    24  * type for the hook is an array with the width as the first element and the

    25  * height as the second element.

    26  *

    27  * @since 2.5.0

    28  * @uses wp_constrain_dimensions() This function passes the widths and the heights.

    29  *

    30  * @param int $width Width of the image

    31  * @param int $height Height of the image

    32  * @param string|array $size Size of what the result image should be.

    33  * @param context Could be 'display' (like in a theme) or 'edit' (like inserting into an editor)

    34  * @return array Width and height of what the result image should resize to.

    35  */

    36 function image_constrain_size_for_editor($width, $height, $size = 'medium', $context = null ) {

    37 	global $content_width, $_wp_additional_image_sizes;

    38 

    39 	if ( ! $context )

    40 		$context = is_admin() ? 'edit' : 'display';

    41 

    42 	if ( is_array($size) ) {

    43 		$max_width = $size[0];

    44 		$max_height = $size[1];

    45 	}

    46 	elseif ( $size == 'thumb' || $size == 'thumbnail' ) {

    47 		$max_width = intval(get_option('thumbnail_size_w'));

    48 		$max_height = intval(get_option('thumbnail_size_h'));

    49 		// last chance thumbnail size defaults

    50 		if ( !$max_width && !$max_height ) {

    51 			$max_width = 128;

    52 			$max_height = 96;

    53 		}

    54 	}

    55 	elseif ( $size == 'medium' ) {

    56 		$max_width = intval(get_option('medium_size_w'));

    57 		$max_height = intval(get_option('medium_size_h'));

    58 		// if no width is set, default to the theme content width if available

    59 	}

    60 	elseif ( $size == 'large' ) {

    61 		// We're inserting a large size image into the editor. If it's a really

    62 		// big image we'll scale it down to fit reasonably within the editor

    63 		// itself, and within the theme's content width if it's known. The user

    64 		// can resize it in the editor if they wish.

    65 		$max_width = intval(get_option('large_size_w'));

    66 		$max_height = intval(get_option('large_size_h'));

    67 		if ( intval($content_width) > 0 )

    68 			$max_width = min( intval($content_width), $max_width );

    69 	} elseif ( isset( $_wp_additional_image_sizes ) && count( $_wp_additional_image_sizes ) && in_array( $size, array_keys( $_wp_additional_image_sizes ) ) ) {

    70 		$max_width = intval( $_wp_additional_image_sizes[$size]['width'] );

    71 		$max_height = intval( $_wp_additional_image_sizes[$size]['height'] );

    72 		if ( intval($content_width) > 0 && 'edit' == $context ) // Only in admin. Assume that theme authors know what they're doing.

    73 			$max_width = min( intval($content_width), $max_width );

    74 	}

    75 	// $size == 'full' has no constraint

    76 	else {

    77 		$max_width = $width;

    78 		$max_height = $height;

    79 	}

    80 

    81 	list( $max_width, $max_height ) = apply_filters( 'editor_max_image_size', array( $max_width, $max_height ), $size, $context );

    82 

    83 	return wp_constrain_dimensions( $width, $height, $max_width, $max_height );

    84 }

    85 

    86 /**

    87  * Retrieve width and height attributes using given width and height values.

    88  *

    89  * Both attributes are required in the sense that both parameters must have a

    90  * value, but are optional in that if you set them to false or null, then they

    91  * will not be added to the returned string.

    92  *

    93  * You can set the value using a string, but it will only take numeric values.

    94  * If you wish to put 'px' after the numbers, then it will be stripped out of

    95  * the return.

    96  *

    97  * @since 2.5.0

    98  *

    99  * @param int|string $width Optional. Width attribute value.

   100  * @param int|string $height Optional. Height attribute value.

   101  * @return string HTML attributes for width and, or height.

   102  */

   103 function image_hwstring($width, $height) {

   104 	$out = '';

   105 	if ($width)

   106 		$out .= 'width="'.intval($width).'" ';

   107 	if ($height)

   108 		$out .= 'height="'.intval($height).'" ';

   109 	return $out;

   110 }

   111 

   112 /**

   113  * Scale an image to fit a particular size (such as 'thumb' or 'medium').

   114  *

   115  * Array with image url, width, height, and whether is intermediate size, in

   116  * that order is returned on success is returned. $is_intermediate is true if

   117  * $url is a resized image, false if it is the original.

   118  *

   119  * The URL might be the original image, or it might be a resized version. This

   120  * function won't create a new resized copy, it will just return an already

   121  * resized one if it exists.

   122  *

   123  * A plugin may use the 'image_downsize' filter to hook into and offer image

   124  * resizing services for images. The hook must return an array with the same

   125  * elements that are returned in the function. The first element being the URL

   126  * to the new image that was resized.

   127  *

   128  * @since 2.5.0

   129  * @uses apply_filters() Calls 'image_downsize' on $id and $size to provide

   130  *		resize services.

   131  *

   132  * @param int $id Attachment ID for image.

   133  * @param array|string $size Optional, default is 'medium'. Size of image, either array or string.

   134  * @return bool|array False on failure, array on success.

   135  */

   136 function image_downsize($id, $size = 'medium') {

   137 

   138 	if ( !wp_attachment_is_image($id) )

   139 		return false;

   140 

   141 	// plugins can use this to provide resize services

   142 	if ( $out = apply_filters( 'image_downsize', false, $id, $size ) )

   143 		return $out;

   144 

   145 	$img_url = wp_get_attachment_url($id);

   146 	$meta = wp_get_attachment_metadata($id);

   147 	$width = $height = 0;

   148 	$is_intermediate = false;

   149 	$img_url_basename = wp_basename($img_url);

   150 

   151 	// try for a new style intermediate size

   152 	if ( $intermediate = image_get_intermediate_size($id, $size) ) {

   153 		$img_url = str_replace($img_url_basename, $intermediate['file'], $img_url);

   154 		$width = $intermediate['width'];

   155 		$height = $intermediate['height'];

   156 		$is_intermediate = true;

   157 	}

   158 	elseif ( $size == 'thumbnail' ) {

   159 		// fall back to the old thumbnail

   160 		if ( ($thumb_file = wp_get_attachment_thumb_file($id)) && $info = getimagesize($thumb_file) ) {

   161 			$img_url = str_replace($img_url_basename, wp_basename($thumb_file), $img_url);

   162 			$width = $info[0];

   163 			$height = $info[1];

   164 			$is_intermediate = true;

   165 		}

   166 	}

   167 	if ( !$width && !$height && isset( $meta['width'], $meta['height'] ) ) {

   168 		// any other type: use the real image

   169 		$width = $meta['width'];

   170 		$height = $meta['height'];

   171 	}

   172 

   173 	if ( $img_url) {

   174 		// we have the actual image size, but might need to further constrain it if content_width is narrower

   175 		list( $width, $height ) = image_constrain_size_for_editor( $width, $height, $size );

   176 

   177 		return array( $img_url, $width, $height, $is_intermediate );

   178 	}

   179 	return false;

   180 

   181 }

   182 

   183 /**

   184  * Registers a new image size

   185  *

   186  * @since 2.9.0

   187  */

   188 function add_image_size( $name, $width = 0, $height = 0, $crop = false ) {

   189 	global $_wp_additional_image_sizes;

   190 	$_wp_additional_image_sizes[$name] = array( 'width' => absint( $width ), 'height' => absint( $height ), 'crop' => (bool) $crop );

   191 }

   192 

   193 /**

   194  * Registers an image size for the post thumbnail

   195  *

   196  * @since 2.9.0

   197  */

   198 function set_post_thumbnail_size( $width = 0, $height = 0, $crop = false ) {

   199 	add_image_size( 'post-thumbnail', $width, $height, $crop );

   200 }

   201 

   202 /**

   203  * An <img src /> tag for an image attachment, scaling it down if requested.

   204  *

   205  * The filter 'get_image_tag_class' allows for changing the class name for the

   206  * image without having to use regular expressions on the HTML content. The

   207  * parameters are: what WordPress will use for the class, the Attachment ID,

   208  * image align value, and the size the image should be.

   209  *

   210  * The second filter 'get_image_tag' has the HTML content, which can then be

   211  * further manipulated by a plugin to change all attribute values and even HTML

   212  * content.

   213  *

   214  * @since 2.5.0

   215  *

   216  * @uses apply_filters() The 'get_image_tag_class' filter is the IMG element

   217  *		class attribute.

   218  * @uses apply_filters() The 'get_image_tag' filter is the full IMG element with

   219  *		all attributes.

   220  *

   221  * @param int $id Attachment ID.

   222  * @param string $alt Image Description for the alt attribute.

   223  * @param string $title Image Description for the title attribute.

   224  * @param string $align Part of the class name for aligning the image.

   225  * @param string $size Optional. Default is 'medium'.

   226  * @return string HTML IMG element for given image attachment

   227  */

   228 function get_image_tag($id, $alt, $title, $align, $size='medium') {

   229 

   230 	list( $img_src, $width, $height ) = image_downsize($id, $size);

   231 	$hwstring = image_hwstring($width, $height);

   232 

   233 	$title = $title ? 'title="' . esc_attr( $title ) . '" ' : '';

   234 

   235 	$class = 'align' . esc_attr($align) .' size-' . esc_attr($size) . ' wp-image-' . $id;

   236 	$class = apply_filters('get_image_tag_class', $class, $id, $align, $size);

   237 

   238 	$html = '<img src="' . esc_attr($img_src) . '" alt="' . esc_attr($alt) . '" ' . $title . $hwstring . 'class="' . $class . '" />';

   239 

   240 	$html = apply_filters( 'get_image_tag', $html, $id, $alt, $title, $align, $size );

   241 

   242 	return $html;

   243 }

   244 

   245 /**

   246  * Calculates the new dimensions for a downsampled image.

   247  *

   248  * If either width or height are empty, no constraint is applied on

   249  * that dimension.

   250  *

   251  * @since 2.5.0

   252  *

   253  * @param int $current_width Current width of the image.

   254  * @param int $current_height Current height of the image.

   255  * @param int $max_width Optional. Maximum wanted width.

   256  * @param int $max_height Optional. Maximum wanted height.

   257  * @return array First item is the width, the second item is the height.

   258  */

   259 function wp_constrain_dimensions( $current_width, $current_height, $max_width=0, $max_height=0 ) {

   260 	if ( !$max_width and !$max_height )

   261 		return array( $current_width, $current_height );

   262 

   263 	$width_ratio = $height_ratio = 1.0;

   264 	$did_width = $did_height = false;

   265 

   266 	if ( $max_width > 0 && $current_width > 0 && $current_width > $max_width ) {

   267 		$width_ratio = $max_width / $current_width;

   268 		$did_width = true;

   269 	}

   270 

   271 	if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height ) {

   272 		$height_ratio = $max_height / $current_height;

   273 		$did_height = true;

   274 	}

   275 

   276 	// Calculate the larger/smaller ratios

   277 	$smaller_ratio = min( $width_ratio, $height_ratio );

   278 	$larger_ratio  = max( $width_ratio, $height_ratio );

   279 

   280 	if ( intval( $current_width * $larger_ratio ) > $max_width || intval( $current_height * $larger_ratio ) > $max_height )

   281  		// The larger ratio is too big. It would result in an overflow.

   282 		$ratio = $smaller_ratio;

   283 	else

   284 		// The larger ratio fits, and is likely to be a more "snug" fit.

   285 		$ratio = $larger_ratio;

   286 

   287 	// Very small dimensions may result in 0, 1 should be the minimum.

   288 	$w = max ( 1, intval( $current_width  * $ratio ) );

   289 	$h = max ( 1, intval( $current_height * $ratio ) );

   290 

   291 	// Sometimes, due to rounding, we'll end up with a result like this: 465x700 in a 177x177 box is 117x176... a pixel short

   292 	// We also have issues with recursive calls resulting in an ever-changing result. Constraining to the result of a constraint should yield the original result.

   293 	// Thus we look for dimensions that are one pixel shy of the max value and bump them up

   294 	if ( $did_width && $w == $max_width - 1 )

   295 		$w = $max_width; // Round it up

   296 	if ( $did_height && $h == $max_height - 1 )

   297 		$h = $max_height; // Round it up

   298 

   299 	return array( $w, $h );

   300 }

   301 

   302 /**

   303  * Retrieve calculated resized dimensions for use in WP_Image_Editor.

   304  *

   305  * Calculate dimensions and coordinates for a resized image that fits within a

   306  * specified width and height. If $crop is true, the largest matching central

   307  * portion of the image will be cropped out and resized to the required size.

   308  *

   309  * @since 2.5.0

   310  * @uses apply_filters() Calls 'image_resize_dimensions' on $orig_w, $orig_h, $dest_w, $dest_h and

   311  *		$crop to provide custom resize dimensions.

   312  *

   313  * @param int $orig_w Original width.

   314  * @param int $orig_h Original height.

   315  * @param int $dest_w New width.

   316  * @param int $dest_h New height.

   317  * @param bool $crop Optional, default is false. Whether to crop image or resize.

   318  * @return bool|array False on failure. Returned array matches parameters for imagecopyresampled() PHP function.

   319  */

   320 function image_resize_dimensions($orig_w, $orig_h, $dest_w, $dest_h, $crop = false) {

   321 

   322 	if ($orig_w <= 0 || $orig_h <= 0)

   323 		return false;

   324 	// at least one of dest_w or dest_h must be specific

   325 	if ($dest_w <= 0 && $dest_h <= 0)

   326 		return false;

   327 

   328 	// plugins can use this to provide custom resize dimensions

   329 	$output = apply_filters( 'image_resize_dimensions', null, $orig_w, $orig_h, $dest_w, $dest_h, $crop );

   330 	if ( null !== $output )

   331 		return $output;

   332 

   333 	if ( $crop ) {

   334 		// crop the largest possible portion of the original image that we can size to $dest_w x $dest_h

   335 		$aspect_ratio = $orig_w / $orig_h;

   336 		$new_w = min($dest_w, $orig_w);

   337 		$new_h = min($dest_h, $orig_h);

   338 

   339 		if ( !$new_w ) {

   340 			$new_w = intval($new_h * $aspect_ratio);

   341 		}

   342 

   343 		if ( !$new_h ) {

   344 			$new_h = intval($new_w / $aspect_ratio);

   345 		}

   346 

   347 		$size_ratio = max($new_w / $orig_w, $new_h / $orig_h);

   348 

   349 		$crop_w = round($new_w / $size_ratio);

   350 		$crop_h = round($new_h / $size_ratio);

   351 

   352 		$s_x = floor( ($orig_w - $crop_w) / 2 );

   353 		$s_y = floor( ($orig_h - $crop_h) / 2 );

   354 	} else {

   355 		// don't crop, just resize using $dest_w x $dest_h as a maximum bounding box

   356 		$crop_w = $orig_w;

   357 		$crop_h = $orig_h;

   358 

   359 		$s_x = 0;

   360 		$s_y = 0;

   361 

   362 		list( $new_w, $new_h ) = wp_constrain_dimensions( $orig_w, $orig_h, $dest_w, $dest_h );

   363 	}

   364 

   365 	// if the resulting image would be the same size or larger we don't want to resize it

   366 	if ( $new_w >= $orig_w && $new_h >= $orig_h )

   367 		return false;

   368 

   369 	// the return array matches the parameters to imagecopyresampled()

   370 	// int dst_x, int dst_y, int src_x, int src_y, int dst_w, int dst_h, int src_w, int src_h

   371 	return array( 0, 0, (int) $s_x, (int) $s_y, (int) $new_w, (int) $new_h, (int) $crop_w, (int) $crop_h );

   372 

   373 }

   374 

   375 /**

   376  * Resize an image to make a thumbnail or intermediate size.

   377  *

   378  * The returned array has the file size, the image width, and image height. The

   379  * filter 'image_make_intermediate_size' can be used to hook in and change the

   380  * values of the returned array. The only parameter is the resized file path.

   381  *

   382  * @since 2.5.0

   383  *

   384  * @param string $file File path.

   385  * @param int $width Image width.

   386  * @param int $height Image height.

   387  * @param bool $crop Optional, default is false. Whether to crop image to specified height and width or resize.

   388  * @return bool|array False, if no image was created. Metadata array on success.

   389  */

   390 function image_make_intermediate_size( $file, $width, $height, $crop = false ) {

   391 	if ( $width || $height ) {

   392 		$editor = wp_get_image_editor( $file );

   393 

   394 		if ( is_wp_error( $editor ) || is_wp_error( $editor->resize( $width, $height, $crop ) ) )

   395 			return false;

   396 

   397 		$resized_file = $editor->save();

   398 

   399 		if ( ! is_wp_error( $resized_file ) && $resized_file ) {

   400 			unset( $resized_file['path'] );

   401 			return $resized_file;

   402 		}

   403 	}

   404 	return false;

   405 }

   406 

   407 /**

   408  * Retrieve the image's intermediate size (resized) path, width, and height.

   409  *

   410  * The $size parameter can be an array with the width and height respectively.

   411  * If the size matches the 'sizes' metadata array for width and height, then it

   412  * will be used. If there is no direct match, then the nearest image size larger

   413  * than the specified size will be used. If nothing is found, then the function

   414  * will break out and return false.

   415  *

   416  * The metadata 'sizes' is used for compatible sizes that can be used for the

   417  * parameter $size value.

   418  *

   419  * The url path will be given, when the $size parameter is a string.

   420  *

   421  * If you are passing an array for the $size, you should consider using

   422  * add_image_size() so that a cropped version is generated. It's much more

   423  * efficient than having to find the closest-sized image and then having the

   424  * browser scale down the image.

   425  *

   426  * @since 2.5.0

   427  * @see add_image_size()

   428  *

   429  * @param int $post_id Attachment ID for image.

   430  * @param array|string $size Optional, default is 'thumbnail'. Size of image, either array or string.

   431  * @return bool|array False on failure or array of file path, width, and height on success.

   432  */

   433 function image_get_intermediate_size($post_id, $size='thumbnail') {

   434 	if ( !is_array( $imagedata = wp_get_attachment_metadata( $post_id ) ) )

   435 		return false;

   436 

   437 	// get the best one for a specified set of dimensions

   438 	if ( is_array($size) && !empty($imagedata['sizes']) ) {

   439 		foreach ( $imagedata['sizes'] as $_size => $data ) {

   440 			// already cropped to width or height; so use this size

   441 			if ( ( $data['width'] == $size[0] && $data['height'] <= $size[1] ) || ( $data['height'] == $size[1] && $data['width'] <= $size[0] ) ) {

   442 				$file = $data['file'];

   443 				list($width, $height) = image_constrain_size_for_editor( $data['width'], $data['height'], $size );

   444 				return compact( 'file', 'width', 'height' );

   445 			}

   446 			// add to lookup table: area => size

   447 			$areas[$data['width'] * $data['height']] = $_size;

   448 		}

   449 		if ( !$size || !empty($areas) ) {

   450 			// find for the smallest image not smaller than the desired size

   451 			ksort($areas);

   452 			foreach ( $areas as $_size ) {

   453 				$data = $imagedata['sizes'][$_size];

   454 				if ( $data['width'] >= $size[0] || $data['height'] >= $size[1] ) {

   455 					// Skip images with unexpectedly divergent aspect ratios (crops)

   456 					// First, we calculate what size the original image would be if constrained to a box the size of the current image in the loop

   457 					$maybe_cropped = image_resize_dimensions($imagedata['width'], $imagedata['height'], $data['width'], $data['height'], false );

   458 					// If the size doesn't match within one pixel, then it is of a different aspect ratio, so we skip it, unless it's the thumbnail size

   459 					if ( 'thumbnail' != $_size && ( !$maybe_cropped || ( $maybe_cropped[4] != $data['width'] && $maybe_cropped[4] + 1 != $data['width'] ) || ( $maybe_cropped[5] != $data['height'] && $maybe_cropped[5] + 1 != $data['height'] ) ) )

   460 						continue;

   461 					// If we're still here, then we're going to use this size

   462 					$file = $data['file'];

   463 					list($width, $height) = image_constrain_size_for_editor( $data['width'], $data['height'], $size );

   464 					return compact( 'file', 'width', 'height' );

   465 				}

   466 			}

   467 		}

   468 	}

   469 

   470 	if ( is_array($size) || empty($size) || empty($imagedata['sizes'][$size]) )

   471 		return false;

   472 

   473 	$data = $imagedata['sizes'][$size];

   474 	// include the full filesystem path of the intermediate file

   475 	if ( empty($data['path']) && !empty($data['file']) ) {

   476 		$file_url = wp_get_attachment_url($post_id);

   477 		$data['path'] = path_join( dirname($imagedata['file']), $data['file'] );

   478 		$data['url'] = path_join( dirname($file_url), $data['file'] );

   479 	}

   480 	return $data;

   481 }

   482 

   483 /**

   484  * Get the available image sizes

   485  * @since 3.0.0

   486  * @return array Returns a filtered array of image size strings

   487  */

   488 function get_intermediate_image_sizes() {

   489 	global $_wp_additional_image_sizes;

   490 	$image_sizes = array('thumbnail', 'medium', 'large'); // Standard sizes

   491 	if ( isset( $_wp_additional_image_sizes ) && count( $_wp_additional_image_sizes ) )

   492 		$image_sizes = array_merge( $image_sizes, array_keys( $_wp_additional_image_sizes ) );

   493 

   494 	return apply_filters( 'intermediate_image_sizes', $image_sizes );

   495 }

   496 

   497 /**

   498  * Retrieve an image to represent an attachment.

   499  *

   500  * A mime icon for files, thumbnail or intermediate size for images.

   501  *

   502  * @since 2.5.0

   503  *

   504  * @param int $attachment_id Image attachment ID.

   505  * @param string $size Optional, default is 'thumbnail'.

   506  * @param bool $icon Optional, default is false. Whether it is an icon.

   507  * @return bool|array Returns an array (url, width, height), or false, if no image is available.

   508  */

   509 function wp_get_attachment_image_src($attachment_id, $size='thumbnail', $icon = false) {

   510 

   511 	// get a thumbnail or intermediate image if there is one

   512 	if ( $image = image_downsize($attachment_id, $size) )

   513 		return $image;

   514 

   515 	$src = false;

   516 

   517 	if ( $icon && $src = wp_mime_type_icon($attachment_id) ) {

   518 		$icon_dir = apply_filters( 'icon_dir', ABSPATH . WPINC . '/images/crystal' );

   519 		$src_file = $icon_dir . '/' . wp_basename($src);

   520 		@list($width, $height) = getimagesize($src_file);

   521 	}

   522 	if ( $src && $width && $height )

   523 		return array( $src, $width, $height );

   524 	return false;

   525 }

   526 

   527 /**

   528  * Get an HTML img element representing an image attachment

   529  *

   530  * While $size will accept an array, it is better to register a size with

   531  * add_image_size() so that a cropped version is generated. It's much more

   532  * efficient than having to find the closest-sized image and then having the

   533  * browser scale down the image.

   534  *

   535  * @see add_image_size()

   536  * @uses apply_filters() Calls 'wp_get_attachment_image_attributes' hook on attributes array

   537  * @uses wp_get_attachment_image_src() Gets attachment file URL and dimensions

   538  * @since 2.5.0

   539  *

   540  * @param int $attachment_id Image attachment ID.

   541  * @param string $size Optional, default is 'thumbnail'.

   542  * @param bool $icon Optional, default is false. Whether it is an icon.

   543  * @param mixed $attr Optional, attributes for the image markup.

   544  * @return string HTML img element or empty string on failure.

   545  */

   546 function wp_get_attachment_image($attachment_id, $size = 'thumbnail', $icon = false, $attr = '') {

   547 

   548 	$html = '';

   549 	$image = wp_get_attachment_image_src($attachment_id, $size, $icon);

   550 	if ( $image ) {

   551 		list($src, $width, $height) = $image;

   552 		$hwstring = image_hwstring($width, $height);

   553 		if ( is_array($size) )

   554 			$size = join('x', $size);

   555 		$attachment = get_post($attachment_id);

   556 		$default_attr = array(

   557 			'src'	=> $src,

   558 			'class'	=> "attachment-$size",

   559 			'alt'	=> trim(strip_tags( get_post_meta($attachment_id, '_wp_attachment_image_alt', true) )), // Use Alt field first

   560 		);

   561 		if ( empty($default_attr['alt']) )

   562 			$default_attr['alt'] = trim(strip_tags( $attachment->post_excerpt )); // If not, Use the Caption

   563 		if ( empty($default_attr['alt']) )

   564 			$default_attr['alt'] = trim(strip_tags( $attachment->post_title )); // Finally, use the title

   565 

   566 		$attr = wp_parse_args($attr, $default_attr);

   567 		$attr = apply_filters( 'wp_get_attachment_image_attributes', $attr, $attachment );

   568 		$attr = array_map( 'esc_attr', $attr );

   569 		$html = rtrim("<img $hwstring");

   570 		foreach ( $attr as $name => $value ) {

   571 			$html .= " $name=" . '"' . $value . '"';

   572 		}

   573 		$html .= ' />';

   574 	}

   575 

   576 	return $html;

   577 }

   578 

   579 /**

   580  * Adds a 'wp-post-image' class to post thumbnails

   581  * Uses the begin_fetch_post_thumbnail_html and end_fetch_post_thumbnail_html action hooks to

   582  * dynamically add/remove itself so as to only filter post thumbnails

   583  *

   584  * @since 2.9.0

   585  * @param array $attr Attributes including src, class, alt, title

   586  * @return array

   587  */

   588 function _wp_post_thumbnail_class_filter( $attr ) {

   589 	$attr['class'] .= ' wp-post-image';

   590 	return $attr;

   591 }

   592 

   593 /**

   594  * Adds _wp_post_thumbnail_class_filter to the wp_get_attachment_image_attributes filter

   595  *

   596  * @since 2.9.0

   597  */

   598 function _wp_post_thumbnail_class_filter_add( $attr ) {

   599 	add_filter( 'wp_get_attachment_image_attributes', '_wp_post_thumbnail_class_filter' );

   600 }

   601 

   602 /**

   603  * Removes _wp_post_thumbnail_class_filter from the wp_get_attachment_image_attributes filter

   604  *

   605  * @since 2.9.0

   606  */

   607 function _wp_post_thumbnail_class_filter_remove( $attr ) {

   608 	remove_filter( 'wp_get_attachment_image_attributes', '_wp_post_thumbnail_class_filter' );

   609 }

   610 

   611 add_shortcode('wp_caption', 'img_caption_shortcode');

   612 add_shortcode('caption', 'img_caption_shortcode');

   613 

   614 /**

   615  * The Caption shortcode.

   616  *

   617  * Allows a plugin to replace the content that would otherwise be returned. The

   618  * filter is 'img_caption_shortcode' and passes an empty string, the attr

   619  * parameter and the content parameter values.

   620  *

   621  * The supported attributes for the shortcode are 'id', 'align', 'width', and

   622  * 'caption'.

   623  *

   624  * @since 2.6.0

   625  *

   626  * @param array $attr Attributes attributed to the shortcode.

   627  * @param string $content Optional. Shortcode content.

   628  * @return string

   629  */

   630 function img_caption_shortcode($attr, $content = null) {

   631 	// New-style shortcode with the caption inside the shortcode with the link and image tags.

   632 	if ( ! isset( $attr['caption'] ) ) {

   633 		if ( preg_match( '#((?:<a [^>]+>\s*)?<img [^>]+>(?:\s*</a>)?)(.*)#is', $content, $matches ) ) {

   634 			$content = $matches[1];

   635 			$attr['caption'] = trim( $matches[2] );

   636 		}

   637 	}

   638 

   639 	// Allow plugins/themes to override the default caption template.

   640 	$output = apply_filters('img_caption_shortcode', '', $attr, $content);

   641 	if ( $output != '' )

   642 		return $output;

   643 

   644 	$atts = shortcode_atts( array(

   645 		'id'	  => '',

   646 		'align'	  => 'alignnone',

   647 		'width'	  => '',

   648 		'caption' => ''

   649 	), $attr, 'caption' );

   650 

   651 	$atts['width'] = (int) $atts['width'];

   652 	if ( $atts['width'] < 1 || empty( $atts['caption'] ) )

   653 		return $content;

   654 

   655 	if ( ! empty( $atts['id'] ) )

   656 		$atts['id'] = 'id="' . esc_attr( $atts['id'] ) . '" ';

   657 

   658 	$caption_width = 10 + $atts['width'];

   659 

   660 	/**

   661 	 * Filter the width of an image's caption.

   662 	 *

   663 	 * By default, the caption is 10 pixels greater than the width of the image,

   664 	 * to prevent post content from running up against a floated image.

   665 	 *

   666 	 * @since 3.7.0

   667 	 *

   668 	 * @param int $caption_width Width in pixels. To remove this inline style, return zero.

   669 	 * @param array $atts {

   670 	 *     The attributes of the caption shortcode.

   671 	 *

   672 	 *     @type string 'id'      The ID of the div element for the caption.

   673 	 *     @type string 'align'   The class name that aligns the caption. Default 'alignnone'.

   674 	 *     @type int    'width'   The width of the image being captioned.

   675 	 *     @type string 'caption' The image's caption.

   676 	 * }

   677 	 * @param string $content The image element, possibly wrapped in a hyperlink.

   678 	 */

   679 	$caption_width = apply_filters( 'img_caption_shortcode_width', $caption_width, $atts, $content );

   680 

   681 	$style = '';

   682 	if ( $caption_width )

   683 		$style = 'style="width: ' . (int) $caption_width . 'px" ';

   684 

   685 	return '<div ' . $atts['id'] . $style . 'class="wp-caption ' . esc_attr( $atts['align'] ) . '">'

   686 	. do_shortcode( $content ) . '<p class="wp-caption-text">' . $atts['caption'] . '</p></div>';

   687 }

   688 

   689 add_shortcode('gallery', 'gallery_shortcode');

   690 

   691 /**

   692  * The Gallery shortcode.

   693  *

   694  * This implements the functionality of the Gallery Shortcode for displaying

   695  * WordPress images on a post.

   696  *

   697  * @since 2.5.0

   698  *

   699  * @param array $attr Attributes of the shortcode.

   700  * @return string HTML content to display gallery.

   701  */

   702 function gallery_shortcode($attr) {

   703 	$post = get_post();

   704 

   705 	static $instance = 0;

   706 	$instance++;

   707 

   708 	if ( ! empty( $attr['ids'] ) ) {

   709 		// 'ids' is explicitly ordered, unless you specify otherwise.

   710 		if ( empty( $attr['orderby'] ) )

   711 			$attr['orderby'] = 'post__in';

   712 		$attr['include'] = $attr['ids'];

   713 	}

   714 

   715 	// Allow plugins/themes to override the default gallery template.

   716 	$output = apply_filters('post_gallery', '', $attr);

   717 	if ( $output != '' )

   718 		return $output;

   719 

   720 	// We're trusting author input, so let's at least make sure it looks like a valid orderby statement

   721 	if ( isset( $attr['orderby'] ) ) {

   722 		$attr['orderby'] = sanitize_sql_orderby( $attr['orderby'] );

   723 		if ( !$attr['orderby'] )

   724 			unset( $attr['orderby'] );

   725 	}

   726 

   727 	extract(shortcode_atts(array(

   728 		'order'      => 'ASC',

   729 		'orderby'    => 'menu_order ID',

   730 		'id'         => $post ? $post->ID : 0,

   731 		'itemtag'    => 'dl',

   732 		'icontag'    => 'dt',

   733 		'captiontag' => 'dd',

   734 		'columns'    => 3,

   735 		'size'       => 'thumbnail',

   736 		'include'    => '',

   737 		'exclude'    => '',

   738 		'link'       => ''

   739 	), $attr, 'gallery'));

   740 

   741 	$id = intval($id);

   742 	if ( 'RAND' == $order )

   743 		$orderby = 'none';

   744 

   745 	if ( !empty($include) ) {

   746 		$_attachments = get_posts( array('include' => $include, 'post_status' => 'inherit', 'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => $order, 'orderby' => $orderby) );

   747 

   748 		$attachments = array();

   749 		foreach ( $_attachments as $key => $val ) {

   750 			$attachments[$val->ID] = $_attachments[$key];

   751 		}

   752 	} elseif ( !empty($exclude) ) {

   753 		$attachments = get_children( array('post_parent' => $id, 'exclude' => $exclude, 'post_status' => 'inherit', 'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => $order, 'orderby' => $orderby) );

   754 	} else {

   755 		$attachments = get_children( array('post_parent' => $id, 'post_status' => 'inherit', 'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => $order, 'orderby' => $orderby) );

   756 	}

   757 

   758 	if ( empty($attachments) )

   759 		return '';

   760 

   761 	if ( is_feed() ) {

   762 		$output = "\n";

   763 		foreach ( $attachments as $att_id => $attachment )

   764 			$output .= wp_get_attachment_link($att_id, $size, true) . "\n";

   765 		return $output;

   766 	}

   767 

   768 	$itemtag = tag_escape($itemtag);

   769 	$captiontag = tag_escape($captiontag);

   770 	$icontag = tag_escape($icontag);

   771 	$valid_tags = wp_kses_allowed_html( 'post' );

   772 	if ( ! isset( $valid_tags[ $itemtag ] ) )

   773 		$itemtag = 'dl';

   774 	if ( ! isset( $valid_tags[ $captiontag ] ) )

   775 		$captiontag = 'dd';

   776 	if ( ! isset( $valid_tags[ $icontag ] ) )

   777 		$icontag = 'dt';

   778 

   779 	$columns = intval($columns);

   780 	$itemwidth = $columns > 0 ? floor(100/$columns) : 100;

   781 	$float = is_rtl() ? 'right' : 'left';

   782 

   783 	$selector = "gallery-{$instance}";

   784 

   785 	$gallery_style = $gallery_div = '';

   786 	if ( apply_filters( 'use_default_gallery_style', true ) )

   787 		$gallery_style = "

   788 		<style type='text/css'>

   789 			#{$selector} {

   790 				margin: auto;

   791 			}

   792 			#{$selector} .gallery-item {

   793 				float: {$float};

   794 				margin-top: 10px;

   795 				text-align: center;

   796 				width: {$itemwidth}%;

   797 			}

   798 			#{$selector} img {

   799 				border: 2px solid #cfcfcf;

   800 			}

   801 			#{$selector} .gallery-caption {

   802 				margin-left: 0;

   803 			}

   804 			/* see gallery_shortcode() in wp-includes/media.php */

   805 		</style>";

   806 	$size_class = sanitize_html_class( $size );

   807 	$gallery_div = "<div id='$selector' class='gallery galleryid-{$id} gallery-columns-{$columns} gallery-size-{$size_class}'>";

   808 	$output = apply_filters( 'gallery_style', $gallery_style . "\n\t\t" . $gallery_div );

   809 

   810 	$i = 0;

   811 	foreach ( $attachments as $id => $attachment ) {

   812 		if ( ! empty( $link ) && 'file' === $link )

   813 			$image_output = wp_get_attachment_link( $id, $size, false, false );

   814 		elseif ( ! empty( $link ) && 'none' === $link )

   815 			$image_output = wp_get_attachment_image( $id, $size, false );

   816 		else

   817 			$image_output = wp_get_attachment_link( $id, $size, true, false );

   818 

   819 		$image_meta  = wp_get_attachment_metadata( $id );

   820 

   821 		$orientation = '';

   822 		if ( isset( $image_meta['height'], $image_meta['width'] ) )

   823 			$orientation = ( $image_meta['height'] > $image_meta['width'] ) ? 'portrait' : 'landscape';

   824 

   825 		$output .= "<{$itemtag} class='gallery-item'>";

   826 		$output .= "

   827 			<{$icontag} class='gallery-icon {$orientation}'>

   828 				$image_output

   829 			</{$icontag}>";

   830 		if ( $captiontag && trim($attachment->post_excerpt) ) {

   831 			$output .= "

   832 				<{$captiontag} class='wp-caption-text gallery-caption'>

   833 				" . wptexturize($attachment->post_excerpt) . "

   834 				</{$captiontag}>";

   835 		}

   836 		$output .= "</{$itemtag}>";

   837 		if ( $columns > 0 && ++$i % $columns == 0 )

   838 			$output .= '<br style="clear: both" />';

   839 	}

   840 

   841 	$output .= "

   842 			<br style='clear: both;' />

   843 		</div>\n";

   844 

   845 	return $output;

   846 }

   847 

   848 /**

   849  * Provide a No-JS Flash fallback as a last resort for audio / video

   850  *

   851  * @since 3.6.0

   852  *

   853  * @param string $url

   854  * @return string Fallback HTML

   855  */

   856 function wp_mediaelement_fallback( $url ) {

   857 	return apply_filters( 'wp_mediaelement_fallback', sprintf( '<a href="%1$s">%1$s</a>', esc_url( $url ) ), $url );

   858 }

   859 

   860 /**

   861  * Return a filtered list of WP-supported audio formats

   862  *

   863  * @since 3.6.0

   864  * @return array

   865  */

   866 function wp_get_audio_extensions() {

   867 	return apply_filters( 'wp_audio_extensions', array( 'mp3', 'ogg', 'wma', 'm4a', 'wav' ) );

   868 }

   869 

   870 /**

   871  * The Audio shortcode.

   872  *

   873  * This implements the functionality of the Audio Shortcode for displaying

   874  * WordPress mp3s in a post.

   875  *

   876  * @since 3.6.0

   877  *

   878  * @param array  $attr    Attributes of the shortcode.

   879  * @param string $content Optional. Shortcode content.

   880  * @return string HTML content to display audio.

   881  */

   882 function wp_audio_shortcode( $attr, $content = '' ) {

   883 	$post_id = get_post() ? get_the_ID() : 0;

   884 

   885 	static $instances = 0;

   886 	$instances++;

   887 

   888 	/**

   889 	 * Override the default audio shortcode.

   890 	 *

   891 	 * @since 3.7.0

   892 	 *

   893 	 * @param null              Empty variable to be replaced with shortcode markup.

   894 	 * @param array  $attr      Attributes of the shortcode.

   895 	 * @param string $content   Shortcode content.

   896 	 * @param int    $instances Unique numeric ID of this audio shortcode instance.

   897 	 */

   898 	$html = apply_filters( 'wp_audio_shortcode_override', '', $attr, $content, $instances );

   899 	if ( '' !== $html )

   900 		return $html;

   901 

   902 	$audio = null;

   903 

   904 	$default_types = wp_get_audio_extensions();

   905 	$defaults_atts = array(

   906 		'src'      => '',

   907 		'loop'     => '',

   908 		'autoplay' => '',

   909 		'preload'  => 'none'

   910 	);

   911 	foreach ( $default_types as $type )

   912 		$defaults_atts[$type] = '';

   913 

   914 	$atts = shortcode_atts( $defaults_atts, $attr, 'audio' );

   915 	extract( $atts );

   916 

   917 	$primary = false;

   918 	if ( ! empty( $src ) ) {

   919 		$type = wp_check_filetype( $src, wp_get_mime_types() );

   920 		if ( ! in_array( strtolower( $type['ext'] ), $default_types ) )

   921 			return sprintf( '<a class="wp-embedded-audio" href="%s">%s</a>', esc_url( $src ), esc_html( $src ) );

   922 		$primary = true;

   923 		array_unshift( $default_types, 'src' );

   924 	} else {

   925 		foreach ( $default_types as $ext ) {

   926 			if ( ! empty( $$ext ) ) {

   927 				$type = wp_check_filetype( $$ext, wp_get_mime_types() );

   928 				if ( strtolower( $type['ext'] ) === $ext )

   929 					$primary = true;

   930 			}

   931 		}

   932 	}

   933 

   934 	if ( ! $primary ) {

   935 		$audios = get_attached_media( 'audio', $post_id );

   936 		if ( empty( $audios ) )

   937 			return;

   938 

   939 		$audio = reset( $audios );

   940 		$src = wp_get_attachment_url( $audio->ID );

   941 		if ( empty( $src ) )

   942 			return;

   943 

   944 		array_unshift( $default_types, 'src' );

   945 	}

   946 

   947 	$library = apply_filters( 'wp_audio_shortcode_library', 'mediaelement' );

   948 	if ( 'mediaelement' === $library && did_action( 'init' ) ) {

   949 		wp_enqueue_style( 'wp-mediaelement' );

   950 		wp_enqueue_script( 'wp-mediaelement' );

   951 	}

   952 

   953 	$atts = array(

   954 		'class'    => apply_filters( 'wp_audio_shortcode_class', 'wp-audio-shortcode' ),

   955 		'id'       => sprintf( 'audio-%d-%d', $post_id, $instances ),

   956 		'loop'     => $loop,

   957 		'autoplay' => $autoplay,

   958 		'preload'  => $preload,

   959 		'style'    => 'width: 100%',

   960 	);

   961 

   962 	// These ones should just be omitted altogether if they are blank

   963 	foreach ( array( 'loop', 'autoplay', 'preload' ) as $a ) {

   964 		if ( empty( $atts[$a] ) )

   965 			unset( $atts[$a] );

   966 	}

   967 

   968 	$attr_strings = array();

   969 	foreach ( $atts as $k => $v ) {

   970 		$attr_strings[] = $k . '="' . esc_attr( $v ) . '"';

   971 	}

   972 

   973 	$html = '';

   974 	if ( 'mediaelement' === $library && 1 === $instances )

   975 		$html .= "<!--[if lt IE 9]><script>document.createElement('audio');</script><![endif]-->\n";

   976 	$html .= sprintf( '<audio %s controls="controls">', join( ' ', $attr_strings ) );

   977 

   978 	$fileurl = '';

   979 	$source = '<source type="%s" src="%s" />';

   980 	foreach ( $default_types as $fallback ) {

   981 		if ( ! empty( $$fallback ) ) {

   982 			if ( empty( $fileurl ) )

   983 				$fileurl = $$fallback;

   984 			$type = wp_check_filetype( $$fallback, wp_get_mime_types() );

   985 			$html .= sprintf( $source, $type['type'], esc_url( $$fallback ) );

   986 		}

   987 	}

   988 

   989 	if ( 'mediaelement' === $library )

   990 		$html .= wp_mediaelement_fallback( $fileurl );

   991 	$html .= '</audio>';

   992 

   993 	return apply_filters( 'wp_audio_shortcode', $html, $atts, $audio, $post_id, $library );

   994 }

   995 add_shortcode( 'audio', 'wp_audio_shortcode' );

   996 

   997 /**

   998  * Return a filtered list of WP-supported video formats

   999  *

  1000  * @since 3.6.0

  1001  * @return array

  1002  */

  1003 function wp_get_video_extensions() {

  1004 	return apply_filters( 'wp_video_extensions', array( 'mp4', 'm4v', 'webm', 'ogv', 'wmv', 'flv' ) );

  1005 }

  1006 

  1007 /**

  1008  * The Video shortcode.

  1009  *

  1010  * This implements the functionality of the Video Shortcode for displaying

  1011  * WordPress mp4s in a post.

  1012  *

  1013  * @since 3.6.0

  1014  *

  1015  * @param array  $attr    Attributes of the shortcode.

  1016  * @param string $content Optional. Shortcode content.

  1017  * @return string HTML content to display video.

  1018  */

  1019 function wp_video_shortcode( $attr, $content = '' ) {

  1020 	global $content_width;

  1021 	$post_id = get_post() ? get_the_ID() : 0;

  1022 

  1023 	static $instances = 0;

  1024 	$instances++;

  1025 

  1026 	/**

  1027 	 * Override the default video shortcode.

  1028 	 *

  1029 	 * @since 3.7.0

  1030 	 *

  1031 	 * @param null              Empty variable to be replaced with shortcode markup.

  1032 	 * @param array  $attr      Attributes of the shortcode.

  1033 	 * @param string $content   Shortcode content.

  1034 	 * @param int    $instances Unique numeric ID of this video shortcode instance.

  1035 	 */

  1036 	$html = apply_filters( 'wp_video_shortcode_override', '', $attr, $content, $instances );

  1037 	if ( '' !== $html )

  1038 		return $html;

  1039 

  1040 	$video = null;

  1041 

  1042 	$default_types = wp_get_video_extensions();

  1043 	$defaults_atts = array(

  1044 		'src'      => '',

  1045 		'poster'   => '',

  1046 		'loop'     => '',

  1047 		'autoplay' => '',

  1048 		'preload'  => 'metadata',

  1049 		'height'   => 360,

  1050 		'width'    => empty( $content_width ) ? 640 : $content_width,

  1051 	);

  1052 

  1053 	foreach ( $default_types as $type )

  1054 		$defaults_atts[$type] = '';

  1055 

  1056 	$atts = shortcode_atts( $defaults_atts, $attr, 'video' );

  1057 	extract( $atts );

  1058 

  1059 	$w = $width;

  1060 	$h = $height;

  1061 	if ( is_admin() && $width > 600 )

  1062 		$w = 600;

  1063 	elseif ( ! is_admin() && $w > $defaults_atts['width'] )

  1064 		$w = $defaults_atts['width'];

  1065 

  1066 	if ( $w < $width )

  1067 		$height = round( ( $h * $w ) / $width );

  1068 

  1069 	$width = $w;

  1070 

  1071 	$primary = false;

  1072 	if ( ! empty( $src ) ) {

  1073 		$type = wp_check_filetype( $src, wp_get_mime_types() );

  1074 		if ( ! in_array( strtolower( $type['ext'] ), $default_types ) )

  1075 			return sprintf( '<a class="wp-embedded-video" href="%s">%s</a>', esc_url( $src ), esc_html( $src ) );

  1076 		$primary = true;

  1077 		array_unshift( $default_types, 'src' );

  1078 	} else {

  1079 		foreach ( $default_types as $ext ) {

  1080 			if ( ! empty( $$ext ) ) {

  1081 				$type = wp_check_filetype( $$ext, wp_get_mime_types() );

  1082 				if ( strtolower( $type['ext'] ) === $ext )

  1083 					$primary = true;

  1084 			}

  1085 		}

  1086 	}

  1087 

  1088 	if ( ! $primary ) {

  1089 		$videos = get_attached_media( 'video', $post_id );

  1090 		if ( empty( $videos ) )

  1091 			return;

  1092 

  1093 		$video = reset( $videos );

  1094 		$src = wp_get_attachment_url( $video->ID );

  1095 		if ( empty( $src ) )

  1096 			return;

  1097 

  1098 		array_unshift( $default_types, 'src' );

  1099 	}

  1100 

  1101 	$library = apply_filters( 'wp_video_shortcode_library', 'mediaelement' );

  1102 	if ( 'mediaelement' === $library && did_action( 'init' ) ) {

  1103 		wp_enqueue_style( 'wp-mediaelement' );

  1104 		wp_enqueue_script( 'wp-mediaelement' );

  1105 	}

  1106 

  1107 	$atts = array(

  1108 		'class'    => apply_filters( 'wp_video_shortcode_class', 'wp-video-shortcode' ),

  1109 		'id'       => sprintf( 'video-%d-%d', $post_id, $instances ),

  1110 		'width'    => absint( $width ),

  1111 		'height'   => absint( $height ),

  1112 		'poster'   => esc_url( $poster ),

  1113 		'loop'     => $loop,

  1114 		'autoplay' => $autoplay,

  1115 		'preload'  => $preload,

  1116 	);

  1117 

  1118 	// These ones should just be omitted altogether if they are blank

  1119 	foreach ( array( 'poster', 'loop', 'autoplay', 'preload' ) as $a ) {

  1120 		if ( empty( $atts[$a] ) )

  1121 			unset( $atts[$a] );

  1122 	}

  1123 

  1124 	$attr_strings = array();

  1125 	foreach ( $atts as $k => $v ) {

  1126 		$attr_strings[] = $k . '="' . esc_attr( $v ) . '"';

  1127 	}

  1128 

  1129 	$html = '';

  1130 	if ( 'mediaelement' === $library && 1 === $instances )

  1131 		$html .= "<!--[if lt IE 9]><script>document.createElement('video');</script><![endif]-->\n";

  1132 	$html .= sprintf( '<video %s controls="controls">', join( ' ', $attr_strings ) );

  1133 

  1134 	$fileurl = '';

  1135 	$source = '<source type="%s" src="%s" />';