media-capabilities/decodingInfo.webrtc.html

<!DOCTYPE html>
<title>MediaCapabilities.decodingInfo() for webrtc</title>
<script src=/resources/testharness.js></script>
<script src="/resources/testharnessreport.js"></script>
<script>

// Minimal VideoConfiguration that will be allowed per spec. All optional
// properties are missing.
const minimalVideoConfiguration = {
  contentType: 'video/VP9; profile-level="0"',
  width: 800,
  height: 600,
  bitrate: 3000,
  framerate: 24,
};

// Minimal AudioConfiguration that will be allowed per spec. All optional
// properties are missing.
const minimalAudioConfiguration = {
  contentType: 'audio/opus',
};

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
  }));
}, "Test that decodingInfo rejects if the configuration doesn't have an audio or video field");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'video/VP9',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: -1,
    },
  }));
}, "Test that decodingInfo rejects if the video configuration has a negative framerate");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'video/VP9"',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: 0,
    },
  }));
}, "Test that decodingInfo rejects if the video configuration has a framerate set to 0");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'video/VP9"',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: Infinity,
    },
  }));
}, "Test that decodingInfo rejects if the video configuration has a framerate set to Infinity");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'fgeoa',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: 24,
    },
  }));
}, "Test that decodingInfo rejects if the video configuration contentType doesn't parse");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'audio/fgeoa',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: 24,
    },
  }));
}, "Test that decodingInfo rejects if the video configuration contentType isn't of type video");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    audio: { contentType: 'fgeoa' },
  }));
}, "Test that decodingInfo rejects if the audio configuration contentType doesn't parse");

promise_test(t => {
  return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    audio: { contentType: 'video/fgeoa' },
  }));
}, "Test that decodingInfo rejects if the audio configuration contentType isn't of type audio");

promise_test(t => {
  return navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: minimalVideoConfiguration,
    audio: minimalAudioConfiguration,
  }).then(ability => {
    assert_equals(typeof ability.supported, "boolean");
    assert_equals(typeof ability.smooth, "boolean");
    assert_equals(typeof ability.powerEfficient, "boolean");
  });
}, "Test that decodingInfo returns a valid MediaCapabilitiesInfo objects");

promise_test(t => {
  return navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: 'video/webm; codecs="vp09.00.10.08"',
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: 24,
    },
    audio: minimalAudioConfiguration,
  }).then(ability => {
    assert_false(ability.supported);
    assert_false(ability.smooth);
    assert_false(ability.powerEfficient);
  });
}, "Test that decodingInfo returns supported, smooth, and powerEfficient set to false for non-webrtc video content type.");

promise_test(t => {
  return navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: minimalVideoConfiguration,
    audio: {
      contentType: 'audio/webm; codecs="opus"',
    },
  }).then(ability => {
    assert_false(ability.supported);
    assert_false(ability.smooth);
    assert_false(ability.powerEfficient);
  });
}, "Test that decodingInfo returns supported, smooth, and powerEfficient set to false for non-webrtc audio content type.");

const validAudioCodecs = (() => {
  // Some codecs that are returned by getCapabilities() are not real codecs,
  // exclude these from the test.
  const excludeList = [ 'audio/CN', 'audio/telephone-event', 'audio/red' ];
  const audioCodecs = [];
  RTCRtpReceiver.getCapabilities("audio")['codecs'].forEach(codec => {
    if (excludeList.indexOf(codec.mimeType) < 0 &&
        audioCodecs.indexOf(codec.mimeType) < 0) {
      audioCodecs.push(codec.mimeType);
    }
  });
  return audioCodecs;
})();

validAudioCodecs.forEach(codec => {
  promise_test(t => {
  return navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    audio: {
      contentType: codec
    }
  }).then(ability => {
    assert_true(ability.supported);
  });
}, "Test that decodingInfo returns supported true for the codec " + codec + " returned by RTCRtpReceiver.getCapabilities()")}
);

const validVideoCodecs = (() => {
  // Some codecs that are returned by getCapabilities() are not real codecs but
  // only used for error correction, exclude these from the test.
  const excludeList = [ 'video/rtx', 'video/red', 'video/ulpfec',
                      'video/flexfec-03' ];
  const videoCodecs = [];

  RTCRtpReceiver.getCapabilities("video")['codecs'].forEach(codec => {
    if (excludeList.indexOf(codec.mimeType) < 0) {
      let mimeType = codec.mimeType;
      if ('sdpFmtpLine' in codec) {
        mimeType += "; " + codec.sdpFmtpLine;
      }
      if (!(mimeType in videoCodecs)) {
        videoCodecs.push(mimeType);
      }
    }
  });
  return videoCodecs;
})();

validVideoCodecs.forEach(codec => {
  promise_test(t => {
  return navigator.mediaCapabilities.decodingInfo({
    type: 'webrtc',
    video: {
      contentType: codec,
      width: 800,
      height: 600,
      bitrate: 3000,
      framerate: 24,
    }
  }).then(ability => {
    assert_true(ability.supported);
  });
}, "Test that decodingInfo returns supported true for the codec " + codec + " returned by RTCRtpReceiver.getCapabilities()")}
);

</script>