Update code docs

Author: jellyrock-bot

docs/data/search.json

@@ -94,39 +94,31 @@
     end if
   end if
 
-  ' Cap H264 codec profile to 1080p when the source video is H264.
+  ' Cap H264 codec profile when the source video is H264.
   ' Applied dynamically here rather than in the static device profile so it doesn't
   ' interfere with non-H264 content (e.g. HEVC DoVi remux needs unrestricted resolution).
+  ' 1080p (1920x1080) is the H264 hardware ceiling on all Roku devices, but a lower
+  ' user resolution cap is respected if set.
   if isValid(mediaStreams)
     for each stream in mediaStreams
       if isValid(stream.Type) and stream.Type = "Video" and isValid(stream.Codec) and LCase(stream.Codec) = "h264"
         if isValid(postData.DeviceProfile.CodecProfiles)
+          ' Start from the H264 hardware ceiling, then clamp down to the user's cap if lower
+          h264CapHeight = 1080
+          h264CapWidth = 1920
+          userResConditions = getResolutionConditions()
+          for each condition in userResConditions
+            if condition.Property = "Height" and condition.Value.toInt() < h264CapHeight
+              h264CapHeight = condition.Value.toInt()
+            end if
+            if condition.Property = "Width" and condition.Value.toInt() < h264CapWidth
+              h264CapWidth = condition.Value.toInt()
+            end if
+          end for
+
           for each codecProfile in postData.DeviceProfile.CodecProfiles
-            if isValid(codecProfile.Codec) and LCase(codecProfile.Codec) = "h264" and isValid(codecProfile.Conditions)
-              ' Check if a Height condition already exists at or below 1080
-              hasHeightCap = false
-              for each condition in codecProfile.Conditions
-                if isValid(condition.Property) and condition.Property = "Height"
-                  if condition.Value.toInt() <= 1080
-                    hasHeightCap = true
-                  end if
-                end if
-              end for
-
-              if not hasHeightCap
-                codecProfile.Conditions.push({
-                  "Condition": "LessThanEqual",
-                  "Property": "Height",
-                  "Value": "1080",
-                  "IsRequired": false
-                })
-                codecProfile.Conditions.push({
-                  "Condition": "LessThanEqual",
-                  "Property": "Width",
-                  "Value": "1920",
-                  "IsRequired": false
-                })
-              end if
+            if isValid(codecProfile.Codec) and LCase(codecProfile.Codec) = "h264"
+              applyResolutionCapToProfile(codecProfile, h264CapHeight, h264CapWidth)
             end if
           end for
         end if

docs/module-deviceCapabilities.html

@@ -424,10 +424,10 @@
       "SegmentLength": 6
     }
 
-    ' Add height restriction if configured
-    maxHeightArray = getMaxHeightArray(true)
-    if maxHeightArray.count() > 0
-      profile.Conditions = [maxHeightArray]
+    ' Add resolution restriction if configured
+    resolutionConditions = getResolutionConditions(true)
+    if resolutionConditions.count() > 0
+      profile.Conditions = resolutionConditions
     end if
 
     transcodingProfiles.push(profile)
@@ -457,7 +457,7 @@
     "av1": {}
   }
   di = CreateObject("roDeviceInfo")
-  maxHeightArray = getMaxHeightArray()
+  resolutionConditions = getResolutionConditions()
 
   ' ========================================
   ' DETECT SURROUND PASSTHROUGH SUPPORT
@@ -738,9 +738,7 @@
   end if
 
   ' set max resolution
-  if maxHeightArray.count() > 0
-    h264ProfileArray.Conditions.push(maxHeightArray)
-  end if
+  h264ProfileArray.Conditions.Append(resolutionConditions)
 
   ' set bitrate restrictions based on user settings
   bitRateArray = GetBitRateLimit("h264")
@@ -774,9 +772,7 @@
     }
 
     ' set max resolution
-    if maxHeightArray.count() > 0
-      mpeg2ProfileArray.Conditions.push(maxHeightArray)
-    end if
+    mpeg2ProfileArray.Conditions.Append(resolutionConditions)
 
     ' set bitrate restrictions based on user settings
     bitRateArray = GetBitRateLimit("mpeg2")
@@ -826,9 +822,7 @@
     }
 
     ' set max resolution
-    if maxHeightArray.count() > 0
-      av1ProfileArray.Conditions.push(maxHeightArray)
-    end if
+    av1ProfileArray.Conditions.Append(resolutionConditions)
 
     ' set bitrate restrictions based on user settings
     bitRateArray = GetBitRateLimit("av1")
@@ -891,9 +885,7 @@
     end if
 
     ' set max resolution
-    if maxHeightArray.count() > 0
-      hevcProfileArray.Conditions.push(maxHeightArray)
-    end if
+    hevcProfileArray.Conditions.Append(resolutionConditions)
 
     ' set bitrate restrictions based on user settings
     bitRateArray = GetBitRateLimit("h265")
@@ -931,9 +923,7 @@
     }
 
     ' set max resolution
-    if maxHeightArray.count() > 0
-      vp9ProfileArray.Conditions.push(maxHeightArray)
-    end if
+    vp9ProfileArray.Conditions.Append(resolutionConditions)
 
     ' set bitrate restrictions based on user settings
     bitRateArray = GetBitRateLimit("vp9")
@@ -1026,35 +1016,89 @@
   return {}
 end function
 
-function getMaxHeightArray(isRequired = false as boolean) as object
+function getResolutionConditions(isRequired = false as boolean) as object
   userMaxHeight = m.global.user.settings.playbackResolutionMax
   if userMaxHeight = invalid or userMaxHeight = "" then userMaxHeight = "auto"
-  if userMaxHeight = "off" then return {}
+  if userMaxHeight = "off" then return []
 
-  deviceMaxHeight = m.global.device.videoHeight
+  globalDevice = m.global.device ' cache - accessed twice below
+  deviceMaxHeight = globalDevice.videoHeight
 
   maxVideoHeight = 1080 ' default to 1080p in case all our validation checks fail
+  maxVideoWidth = 1920
 
   if userMaxHeight = "auto"
     if isValid(deviceMaxHeight) and deviceMaxHeight <> 0 and deviceMaxHeight > maxVideoHeight
       maxVideoHeight = deviceMaxHeight
+      maxVideoWidth = globalDevice.videoWidth ' paired width for device's native video mode
     end if
   else
     userMaxHeight = userMaxHeight.ToInt()
     if isValid(userMaxHeight) and userMaxHeight > 0 and userMaxHeight < maxVideoHeight
       maxVideoHeight = userMaxHeight
+      ' Settings only stores height, so derive the paired 16:9 width
+      ' (same standard resolution pairs as SaveDeviceToGlobal in globals.bs)
+      heightToWidth = {
+        "480": 720,
+        "576": 720,
+        "720": 1280,
+        "1080": 1920,
+        "2160": 3840,
+        "4320": 7680
+      }
+      mappedWidth = heightToWidth[maxVideoHeight.toStr()]
+      maxVideoWidth = isValid(mappedWidth) ? mappedWidth : int(maxVideoHeight * 16 / 9)
     end if
   end if
 
-  return {
+  return [
+    {
+      "Condition": "LessThanEqual",
+      "Property": "Height",
+      "Value": maxVideoHeight.toStr(),
+      "IsRequired": isRequired
+    },
+    {
+      "Condition": "LessThanEqual",
+      "Property": "Width",
+      "Value": maxVideoWidth.toStr(),
+      "IsRequired": isRequired
+    }
+  ]
+end function
+
+' Apply a paired Height + Width resolution cap to a codec profile's Conditions.
+' No-ops if a Height condition at or below maxHeight already exists.
+' @param codecProfile {object} - The codec profile AA containing a Conditions array
+' @param maxHeight {integer} - The max height to cap at (e.g. 1080)
+' @param maxWidth {integer} - The max width to cap at (e.g. 1920)
+' @param isRequired {boolean} - Whether the condition is required for direct play
+sub applyResolutionCapToProfile(codecProfile as object, maxHeight as integer, maxWidth as integer, isRequired = false as boolean)
+  if not isValid(codecProfile) or not isValid(codecProfile.Conditions) then return
+
+  for each condition in codecProfile.Conditions
+    if isValid(condition.Property) and condition.Property = "Height"
+      if condition.Value.toInt() <= maxHeight
+        return ' Resolution cap already present
+      end if
+    end if
+  end for
+
+  codecProfile.Conditions.push({
     "Condition": "LessThanEqual",
     "Property": "Height",
-    "Value": maxVideoHeight.toStr(),
+    "Value": maxHeight.toStr(),
     "IsRequired": isRequired
-  }
-end function
+  })
+  codecProfile.Conditions.push({
+    "Condition": "LessThanEqual",
+    "Property": "Width",
+    "Value": maxWidth.toStr(),
+    "IsRequired": isRequired
+  })
+end sub
 
-' Recieves and returns an assArray of supported profiles and levels for each video codec
+' Receives and returns an assArray of supported profiles and levels for each video codec
 function updateProfileArray(profileArray as object, videoCodec as string, videoProfile as string, profileLevel = "" as string) as object
   ' validate params
   if not isValid(profileArray) then return {}