@amazon-devices/keplermediadescriptor

"@amazon-devices/keplermediadescriptor": "~1.1.8",

import {
    KeplerMediaDescriptor,
    MediaFormat,
    VideoDecoderConfig,
    VideoFormat,
    AudioDecoderConfig,
    AudioFormat,
    MediaFormatProfileLevel,
} from "@amazon-devices/keplermediadescriptor";

let mediaFormat : MediaFormat = new MediaFormat(CodecMimeType.MIME_AVC);
// 12Mbps bitrate
mediaFormat.bitrateKbps = 12000;

// 1080p Resolution
let videoFormat = new VideoFormat();
videoFormat.resolution = {
    width = 1080,
    height = 1920
};

// 60fps frame rate
videoFormat.frameRate = 60;

// use the decoder config to send all the attributes
// in a single go.
const decoderConfig = new VideoDecoderConfig();
decoderConfig.mediaFormat = mediaFormat;
decoderConfig.videoFormat = videoFormat;
decoderConfig.formatProfileLevel = profileLevel;

// avc codec with Main Profile and Level 4.2
let mime = "video/mp4; codecs="avc1.640028""
let profileLevel = new MediaFormatProfileLevel(mime);
decoderConfig.formatProfileLevel = profileLevel;

let videoCaps = await KeplerMediaDescriptor.queryMediaCapabilities(decoderConfig);
if (videoCaps.length > 0) {
    console.info("The device supports the requested config");
}

// loop through the capabilities
for (let index = 0; index < videoCaps.length; index++) {
    let videoCapability = videoCaps[index];
    // check if the codec is hardware backed
    if (videoCapability.mediaCodecFeaturesCapabilities.hardwareBacked) {
        console.log("codec is hardware backed.")
    }

    // Get the min and max resolution supported by the codec:
    let resolutions = videoCapability.videoFormatCapabilities.resolutions;
    console.log("min resolution is ", resolutions[0], " max resolution is ", resolutions[1]);

    // Get the max frame rate supported by the codec for a given resolution
    let maxFps = videoCapability.videoFormatCapabilities.getMaxFrameRate(resolutions[1]);

    // Get all the color formats supported by the decoder:
    console.log(videoCapability.videoFormatCapabilities.colorFormats);

    // check if the codec supports decryption
    if (videoCapability.decoderFeaturesCapabilities.decryptionSupported) {
        console.log("decryption is supported by this codec");
    }
}

let mediaFormat = new MediaFormat(CodecMimeType.MIME_AAC);
let audioFormat = new AudioFormat();
audioFormat.channelCount = 2;
audioFormat.sampleRate = 44100;

const decoderConfig = new AudioDecoderConfig();
decoderConfig.mediaFormat = mediaFormat;
decoderConfig.audioFormat = audioFormat;

let audioCaps = await KeplerMediaDescriptor.queryMediaCapabilities(decoderConfig);

let mediaFormat = new MediaFormat(CodecMimeType.MIME_AC3); // or MIME_EAC3
const decoderConfig = new AudioDecoderConfig();
decoderConfig.mediaFormat = mediaFormat;
let audioCaps = await KeplerMediaDescriptor.queryMediaCapabilities(decoderConfig);

if (audioCaps.length > 0) {
    console.log("the device supports DOLBY digital audio");
}

// loop through the capabilities
for (let index = 0; index < audioCaps.length; index++) {
    let audioCapability = audioCaps[index];
    if (audioCapability.decoderFeaturesCapabilities.decryptionSupported) {
        console.log("The codec supports decryption");
    }
}