Pictures and videos consume the most space in the redirected folders of my users. While I don’t have a great solution for videos yet, I cobbled together a few PowerShell scripts into a single solution. The script below will search a root folder (\\Test\FR\Staff\) and work through each user’s subfolder (\\Test\FR\Staff\jmoody\). It will find any picture greater than your specified resolution and reduce it to a more appropriate size. Even small environments could save several 100 GBs!

I wanted to see how big of a difference this re-sizing could make. I modified the script output to keep the old photo for comparison. To show you the size difference, look at the screenshot below. The new photo is almost 30x smaller than the original photo!  On my 1920×1080 monitor – I can see zero difference in quality.

In the very first line of the PowerShell script, you will need to set your domain name. The next three $UserFolders lines are examples searches. The first will convert pictures only in the Jmoody subfolder. The second will convert the first 10 folders in the root folder. The final example will convert all folders. As you implement this script in your environment, I recommend a roll-out using those three examples. For safety, keep extending the select -first example until you are comfortable converting every picture that is in your folder redirection share.

Here is the script  – I’ll meet you with some more information below it. If your mouse wheel breaks while scrolling down, remember that you can still use the Page Down button on your keyboard. 🙂

$Domain = "Test.local"

#$UserFolders = Get-ChildItem -Path \\Test\FR\Staff\ | where Fullname -Like \\Test\FR\Staff\Jmoody

#$UserFolders = Get-ChildItem -Path \\Test\FR\Staff\ | select -First 10

#$UserFolders = Get-ChildItem -Path \\Test\FR\Staff\


Function Set-Owner {
    <#
        .SYNOPSIS
            Changes owner of a file or folder to another user or group.

        .DESCRIPTION
            Changes owner of a file or folder to another user or group.

        .PARAMETER Path
            The folder or file that will have the owner changed.

        .PARAMETER Account
            Optional parameter to change owner of a file or folder to specified account.

            Default value is 'Builtin\Administrators'

        .PARAMETER Recurse
            Recursively set ownership on subfolders and files beneath given folder.

        .NOTES
            Name: Set-Owner
            Author: Boe Prox
            Version History:
                 1.0 - Boe Prox
                    - Initial Version

        .EXAMPLE
            Set-Owner -Path C:\temp\test.txt

            Description
            -----------
            Changes the owner of test.txt to Builtin\Administrators

        .EXAMPLE
            Set-Owner -Path C:\temp\test.txt -Account 'Domain\bprox

            Description
            -----------
            Changes the owner of test.txt to Domain\bprox

        .EXAMPLE
            Set-Owner -Path C:\temp -Recurse 

            Description
            -----------
            Changes the owner of all files and folders under C:\Temp to Builtin\Administrators

        .EXAMPLE
            Get-ChildItem C:\Temp | Set-Owner -Recurse -Account 'Domain\bprox'

            Description
            -----------
            Changes the owner of all files and folders under C:\Temp to Domain\bprox
    #>
    [cmdletbinding(
        SupportsShouldProcess = $True
    )]
    Param (
        [parameter(ValueFromPipeline=$True,ValueFromPipelineByPropertyName=$True)]
        [Alias('FullName')]
        [string[]]$Path,
        [parameter()]
        [string]$Account = 'Builtin\Administrators',
        [parameter()]
        [switch]$Recurse
    )
    Begin {
        #Prevent Confirmation on each Write-Debug command when using -Debug
        If ($PSBoundParameters['Debug']) {
            $DebugPreference = 'Continue'
        }
        Try {
            [void][TokenAdjuster]
        } Catch {
            $AdjustTokenPrivileges = @"
            using System;
            using System.Runtime.InteropServices;

             public class TokenAdjuster
             {
              [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
              internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall,
              ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);
              [DllImport("kernel32.dll", ExactSpelling = true)]
              internal static extern IntPtr GetCurrentProcess();
              [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
              internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr
              phtok);
              [DllImport("advapi32.dll", SetLastError = true)]
              internal static extern bool LookupPrivilegeValue(string host, string name,
              ref long pluid);
              [StructLayout(LayoutKind.Sequential, Pack = 1)]
              internal struct TokPriv1Luid
              {
               public int Count;
               public long Luid;
               public int Attr;
              }
              internal const int SE_PRIVILEGE_DISABLED = 0x00000000;
              internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
              internal const int TOKEN_QUERY = 0x00000008;
              internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
              public static bool AddPrivilege(string privilege)
              {
               try
               {
                bool retVal;
                TokPriv1Luid tp;
                IntPtr hproc = GetCurrentProcess();
                IntPtr htok = IntPtr.Zero;
                retVal = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
                tp.Count = 1;
                tp.Luid = 0;
                tp.Attr = SE_PRIVILEGE_ENABLED;
                retVal = LookupPrivilegeValue(null, privilege, ref tp.Luid);
                retVal = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
                return retVal;
               }
               catch (Exception ex)
               {
                throw ex;
               }
              }
              public static bool RemovePrivilege(string privilege)
              {
               try
               {
                bool retVal;
                TokPriv1Luid tp;
                IntPtr hproc = GetCurrentProcess();
                IntPtr htok = IntPtr.Zero;
                retVal = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
                tp.Count = 1;
                tp.Luid = 0;
                tp.Attr = SE_PRIVILEGE_DISABLED;
                retVal = LookupPrivilegeValue(null, privilege, ref tp.Luid);
                retVal = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
                return retVal;
               }
               catch (Exception ex)
               {
                throw ex;
               }
              }
             }
"@
            Add-Type $AdjustTokenPrivileges
        }

        #Activate necessary admin privileges to make changes without NTFS perms
        [void][TokenAdjuster]::AddPrivilege("SeRestorePrivilege") #Necessary to set Owner Permissions
        [void][TokenAdjuster]::AddPrivilege("SeBackupPrivilege") #Necessary to bypass Traverse Checking
        [void][TokenAdjuster]::AddPrivilege("SeTakeOwnershipPrivilege") #Necessary to override FilePermissions
    }
    Process {
        ForEach ($Item in $Path) {
            Write-Verbose "FullName: $Item"
            #The ACL objects do not like being used more than once, so re-create them on the Process block
            $DirOwner = New-Object System.Security.AccessControl.DirectorySecurity
            $DirOwner.SetOwner([System.Security.Principal.NTAccount]$Account)
            $FileOwner = New-Object System.Security.AccessControl.FileSecurity
            $FileOwner.SetOwner([System.Security.Principal.NTAccount]$Account)
            $DirAdminAcl = New-Object System.Security.AccessControl.DirectorySecurity
            $FileAdminAcl = New-Object System.Security.AccessControl.DirectorySecurity
            $AdminACL = New-Object System.Security.AccessControl.FileSystemAccessRule('Builtin\Administrators','FullControl','ContainerInherit,ObjectInherit','InheritOnly','Allow')
            $FileAdminAcl.AddAccessRule($AdminACL)
            $DirAdminAcl.AddAccessRule($AdminACL)
            Try {
                $Item = Get-Item -LiteralPath $Item -Force -ErrorAction Stop
                If (-NOT $Item.PSIsContainer) {
                    If ($PSCmdlet.ShouldProcess($Item, 'Set File Owner')) {
                        Try {
                            $Item.SetAccessControl($FileOwner)
                        } Catch {
                            Write-Warning "Couldn't take ownership of $($Item.FullName)! Taking FullControl of $($Item.Directory.FullName)"
                            $Item.Directory.SetAccessControl($FileAdminAcl)
                            $Item.SetAccessControl($FileOwner)
                        }
                    }
                } Else {
                    If ($PSCmdlet.ShouldProcess($Item, 'Set Directory Owner')) {                        
                        Try {
                            $Item.SetAccessControl($DirOwner)
                        } Catch {
                            Write-Warning "Couldn't take ownership of $($Item.FullName)! Taking FullControl of $($Item.Parent.FullName)"
                            $Item.Parent.SetAccessControl($DirAdminAcl) 
                            $Item.SetAccessControl($DirOwner)
                        }
                    }
                    If ($Recurse) {
                        [void]$PSBoundParameters.Remove('Path')
                        Get-ChildItem $Item -Force | Set-Owner @PSBoundParameters
                    }
                }
            } Catch {
                Write-Warning "$($Item): $($_.Exception.Message)"
            }
        }
    }
    End {  
        #Remove priviledges that had been granted
        [void][TokenAdjuster]::RemovePrivilege("SeRestorePrivilege") 
        [void][TokenAdjuster]::RemovePrivilege("SeBackupPrivilege") 
        [void][TokenAdjuster]::RemovePrivilege("SeTakeOwnershipPrivilege")     
    }
}


foreach ($UserFolder in $UserFolders){

$FullName = $UserFolder.FullName

[reflection.assembly]::LoadWithPartialName("System.Drawing")

$SizeLimit=1400          # required size of picture's long side
$logfile="resizelog.txt" # log file for errors
$toresize=$args[0]       # list of directories to find and resize images. can be empty
$toresize=@($FullName+"\")

echo $toresize           # visual control
#Write-Host -NoNewLine ("Press any key.")   # Optional "Press any key"
#$null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
#Write-Host ""

$error.clear()

# first part. find and resize jpgs

Get-ChildItem -recurse $toresize -include *.jpg  | foreach {
  $OldBitmap = new-object System.Drawing.Bitmap $_.FullName # open found jpg
  if ($error.count -ne 0) {                                 # error handling
    $error | out-file $logfile -append -encoding default
    $error[($error.count-1)].TargetObject | out-file $logfile -append -encoding default
    echo $_>>$logfile
    $error.clear()
  }
  $LongSide=$OldBitmap.Width                                # locating long side of picture
  if ($OldBitmap.Width -lt $OldBitmap.Height) { $LongSide=$OldBitmap.Height }
  if ($LongSide -gt $SizeLimit) {                           # if long side is greater than our limit, process jpg
    if ($OldBitmap.Width -lt $OldBitmap.Height) {           # calculate dimensions of picture resize to
      $newH=$SizeLimit
      $newW=[int]($OldBitmap.Width*$SizeLimit/$OldBitmap.Height)
    } else {
      $newW=$SizeLimit
      $newH=[int]($OldBitmap.Height*$newW/$OldBitmap.Width)
    }
    $NewBitmap = new-object System.Drawing.Bitmap $newW,$newH # create new bitmap
    $g=[System.Drawing.Graphics]::FromImage($NewBitmap)
    $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic # use high quality resize algorythm
    $g.DrawImage($OldBitmap, 0, 0, $newW, $newH)              # resize our picture

    $name=$_.DirectoryName+"\"+$_.name+".new"                 # generating name for new picture
    $NewBitmap.Save($name, ([system.drawing.imaging.imageformat]::jpeg)) # save newly created resized jpg
    $NewBitmap.Dispose()                                      # cleaning up our mess
    $OldBitmap.Dispose()
    $n=get-childitem $name
    if ($n.length -ge $_.length) {                            # if resized jpg has greater size than original
      Write-host -NoNewLine "+"                               # draw "+"
      $n.delete()                                             # and delete it
    } else {                                                  # if resized jpg is smaller than original
      if ($n.Exists -and $_.Exists) {
        $name=$_.FullName
        $_.Delete()                                           # delete original
        $n.MoveTo($name)                                      # rename new file to original name (replace old file with new)
        echo ($Name + " " + $LongSide)                        # write its name for visual control
      }
    }
    
  } else {                                                    # if long side is smaller than limit, draw dot for visual
    Write-host -NoNewLine "."
    $OldBitmap.Dispose()
  }
}


#second part. process other than jpgs bitmaps

Get-ChildItem -recurse $toresize -include *.bmp, *.tif, *.gif | foreach {
  $OldBitmap = new-object System.Drawing.Bitmap $_.FullName # open picture
  if ($error.count -ne 0) {                                 # handle errors if any
    $error | out-file $logfile -append -encoding default
    $error[($error.count-1)].TargetObject | out-file $logfile -append -encoding default
    $error.clear()
  }
  $LongSide=$OldBitmap.Width                                # find picture's long side
  if ($OldBitmap.Width -lt $OldBitmap.Height) { $LongSide=$OldBitmap.Height }
  
  if ($LongSide -gt $SizeLimit) {                           # if long side is greater than our limit, process picture
    if ($OldBitmap.Width -lt $OldBitmap.Height) {           # calculating new dimensions
      $newH=$SizeLimit
      $newW=[int]($OldBitmap.Width*$SizeLimit/$OldBitmap.Height)
    } else {
      $newW=$SizeLimit
      $newH=[int]($OldBitmap.Height*$newW/$OldBitmap.Width)
    }
    $NewBitmap = new-object System.Drawing.Bitmap $newW,$newH # create new bitmap
    $g=[System.Drawing.Graphics]::FromImage($NewBitmap)
    $g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
    $g.DrawImage($OldBitmap, 0, 0, $newW, $newH)              # copy resized image to it

    $name=$_.DirectoryName+"\"+$_.name.substring(0, $_.name.indexof($_.extension))+".jpg" # generating new name, jpg extension
    $NewBitmap.Save($name, ([system.drawing.imaging.imageformat]::jpeg)) # save new file
    $NewBitmap.Dispose()
    $OldBitmap.Dispose()
    $n=get-childitem $name
    if ($n.length -ge $_.length) {                             # if new file is longer than original,
      $n.delete()                                              # delete new file
      Write-host -NoNewLine "+"                                # and draw "+" for beauty
    } else {                                                   # if new file is shorter than original (as we expect)
      echo ($Name + " " + $LongSide)                           # draw its name
      $_.Delete()                                              # delete oroginal
    }
  } else {                                                     # if long side is less than our limit, try to recompress it to jpg
    $name=$_.DirectoryName+"\"+$_.name.substring(0, $_.name.indexof($_.extension))+".jpg"
    $OldBitmap.Save($name, ([system.drawing.imaging.imageformat]::jpeg))
    $OldBitmap.Dispose()
    $n=get-childitem $name
    if ($n.length -ge $_.length) {                              # if new jpg is greater than original
      $n.delete()                                               # delete new jpg
      Write-host -NoNewLine "-"                                 # draw "-" for visual control
    } else {
      echo ($Name + " " + $LongSide)                            # draw new file name
      $_.Delete()                                               # delete original
    }
  }
}

$Account = $Domain + "\" + $UserFolder.Name

Set-Owner -Path $FullName -Recurse -Account "$Account"

icacls.exe $FullName /q /c /t /reset

Clear-Variable Account,Fullname
}

This script is configured to find pictures with a long side greater than 1440. Search for $SizeLimit=1400 to change this value.

• If you wish to keep higher resolution pictures, increase this to a value like: 1680 or 1920
• If you wish to keep lower resolution pictures, decrease this to a value like: 1280 or 1152

Though it should go without saying, have a tested backup before doing any large scale modifications like this. If you are the kind of person who prefers not to test a backup, at least keep your resume on another server. 🙂

The only issue that I have had with this script is the converted picture has a new created/modified date (because it is a new file). If you use File Management Tasks for stale data cleanup, older pictures that would have been deleted soon are suddenly new again. Not a big deal as the 30x space savings more than makes up for that!

We have reached the credits portion of this broadcast. The Set-Owner function was written by Boe Prox. The re-sizing picture portion of the script was written by Oleg Medvedev.  The remaining ten lines were written by yours truly.

If you run into issues, have improvements, or just like the script –  I would love to hear from you in the comments. And while you are saving space, have you configured data duplication for your file shares yet?