decoding-info 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,2 +1,5 @@
+# v1.0.1
+Fixed dist files.
+
 # v1.0.0
 First release.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Denis Seleznev
+Copyright (c) 2026 Denis Seleznev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,8 +4,15 @@
 [![NPM Downloads](https://img.shields.io/npm/dm/decoding-info.svg?style=flat)](https://www.npmjs.org/package/decoding-info)
 [![install size](https://packagephobia.com/badge?p=decoding-info)](https://packagephobia.com/result?p=decoding-info)
 
+[Demo](https://vvideo.github.io/decoding-info/index.html)
+
 This npm package allows you to determine the resolution of a supported video codec using the [MediaCapabilities API](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/mediaCapabilities).
 
+Finding video codec resolution:
+- Minimum and maximum resolutions for a video codec.
+- Minimum and maximum resolutions for a video codec with smooth playback.
+- Minimum and maximum resolutions for a video codec in power-efficiency mode (similar to hardware acceleration).
+
 ## Installation
 ```bash
 npm install --save-dev decoding-info
@@ -18,8 +25,6 @@ import { getVideoCodecSupportedResolution } from 'decoding-info';
 const configuration = {
     video: {
         codec: 'video/mp4; codecs="hvc1.1.6.L123.B0"',
-        width: 1920,
-        height: 1080,
         framerate: 25,
         bitrate: 1000000,
     },
@@ -29,7 +34,6 @@ getVideoCodecSupportedResolution(configuration).then((result) => {
     console.log(result);
     // {
     //     "error": null,
-    //     "attempts": 103,
     //     "supported": {
     //         "value": true,
     //         "minHeight": 16,
@@ -56,9 +60,10 @@ getVideoCodecSupportedResolution(configuration).then((result) => {
 ```
 
 ## Links
-- [Test navigator.mediaCapabilities.decodingInfo()](https://vvideo.github.io/decoding-info/pages/decoding-info.html)
-- [Test MediaSource.isTypeSupported()](https://vvideo.github.io/decoding-info/pages/is-type-supported.html)
-- [Test .canPlayType()](https://vvideo.github.io/decoding-info/pages/can-play-type.html)
+- [Demo](https://vvideo.github.io/decoding-info/index.html)
+- [Test navigator.mediaCapabilities.decodingInfo()](https://vvideo.github.io/decoding-info/decoding-info.html)
+- [Test MediaSource.isTypeSupported()](https://vvideo.github.io/decoding-info/is-type-supported.html)
+- [Test .canPlayType()](https://vvideo.github.io/decoding-info/can-play-type.html)
 
 ## [License](./LICENSE)
 MIT

package/dist/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const MIN_SIZE = 1;
+export declare const MAX_SIZE = 64000;
+export declare const START_SIZE = 320;

package/dist/getMaxSize.d.ts

@@ -0,0 +1,11 @@
+export declare function getMaxSize(configuration: MediaDecodingConfiguration, getSupported: (result: MediaCapabilitiesDecodingInfo) => boolean, maxSize: number): Promise<{
+    result: number;
+    attempts: number;
+    maxWidth: number;
+    maxHeight: number;
+} | {
+    attempts: number;
+    maxWidth: undefined;
+    maxHeight: undefined;
+    result: number | null;
+}>;

package/dist/getMinSize.d.ts

@@ -0,0 +1,11 @@
+export declare function getMinSize(configuration: MediaDecodingConfiguration, getSupported: (result: MediaCapabilitiesDecodingInfo) => boolean, minSize: number): Promise<{
+    attempts: number;
+    minWidth: number;
+    minHeight: number;
+    result: number;
+} | {
+    attempts: number;
+    minWidth: undefined;
+    minHeight: undefined;
+    result: number | null;
+}>;

package/dist/index.common.js

@@ -0,0 +1,253 @@
+'use strict';
+
+function getDecodingInfo(configuration) {
+    return navigator.mediaCapabilities.decodingInfo(configuration);
+}
+
+const MIN_SIZE = 1;
+const MAX_SIZE = 64000;
+const START_SIZE = 320;
+
+async function binarySearch(compareFn, minValue, maxValue) {
+    let left = minValue;
+    let right = maxValue;
+    while (left <= right) {
+        const middle = Math.floor((right + left) / 2);
+        const cmp = await compareFn(middle);
+        if (cmp === 0) {
+            return middle;
+        }
+        else if (cmp < 0) {
+            left = middle + 1;
+        }
+        else {
+            right = middle - 1;
+        }
+    }
+    return null;
+}
+
+async function getMaxSize(configuration, getSupported, maxSize) {
+    let maxWidth = undefined;
+    let attempts = 1;
+    const dataMaxSize = await getDecodingInfo({
+        ...configuration,
+        video: {
+            ...configuration.video,
+            width: maxSize,
+            height: maxSize,
+        }
+    });
+    const supportedMaxSize = getSupported(dataMaxSize);
+    if (supportedMaxSize) {
+        return {
+            result: maxSize,
+            attempts,
+            maxWidth: maxSize,
+            maxHeight: maxSize,
+        };
+    }
+    const result = await binarySearch(async (value) => {
+        attempts++;
+        const data1 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value,
+                height: value,
+            }
+        });
+        const supported1 = getSupported(data1);
+        if (!supported1) {
+            return 1;
+        }
+        if (supported1) {
+            maxWidth = Math.max(maxWidth || 0, value);
+        }
+        attempts++;
+        const data2 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value + 1,
+                height: value + 1,
+            }
+        });
+        const supported2 = getSupported(data2);
+        if (supported2) {
+            maxWidth = Math.max(maxWidth || 0, value + 1);
+        }
+        if (supported1 !== supported2) {
+            return 0;
+        }
+        if (supported1 && supported2) {
+            return -1;
+        }
+        return 1;
+    }, START_SIZE, maxSize);
+    return {
+        attempts,
+        maxWidth,
+        maxHeight: maxWidth,
+        result,
+    };
+}
+
+async function getMinSize(configuration, getSupported, minSize) {
+    let minWidth = undefined;
+    let attempts = 1;
+    const dataMinSize = await getDecodingInfo({
+        ...configuration,
+        video: {
+            ...configuration.video,
+            width: minSize,
+            height: minSize,
+        }
+    });
+    const supportedMinSize = getSupported(dataMinSize);
+    if (supportedMinSize) {
+        return {
+            attempts,
+            minWidth: minSize,
+            minHeight: minSize,
+            result: minSize,
+        };
+    }
+    const result = await binarySearch(async (value) => {
+        attempts++;
+        const data1 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value - 1,
+                height: value - 1,
+            }
+        });
+        const supported1 = getSupported(data1);
+        if (supported1) {
+            minWidth = Math.min(minWidth || Infinity, value - 1);
+            return 1;
+        }
+        attempts++;
+        const data2 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value,
+                height: value,
+            }
+        });
+        const supported2 = getSupported(data2);
+        if (supported2) {
+            minWidth = Math.min(minWidth || Infinity, value);
+        }
+        if (supported1 !== supported2) {
+            return 0;
+        }
+        if (supported1 && supported2) {
+            return 1;
+        }
+        return -1;
+    }, minSize, START_SIZE);
+    return {
+        attempts,
+        minWidth,
+        minHeight: minWidth,
+        result,
+    };
+}
+
+async function getVideoCodecSupportedResolution(configuration, options) {
+    const minSize = options?.minSize || MIN_SIZE;
+    const maxSize = options?.maxSize || MAX_SIZE;
+    const startSize = options?.startSize || START_SIZE;
+    const resultData = {
+        error: null,
+        attempts: 1,
+        supported: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+        smooth: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+        powerEfficient: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+    };
+    let decodingInfo;
+    try {
+        decodingInfo = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: startSize,
+                height: startSize,
+            },
+        });
+    }
+    catch (error) {
+        resultData.error = error;
+        return resultData;
+    }
+    if (!decodingInfo.supported) {
+        return resultData;
+    }
+    resultData.supported.value = true;
+    const [supportedMinSize, supportedMaxSize, smoothMinSize, smoothMaxSize, powerEfficientMinSize, powerEfficientMaxSize] = await Promise.all([
+        getMinSize(configuration, (result) => result.supported, minSize),
+        getMaxSize(configuration, (result) => result.supported, maxSize),
+        getMinSize(configuration, (result) => result.supported && result.smooth, minSize),
+        getMaxSize(configuration, (result) => result.supported && result.smooth, maxSize),
+        getMinSize(configuration, (result) => result.supported && result.powerEfficient, minSize),
+        getMaxSize(configuration, (result) => result.supported && result.powerEfficient, maxSize),
+    ]);
+    if (supportedMinSize.minWidth) {
+        resultData.supported.minWidth = supportedMinSize.minWidth;
+        resultData.supported.minHeight = supportedMinSize.minHeight;
+    }
+    if (supportedMaxSize.maxWidth) {
+        resultData.supported.maxWidth = supportedMaxSize.maxWidth;
+        resultData.supported.maxHeight = supportedMaxSize.maxHeight;
+    }
+    if (smoothMinSize.minWidth) {
+        resultData.smooth.value = true;
+        resultData.smooth.minWidth = smoothMinSize.minWidth;
+        resultData.smooth.minHeight = smoothMinSize.minHeight;
+    }
+    if (smoothMaxSize.maxWidth) {
+        resultData.smooth.value = true;
+        resultData.smooth.maxWidth = smoothMaxSize.maxWidth;
+        resultData.smooth.maxHeight = smoothMaxSize.maxHeight;
+    }
+    if (powerEfficientMinSize.minHeight) {
+        resultData.powerEfficient.value = true;
+        resultData.powerEfficient.minWidth = powerEfficientMinSize.minWidth;
+        resultData.powerEfficient.minHeight = powerEfficientMinSize.minHeight;
+    }
+    if (powerEfficientMaxSize.maxWidth) {
+        resultData.powerEfficient.value = true;
+        resultData.powerEfficient.maxWidth = powerEfficientMaxSize.maxWidth;
+        resultData.powerEfficient.maxHeight = powerEfficientMaxSize.maxHeight;
+    }
+    resultData.attempts += (supportedMinSize.attempts +
+        supportedMaxSize.attempts +
+        smoothMinSize.attempts +
+        smoothMaxSize.attempts +
+        powerEfficientMinSize.attempts +
+        powerEfficientMaxSize.attempts);
+    return resultData;
+}
+
+exports.getVideoCodecSupportedResolution = getVideoCodecSupportedResolution;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+interface ResultData {
+    error: null | Error;
+    attempts: number;
+    supported: {
+        value: boolean;
+        minWidth: number | undefined;
+        minHeight: number | undefined;
+        maxWidth: number | undefined;
+        maxHeight: number | undefined;
+    };
+    smooth: {
+        value: boolean;
+        minWidth: number | undefined;
+        minHeight: number | undefined;
+        maxWidth: number | undefined;
+        maxHeight: number | undefined;
+    };
+    powerEfficient: {
+        value: boolean;
+        minWidth: number | undefined;
+        minHeight: number | undefined;
+        maxWidth: number | undefined;
+        maxHeight: number | undefined;
+    };
+}
+interface GetVideoCodecSupportedResolutionOptions {
+    minSize?: number;
+    maxSize?: number;
+    startSize?: number;
+}
+export declare function getVideoCodecSupportedResolution(configuration: MediaDecodingConfiguration, options?: GetVideoCodecSupportedResolutionOptions): Promise<ResultData>;
+export {};

package/dist/index.esm.js

@@ -0,0 +1,251 @@
+function getDecodingInfo(configuration) {
+    return navigator.mediaCapabilities.decodingInfo(configuration);
+}
+
+const MIN_SIZE = 1;
+const MAX_SIZE = 64000;
+const START_SIZE = 320;
+
+async function binarySearch(compareFn, minValue, maxValue) {
+    let left = minValue;
+    let right = maxValue;
+    while (left <= right) {
+        const middle = Math.floor((right + left) / 2);
+        const cmp = await compareFn(middle);
+        if (cmp === 0) {
+            return middle;
+        }
+        else if (cmp < 0) {
+            left = middle + 1;
+        }
+        else {
+            right = middle - 1;
+        }
+    }
+    return null;
+}
+
+async function getMaxSize(configuration, getSupported, maxSize) {
+    let maxWidth = undefined;
+    let attempts = 1;
+    const dataMaxSize = await getDecodingInfo({
+        ...configuration,
+        video: {
+            ...configuration.video,
+            width: maxSize,
+            height: maxSize,
+        }
+    });
+    const supportedMaxSize = getSupported(dataMaxSize);
+    if (supportedMaxSize) {
+        return {
+            result: maxSize,
+            attempts,
+            maxWidth: maxSize,
+            maxHeight: maxSize,
+        };
+    }
+    const result = await binarySearch(async (value) => {
+        attempts++;
+        const data1 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value,
+                height: value,
+            }
+        });
+        const supported1 = getSupported(data1);
+        if (!supported1) {
+            return 1;
+        }
+        if (supported1) {
+            maxWidth = Math.max(maxWidth || 0, value);
+        }
+        attempts++;
+        const data2 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value + 1,
+                height: value + 1,
+            }
+        });
+        const supported2 = getSupported(data2);
+        if (supported2) {
+            maxWidth = Math.max(maxWidth || 0, value + 1);
+        }
+        if (supported1 !== supported2) {
+            return 0;
+        }
+        if (supported1 && supported2) {
+            return -1;
+        }
+        return 1;
+    }, START_SIZE, maxSize);
+    return {
+        attempts,
+        maxWidth,
+        maxHeight: maxWidth,
+        result,
+    };
+}
+
+async function getMinSize(configuration, getSupported, minSize) {
+    let minWidth = undefined;
+    let attempts = 1;
+    const dataMinSize = await getDecodingInfo({
+        ...configuration,
+        video: {
+            ...configuration.video,
+            width: minSize,
+            height: minSize,
+        }
+    });
+    const supportedMinSize = getSupported(dataMinSize);
+    if (supportedMinSize) {
+        return {
+            attempts,
+            minWidth: minSize,
+            minHeight: minSize,
+            result: minSize,
+        };
+    }
+    const result = await binarySearch(async (value) => {
+        attempts++;
+        const data1 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value - 1,
+                height: value - 1,
+            }
+        });
+        const supported1 = getSupported(data1);
+        if (supported1) {
+            minWidth = Math.min(minWidth || Infinity, value - 1);
+            return 1;
+        }
+        attempts++;
+        const data2 = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: value,
+                height: value,
+            }
+        });
+        const supported2 = getSupported(data2);
+        if (supported2) {
+            minWidth = Math.min(minWidth || Infinity, value);
+        }
+        if (supported1 !== supported2) {
+            return 0;
+        }
+        if (supported1 && supported2) {
+            return 1;
+        }
+        return -1;
+    }, minSize, START_SIZE);
+    return {
+        attempts,
+        minWidth,
+        minHeight: minWidth,
+        result,
+    };
+}
+
+async function getVideoCodecSupportedResolution(configuration, options) {
+    const minSize = options?.minSize || MIN_SIZE;
+    const maxSize = options?.maxSize || MAX_SIZE;
+    const startSize = options?.startSize || START_SIZE;
+    const resultData = {
+        error: null,
+        attempts: 1,
+        supported: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+        smooth: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+        powerEfficient: {
+            value: false,
+            minWidth: undefined,
+            minHeight: undefined,
+            maxWidth: undefined,
+            maxHeight: undefined,
+        },
+    };
+    let decodingInfo;
+    try {
+        decodingInfo = await getDecodingInfo({
+            ...configuration,
+            video: {
+                ...configuration.video,
+                width: startSize,
+                height: startSize,
+            },
+        });
+    }
+    catch (error) {
+        resultData.error = error;
+        return resultData;
+    }
+    if (!decodingInfo.supported) {
+        return resultData;
+    }
+    resultData.supported.value = true;
+    const [supportedMinSize, supportedMaxSize, smoothMinSize, smoothMaxSize, powerEfficientMinSize, powerEfficientMaxSize] = await Promise.all([
+        getMinSize(configuration, (result) => result.supported, minSize),
+        getMaxSize(configuration, (result) => result.supported, maxSize),
+        getMinSize(configuration, (result) => result.supported && result.smooth, minSize),
+        getMaxSize(configuration, (result) => result.supported && result.smooth, maxSize),
+        getMinSize(configuration, (result) => result.supported && result.powerEfficient, minSize),
+        getMaxSize(configuration, (result) => result.supported && result.powerEfficient, maxSize),
+    ]);
+    if (supportedMinSize.minWidth) {
+        resultData.supported.minWidth = supportedMinSize.minWidth;
+        resultData.supported.minHeight = supportedMinSize.minHeight;
+    }
+    if (supportedMaxSize.maxWidth) {
+        resultData.supported.maxWidth = supportedMaxSize.maxWidth;
+        resultData.supported.maxHeight = supportedMaxSize.maxHeight;
+    }
+    if (smoothMinSize.minWidth) {
+        resultData.smooth.value = true;
+        resultData.smooth.minWidth = smoothMinSize.minWidth;
+        resultData.smooth.minHeight = smoothMinSize.minHeight;
+    }
+    if (smoothMaxSize.maxWidth) {
+        resultData.smooth.value = true;
+        resultData.smooth.maxWidth = smoothMaxSize.maxWidth;
+        resultData.smooth.maxHeight = smoothMaxSize.maxHeight;
+    }
+    if (powerEfficientMinSize.minHeight) {
+        resultData.powerEfficient.value = true;
+        resultData.powerEfficient.minWidth = powerEfficientMinSize.minWidth;
+        resultData.powerEfficient.minHeight = powerEfficientMinSize.minHeight;
+    }
+    if (powerEfficientMaxSize.maxWidth) {
+        resultData.powerEfficient.value = true;
+        resultData.powerEfficient.maxWidth = powerEfficientMaxSize.maxWidth;
+        resultData.powerEfficient.maxHeight = powerEfficientMaxSize.maxHeight;
+    }
+    resultData.attempts += (supportedMinSize.attempts +
+        supportedMaxSize.attempts +
+        smoothMinSize.attempts +
+        smoothMaxSize.attempts +
+        powerEfficientMinSize.attempts +
+        powerEfficientMaxSize.attempts);
+    return resultData;
+}
+
+export { getVideoCodecSupportedResolution };

package/dist/utils/binarySearch.d.ts

@@ -0,0 +1 @@
+export declare function binarySearch(compareFn: (value: number) => Promise<number> | number, minValue: number, maxValue: number): Promise<number | null>;

package/dist/utils/binarySearch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/getDecodingInfo.d.ts

@@ -0,0 +1 @@
+export declare function getDecodingInfo(configuration: MediaDecodingConfiguration): Promise<MediaCapabilitiesDecodingInfo>;

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "decoding-info",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Testing audio and video codec support in a browser with or without a key system",
   "type": "module",
   "main": "src/index.common.js",
   "module": "src/index.esm.js",
   "typings": "src/index.d.ts",
   "scripts": {
+    "prepare": "npm run build",    
     "clean": "del ./dist/*",
+    "build": "npm run clean && rollup --config rollup.config.mjs && cp -f ./dist/index.esm.js ./pages",
     "test": "jest . && npm run typecheck",
-    "typecheck": "tsc --noEmit",
-    "build": "npm run clean && rollup --config rollup.config.mjs"
+    "typecheck": "tsc --noEmit"
   },
   "files": [
     "dist",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "LICENSE.md"
   ],
   "keywords": [
     "media",
@@ -34,12 +36,12 @@
     "@jest/globals": "^30.2.0",
     "@rollup/plugin-typescript": "12.3.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.10.0",
+    "@types/node": "^25.0.10",
     "del-cli": "^7.0.0",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
-    "rollup": "4.53.3",
-    "ts-jest": "^29.4.5",
+    "rollup": "4.56.0",
+    "ts-jest": "^29.4.6",
     "tslib": "2.8.1",
     "typescript": "5.9.3"
   }