How to accept 'multiple files' or 'single directory' to single parameter on PowerShell?

I'm trying to write a PowerShell script for processing files with FFmpeg.

Since I'm trying to use it with PowerShell v5.1 which is shipped with Windows, I'm trying to code it with PowerShell v5.1. If it isn't possible with PowerShell v5.1, it is OK to use with latest PowerShell.

Because Windows doesn't allow PowerShell script to be executed from 'Run' or Command Prompt, I'll use additional batch script like this to be used with PowerShell script:

@echo off
powershell -File .\ff.ps1 %*

With this, I can pass every parameter and arguments to PowerShell script from Command Prompt.

The command syntax would be like this (in Command Prompt):

> ff mp3 [Some optional parameters] <multiple files>|<single directory>

If you provide multiple files separated with space, the script will process them.
If you provide single directory, the script will process all files inside of that directory, not its subdirectories (and their files).

Since I need to specify 'subcommand', I defined parameters like this, at the top of the script.

[CmdletBinding()]
param(
  [Parameter()][Boolean]$loop = $true,
  [Parameter()][Boolean]$twoPass = $true,
  [Parameter()][Int]$height = -1,
  [Parameter()][Int]$width = 1280,
  [Parameter()][Int]$quality = 80,
  [Parameter()][Int]$samplerate = 48000,
  [Parameter()][Int]$compression = 6,
  [Parameter()][Int]$giType = 1,
  [Parameter()][Int]$fps = 24,
  [Parameter()][Int]$bitrate = 320,
  [Parameter()][String]$preset = "picture",
  [Parameter()][Switch]$lossless = $false,
  [Parameter(Position = 0, Mandatory = $true)][String]$subcmd = ""
)

With this, I can set subcommand of my script.

The problem is, I don't know how to set another parameter for those <multiple files>|<single directory>.

These are 'acceptable' values for that parameter:

// single file in current directory
01.mp4
..mp4
// multiple files in current directory
01.jpg 02.jpg 03.jpg 04.jpg
..jpg ..jpg 03.jpg 04.jpg
// single file in subdirectory
subdir.png
.\subdir.png
// multiple files in subdirectory
subdir.png subdir.jpg subdir.webp
.\subdir.png .\subdir.jpg .\subdir.webp
// wildcard
*.png
.\*.png
subdir2\*.mp3
.\subdir2\*.mp3
// multiple wildcard (with subdirectory)
*.png *.jpg
.\*.png .\*.jpg
subdir2\image_*.png subdir2\image_*.jpg
.\subdir2\image_*.png .\subdir2\image_*.jpg
*.png subdir2\*.png
*.png .\subdir2\*.png

// single subdirectory in current directory
subdir3
.\subdir3
// single directory in subdirectory
.\subdir3\subdir4
subdir3\subdir4
// single absolute path
C:\another_dir

All wildcards and relative paths should be 'resolved' to absolute paths, which means I need a complete files list to be processed with FFmpeg.

(I will have to filter the list before processing them with FFmpeg because we can't 'convert' PNG to MP3, but that would be an another problem)

Here are some possible actual usage of the script (in PowerShell):

PS> ff.ps1 mp3 -bitrate 320 01.mp4 subdir\*.avi 00.webp // '00.webp' will be filtered out before processing
PS> ff.ps1 webpa -loop 0 subdir // Get all files inside of 'subdir' and filter them, and process

So, here is brief question.

How can I accept <multiple files>|<single directory> provided as above, as a file list, in a single parameter?

I would recommend sending the objects to be worked on, in this case the files and folders containing files, through the pipeline and use the parameters as a description of what is going to be done to each of those objects that arrive on the pipeline.

This code:

1. Uses ValueFromPipeline for the first parameter of the "myfunc" function.
2. Uses a sub-function called "PipeOneFileAtTime" defined in the begin section of "myfunc" to break out each file, and all sub files in folders (-Recurse), and pass each one down the pipeline one at a time.
3. Uses switch because it will automatically loop through each item in an arrays while allowing for a check the type of the each item, in this case it only test if it is a [string].
4. If an item isn't an [string], then it is handled by the default section of switch statement.
5. If an item is a [string], then it is tested to see if it is a file, a folder, or fails to match anything. If a file, then it is sent down the pipe, if a folder, then the files in the folder are placed on the pipeline, and if it fails to match anything, then a red warning is sent to the host (see the "Unknown: vkea" example output below).
6. Uses $MyInvocation.ExpectingInput for testing if there are items on the pipeline. Examples of use is in all 3 sections - begin, process, and end, but only the one in process actually does anything.
7. The code does NOT try to execute ffmpeg.exe, but just uses Write-Host to build a sudo command sent to the host screen.
8. It does try to build one parameter, $twoPass, as an example of how you might build the parameters that you pass to ffmpeg.exe.

#$ffmpeg = 'D:\Temp\Downloads\ffmpeg-2023-02-27-git-891ed24f77-full_build\bin\ffmpeg.exe'
$ffmpeg = 'ffmpeg.exe'
function myfunc {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline = $true)]$InputObject,
        [Parameter()][Boolean]$loop = $true,
        [Parameter()][Boolean]$twoPass = $true,
        [Parameter()][Int]$height = -1,
        [Parameter()][Int]$width = 1280,
        [Parameter()][Int]$quality = 80,
        [Parameter()][Int]$samplerate = 48000,
        [Parameter()][Int]$compression = 6,
        [Parameter()][Int]$giType = 1,
        [Parameter()][Int]$fps = 24,
        [Parameter()][Int]$bitrate = 320,
        [Parameter()][String]$preset = "picture",
        [Parameter()][Switch]$lossless = $false,
        [Parameter(Position = 0, Mandatory = $true)][String]$subcmd = ""
    )
    begin {
        function PipeOneFileAtTime {
            param(
                [Parameter(ValueFromPipeline = $true)]$FileInfo
            )
            process {
                switch ($FileInfo) {
                    {$_ -is [string]} {
                        if(Test-Path -Path $_ -PathType Leaf) { $_ }
                        elseif(Test-Path -Path $_ -PathType Container) {
                            Get-ChildItem -Path $_ -Recurse | Where-Object {$_.PSIsContainer -eq $false} |
                                ForEach-Object {$_.FullName}
                        }
                        else { Write-Host "Unknown: $_" -ForegroundColor Red }
                    }
                    default {
                        $_.GetType() | Out-Host
                    }
                }
            }
        }
        $_twoPass = if($twoPass) {' -pass 2 '} else {''}
        if ($MyInvocation.ExpectingInput) {
        }
    }
    process {
        if ($MyInvocation.ExpectingInput) {
            $InputObject | PipeOneFileAtTime | ForEach-Object {
                Write-Host "$ffmpeg " -ForegroundColor White -NoNewline
                Write-Host " $_ " -ForegroundColor Cyan -NoNewline
                Write-Host " $_twoPass" -ForegroundColor Yellow
            }
        }
    }
    end {
        if ($MyInvocation.ExpectingInput) {
        }
    }
}

This is an example use, on the pipeline is sent an array, and int, a string that points to no file or folder, and a string that points to a folder. In the array is a folder, a file, and then another folder.

,@("C:\Temp", "D:\Downloads\VSCodeSetup-x64-1.41.1.exe", "D:\Temp\TestCL"), [int]22, "vkea", "D:\Temp\Test"| myfunc -subcmd "abc" -twoPass $true

The above example use, on my computer, produced the following output. The array is processed first, with it's "C:\Temp" folder, a file, and then the folder "D:\Temp\TestCL". Followed by the int which is passed to the default section produces the GetType() output for the int. Followed by a string that has no meaning producing the "Unknown: vkea" text (which appears red in the host console), and then the last folder.

ffmpeg.exe  C:\Temp\a.csv   -pass 2
ffmpeg.exe  C:\Temp\b.csv   -pass 2
ffmpeg.exe  C:\Temp\dif.lst   -pass 2
ffmpeg.exe  C:\Temp\Data\ffmpeg.txt   -pass 2
ffmpeg.exe  C:\Temp\Data\MyInvoc.TXT   -pass 2
ffmpeg.exe  C:\Temp\Data\names.txt   -pass 2
ffmpeg.exe  D:\Downloads\VSCodeSetup-x64-1.41.1.exe   -pass 2
ffmpeg.exe  D:\Temp\TestCL\GPFSVI.txt   -pass 2
ffmpeg.exe  D:\Temp\TestCL\GPFSVI2.txt   -pass 2
ffmpeg.exe  D:\Temp\TestCL\TestStrAry.CMD   -pass 2

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Int32                                    System.ValueType


Unknown: vkea
ffmpeg.exe  D:\Temp\Test\KicDocs.zip   -pass 2
ffmpeg.exe  D:\Temp\Test\Nums.srt   -pass 2
ffmpeg.exe  D:\Temp\Test\Nums.txt   -pass 2
ffmpeg.exe  D:\Temp\Test\Resized952023012395195324.jpg   -pass 2
ffmpeg.exe  D:\Temp\Test\Resized952023012395195343.bmp   -pass 2
ffmpeg.exe  D:\Temp\Test\Resized952023012395195343.jpg   -pass 2
ffmpeg.exe  D:\Temp\Test\Resized9558eda8b8-5520-406e-8f35-4e6e2ea7d464.jpg   -pass 2
ffmpeg.exe  D:\Temp\Test\test.ps1   -pass 2

This is a very generalized answer, but hopefully you can figure out how to incorporate some of it's functionality into your project.