Media And Microcode : Get-RecordedTV

Microcode: Cleaning up DVR with Get-RecordedTV

JamesBrundage — Mon, 21 Jul 2008 03:51:01 GMT

The first simple way we can approach cleaning up DVR is by making the assertion that shows you don't want as much you won't record as often. Suppose you record a movie once, or a game, or the pilot of a really bad TV show. After a month or so it's still on your hard drive, taking up space but for some reason avoiding the Windows Media Center's cleanup bots.

Now that we've got a fairly mature Get-RecordedTV, we can use it to delete a certain number of files from your collection until we reach a desired amount of freed space.

function Remove-DVRBySeries($cleanupSize = 1gb, $episodeCount = 1)
{
    $shows = @()
    # Pipe the results of Get-RecordedTV so that we can see progress
    $perc = 0

    Get-RecordedTV | Foreach-Object {
        $perc+=5
        if ($perc -gt 100) { $perc = 0 }
        Write-Progress "Getting DVR Metadata" "$($_.Series) - $($_.Episode) - $($_.Channel)" -perc $perc
        $shows+=$_
    }
    $showsbySeries = $shows | Group-Object Series
    $allSeries = $showsBySeries |
      Where-Object { $_.Count -le $episodeCount} |
      Sort-Object Count
    foreach ($series in $allSeries)
    {
        foreach ($e in $series.Group) {
            $response =Read-Host "Delete $($e.Series) - $($e.Episode) (Yes/No)"
            if ($response -ilike "*Yes*") {
                if ($e.File) {
                    Write-Progress "Deleting $($e.Series) - $($e.Episode)" `
                       "$($e.Size / 1mb) megabytes saved - $(($cleanupSize - $e.Size)/1mb) remaining"
                    Remove-Item $e.File
                    $cleanupSize-=$e.Size
                } else {
                    Write-Error "$($e.Series) - $($e.Episode) File Not Found"
                }
            } else {
                Write-Progress "Skipping show by user request" "$($e.Series) - $($e.Episode)"
            }
            if ($cleanupSize -le 0) { return }
        }
    }
}

This script will remove shows with one or fewer episodes until it has saved 1gb of space. If you want to make it save more, use the cleanupSize parameter. If you want it to check series with more episodes, use the -episodeCount parameter. It will ask to make sure you want to delete each show, and will stop once it has saved you enough space.

The script above uses a lot of simple PowerShell benefits. Let's take a closer look at each:

CleanupSize uses 1gb as its default. In PowerShell, you can use gb,mb,and kb as numbers, e.g. 1gb, 10mb, or 640kb
By piping Get-RecordedTV to ForEach-Object, I am able to store the results of Get-RecordedTV as they come in, instead of waiting for all of them to be completed, I can use Write-Progress to display each show as it comes in. Since I don't know how long it will take, I can just wrap the progress bar around whenever I get to 100%.
Group-Object will group all of the shows by the value of the series property
Sort-Object is used to sort the results of Group-Object by the number of items in each group (in our case, the number of recorded episodes of a series)
Write-Progress is used again to update the user as files are deleted or skipped
Read-Host displays a prompt and asks for user input
-ilike is a case insentive like, so $response -ilike will match "Yes", "yeS', or "Yes Sir", sadly, the logic will also catch "Yes, I mean No!"
Write-Error politely informs me that a file cannot be deleted, but does not stop execution of the script (this the important difference between Write-Error and throw)

That's it. We've brought one train of thought to an end. With this script, I was able to quickly and easily cleanup almost 40gb of shows that I wasn't watching. I hope it helps you clean up your hard drive, and I hope that explaining how to get here has increased your understanding of PowerShell scripting and problem solving.

Hope this helps,

James

Microcode: Cleaning up Get-RecordedTV with Select-Object

JamesBrundage — Mon, 21 Jul 2008 02:28:15 GMT

In a previous post, I introduced Get-RecordedTV, which was built upon another function, Search-WindowsDesktop.

The old version of Get-RecordedTV directly returned the properties related to DVR from Windows Desktop Search, with incredibly long names like 'System.RecordedTV.IsRepeatBroadcast'. In the interests of making future code shorter and explaining one of the free benefits you get with objects in PowerShell (Select-Object), I'm going to start by giving a new Get-RecordedTV. Instead of giving you the properties directly from Desktop Search, this Get-RecordedTV reinterprets the results to make them easier to read.

function Get-RecordedTV() {
    Search-WindowsDesktop 'System.Title',
      'System.RecordedTV.EpisodeName',
      'System.RecordedTV.ChannelNumber',
      'System.RecordedTV.StationName',
      'System.RecordedTV.IsRepeatBroadcast',
      'System.RecordedTV.StationCallsign',
      'System.RecordedTV.ProgramDescription',
      'System.RecordedTV.IsSAP',
      'System.RecordedTV.IsHDContent',
      'System.RecordedTV.RecordingTime',
      'System.Video.FrameHeight',
      'System.Video.FrameWidth',
      'System.Video.EncodingBitrate',
      'System.Media.DateEncoded',
      'System.ParentalRating',
      'System.Size',
      'System.ItemPathDisplay' "WHERE System.RecordedTV.ChannelNumber IS NOT NULL" |
    Select-Object @{Name='Series';Expression={$_.'System.Title'}},
      @{Name='Episode';Expression={$_.'System.RecordedTV.EpisodeName'}},
      @{Name='Description';Expression={$_.'System.RecordedTV.ProgramDescription'}},
      @{Name='Channel';Expression={
          "$($_.'System.RecordedTV.ChannelNumber')-$($_.'System.RecordedTV.StationCallsign')-$($_.'System.RecordedTV.StationName')"
      }},
      @{Name='File';Expression={
          Get-Item $_.'System.ItemPathDisplay' -errorAction SilentlyContinue
      }},
      @{Name='Size';Expression={$_.'System.Size'}},
      @{Name='DateRecorded';Expression={$_.'System.RecordedTV.RecordingTime'}},
      @{Name='IsSAP';Expression={$_.'System.RecordedTV.IsSAP'}},
      @{Name='IsHD';Expression={$_.'System.RecordedTV.IsHDContent'}},
      @{Name='IsRepeatBroadcast';Expression={$_.'System.RecordedTV.IsRepeatBroadcast'}},
      @{Name='Width';Expression={$_.'System.Video.FrameWidth'}},
      @{Name='Height';Expression={$_.'System.Video.FrameHeight'}},
      @{Name='Rating';Expression={$_.'System.ParentalRating'}}
}

This entire function is still one pipeline. It gets the results from Search-WindowsDesktop, and, as each item arrives, it pipes the results to Select-Object.

Select-Object is an incredibly useful PowerShell Cmdlet. It is used to select one or more objects from a type, and return them in a bag of properties. While it works great for selecting just a property or two (e.g. Get-Process | Select Name, ID), it can also be used in some interesting other ways.

The way I use it above is to rename a number of properties. If you have an parameter in Select-Object that takes the format @{Name='String';Expression={expression}}, you will create a new property on the object with the value of the expression. You can refer to something on the current object by using $_ (which, in PowerShell, is pretty commonly the current element in the pipeline). You can also use this to run methods and return their values as properties. And, finally, you can actually create a type that is only properties this way, by using a simple other PowerShell coolness, the range operator.

So, to create one hundred anonymous objects with two random numbers:

$random=New-Object Random
1..100 |
Select-Object @{Name='Random1';Expression={$random.Next()}},
@{Name='Random2';Expression={$random.Next()}}

People familiar with functional programming might know this sort of thing as a Tuple, but knowing the correct terminology doesn't help the usefulness sink in all that much to me.

In the case of Get-RecordedTV, the first use is pretty obvious: it reduces the amount of typing for each property name and makes it easier to identify. The second advantage is more subtle. By re-interpreting the return type from Search-WindowsDesktop to be a bunch of properties that the system decides to a bunch of properties that I choose, it means that I can make the dependency on Search-WindowsDesktop removable. In doing so, I hurt anyone that has already built scripts around Get-RecordedTV, because they have to change their scripts to handle a new signature for the anonymous type, because the change subtracted types.

Subtractive changes break backwards compatibility, but in this case it frees me from the stack that I used to depend on. This is a wonderful flexibility of writing in an interpreted language, and can be valuable because you can use it to make a flexible dependency instead of a fixed one. With a flexible dependency, if I find out that they have turned Windows Desktop Search off, or I find a better mechanism down the line, I can replace my dependency on Search-WindowsDesktop with another technology.

I could write an interface to express the data I want to get, but that's overkill for my situation. If I write an interface, then I have to have a real type already loaded, and I've swapped one dependency (on Search-WindowsDesktop) for two ( the type that implements the interface and the interface type ) and have essential hard-bolted a dependency on my interface to any application that wants to use the data.

Anonymous types allow you to get most of the benefits of interfaces with a flexible dependency. As long as you keep the bag of properties the same, you can build upon scripts that return anonymous properties. You can use this to coerce data into forms that are easier to remember, and to summarize data in simpler forms. You will also find that a number of cmdlets within PowerShell (Select-Object, Sort-Object, and Group-Object) work amazingly well with bags of properties.

In a later posts, we'll use this base of code and these cmdlets to prune the collection, and demonstrate how the use of property bags and the exploration into Windows Desktop Search leads to a variety of wonderful side effects.

Hope this Helps,

James Brundage [MSFT]

Microcode: Getting DVR MetaData with Search-WindowsDesktop

JamesBrundage — Mon, 14 Jul 2008 00:35:00 GMT

In the previous post, i explained that I was trying to find a way to get at the information about my TV shows, and introduced you to some of the thought process that went into finding out information about my DVR. I then solved the most important portion of my DVR problem (extracting out the metadata) in a way that was flexible enough to apply to be used for other potential projects, like Getting Photo Metadata or Getting Contact Metadata.

Here's the Search-WindowsDesktop function again:

function Search-WindowsDesktop($fields, $filter)
{
    $connection = New-Object -comObject "ADODB.Connection"
    $recordSet = New-Object -comObject "ADODB.RecordSet"

    $null = $connection.Open("Provider=Search.CollatorDSO;Extended Properties='Application=Windows';") > $null

    $ofs = ","
    $query = "SELECT $fields"
    $query += " FROM SYSTEMINDEX $filter"
    $null = $recordSet.Open($query, $connection)

    if ($recordSet.EOF) { return }
    $recordSet.MoveFirst()

    while (-not $recordSet.EOF) {
        $result = New-Object Object
        foreach ($field in $fields) {
            $result | Add-Member NoteProperty $field $recordSet.Fields.Item($field).Value
        }
        $result
        $recordSet.MoveNext()
    }

    $null = $recordSet.Close()
    $null = $connection.Close()

    $connection = $null
    $recordSet = $null
}

I also introduced the way I think solve problems by looking at the smaller problems they contained. My starting point was that I was trying to prune my Windows Media Center dvrms files. I could have gone about getting rid of Windows Media Center files in a less elegant way, but I would have regretted it. For instance, I could have pruned the files just on size, but I would have Lost Lost. But going down the path of getting metadata lets me do more related tasks.

I strongly believe that whenever problem solving, it is key to examine not just the problems that you are working with, but to look at the related problems. The root problem in this case was that dvrms files are my appetite for video on demand are both large enough to flood my disk. If I pruned my collection on size, not only would I have lost Lost, but I would only have the option of losing the files forever. By getting the DVR metadata, I open up the door to a number of more promising paths:

I can back up certain shows to other hard drives
If I can find a way to remove commercials

I can burn a DVD of the files

If I can find the right API,

I can convert the files to another file format

Getting the metadata solves the problem in a better and more flexible way than does chopping by file size. Researching it also exposed me to other cool things that I can do, and give me a reference to use while creating my DVR Metadata script. Using PowerShell, I tried running queries one by one for each of the properties on the Recorded TV reference to discover which ones work and determined if the return values were helpful.

Here's the result of my efforts:

function Get-RecordedTV() {
Search-WindowsDesktop 'System.Title',
    'System.RecordedTV.EpisodeName',
    'System.RecordedTV.ChannelNumber',
    'System.RecordedTV.StationName',
    'System.RecordedTV.IsRepeatBroadcast',
    'System.RecordedTV.StationCallsign',
    'System.RecordedTV.ProgramDescription',
    'System.RecordedTV.IsSAP',
    'System.RecordedTV.IsHDContent',
    'System.RecordedTV.RecordingTime',
    'System.Video.FrameHeight',
    'System.Video.FrameWidth',
    'System.Video.EncodingBitrate',
    'System.Media.DateEncoded',
    'System.ParentalRating',
    'System.Size',
    'System.ItemURL',
    'System.RecordedTV.RecordingTime' "WHERE System.RecordedTV.ChannelNumber IS NOT NULL"
}

I know it really doesn't look like it, but that can be written as a one-liner. By using an existing system and writing a generic function, I was able to write this Get-RecordedTV function simply by providing the data I needed to my Search-WindowsDesktop function.

Since the Search-WindowsDesktop function returns objects with property names, it is possible to use a number of built-in PowerShell commands to help you look through the data.

Here are the Cmdlets you can use to explore objects:

Group-Object	Creates groups of objects on a type or expression
Select-Object	Selects properties from an object or make new ones on the fly
Sort-Object	Sort a list of objects by a property
Where-Object (or ?)	Filters the objects by an expresson
Foreach-Object (or %)	Performs an action on each of the input objects

One quick thing I can see this way is what TV station I watch the most:

Get-RecordedTV | Group-Object 'System.RecordedTV.StationCallSign' | Sort Count -Descending

Another thing I can do with a simple change is group by Parental Rating instead

Get-RecordedTV | Group-Object 'System.ParentalRating' | Sort Count -Descending

And of course, I can sort on the size and the time recorded:

Get-RecordedTV | sort 'System.RecordedTV.RecordingTime' -descending

Get-RecordedTV | sort 'System.Size' -descending

Now I have the potential to build a much more flexible TV pruning solution. In a future post, I'll show how you can resolve the ItemURL to a real file and, finally, how to prune the files you don't want by any criteria you'd like.

Hope this helps,

James Brundage