bare-ffmpeg 1.0.0-9 → 1.0.0

package/lib/codec-parameters.js

@@ -1,30 +1,240 @@
 const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
 module.exports = class FFmpegCodecParameters {
-  constructor(handle) {
+  constructor(handle, owned = false) {
     this._handle = handle
+    this._owned = owned
   }
 
-  destroy() {
-    this._handle = null
-  }
+  // Getters, Setters
 
   get bitRate() {
     return binding.getCodecParametersBitRate(this._handle)
   }
 
+  set bitRate(rate) {
+    binding.setCodecParametersBitRate(this._handle, rate)
+  }
+
   get bitsPerCodedSample() {
     return binding.getCodecParametersBitsPerCodedSample(this._handle)
   }
 
+  set bitsPerCodedSample(bits) {
+    binding.setCodecParametersBitsPerCodedSample(this._handle, bits)
+  }
+
   get bitsPerRawSample() {
     return binding.getCodecParametersBitsPerRawSample(this._handle)
   }
 
+  set bitsPerRawSample(bits) {
+    binding.setCodecParametersBitsPerRawSample(this._handle, bits)
+  }
+
   get sampleRate() {
     return binding.getCodecParametersSampleRate(this._handle)
   }
 
+  set sampleRate(rate) {
+    binding.setCodecParametersSampleRate(this._handle, rate)
+  }
+
+  get sampleAspectRatio() {
+    const view = new Int32Array(binding.getCodecParametersSampleAspectRatio(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set sampleAspectRatio(ratio) {
+    binding.setCodecParametersSampleAspectRatio(this._handle, ratio.numerator, ratio.denominator)
+  }
+
+  get frameRate() {
+    const view = new Int32Array(binding.getCodecParametersFramerate(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set frameRate(rate) {
+    binding.setCodecParametersFramerate(this._handle, rate.numerator, rate.denominator)
+  }
+
+  get frameSize() {
+    return binding.getCodecParametersFrameSize(this._handle)
+  }
+
+  set frameSize(size) {
+    binding.setCodecParametersFrameSize(this._handle, size)
+  }
+
+  get videoDelay() {
+    return binding.getCodecParametersVideoDelay(this._handle)
+  }
+
+  set videoDelay(delay) {
+    binding.setCodecParametersVideoDelay(this._handle, delay)
+  }
+
+  get nbChannels() {
+    return binding.getCodecParametersNbChannels(this._handle)
+  }
+
+  set nbChannels(numberOfChannels) {
+    binding.setCodecParametersNbChannels(this._handle, numberOfChannels)
+  }
+
+  get type() {
+    return binding.getCodecParametersType(this._handle)
+  }
+
+  set type(type) {
+    binding.setCodecParametersType(this._handle, type)
+  }
+
+  get tag() {
+    return binding.getCodecParametersTag(this._handle)
+  }
+
+  set tag(tag) {
+    binding.setCodecParametersTag(this._handle, tag)
+  }
+
+  get id() {
+    return binding.getCodecParametersId(this._handle)
+  }
+
+  set id(id) {
+    binding.setCodecParametersId(this._handle, id)
+  }
+
+  get level() {
+    return binding.getCodecParametersLevel(this._handle)
+  }
+
+  set level(level) {
+    binding.setCodecParametersLevel(this._handle, level)
+  }
+
+  get profile() {
+    return binding.getCodecParametersProfile(this._handle)
+  }
+
+  set profile(profile) {
+    binding.setCodecParametersProfile(this._handle, profile)
+  }
+
+  get format() {
+    return binding.getCodecParametersFormat(this._handle)
+  }
+
+  set format(format) {
+    binding.setCodecParametersFormat(this._handle, format)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(binding.getCodecParametersChannelLayout(this._handle))
+  }
+
+  set channelLayout(value) {
+    binding.setCodecParametersChannelLayout(this._handle, ChannelLayout.from(value)._handle)
+  }
+
+  get width() {
+    return binding.getCodecParametersWidth(this._handle)
+  }
+
+  set width(value) {
+    binding.setCodecParametersWidth(this._handle, value)
+  }
+
+  get height() {
+    return binding.getCodecParametersHeight(this._handle)
+  }
+
+  set height(value) {
+    binding.setCodecParametersHeight(this._handle, value)
+  }
+
+  get extraData() {
+    return Buffer.from(binding.getCodecParametersExtraData(this._handle))
+  }
+
+  set extraData(value) {
+    binding.setCodecParametersExtraData(
+      this._handle,
+      value.buffer,
+      value.byteOffset,
+      value.byteLength
+    )
+  }
+
+  get blockAlign() {
+    return binding.getCodecParametersBlockAlign(this._handle)
+  }
+
+  set blockAlign(value) {
+    binding.setCodecParametersBlockAlign(this._handle, value)
+  }
+
+  get initialPadding() {
+    return binding.getCodecParametersInitialPadding(this._handle)
+  }
+
+  set initialPadding(value) {
+    binding.setCodecParametersInitialPadding(this._handle, value)
+  }
+
+  get trailingPadding() {
+    return binding.getCodecParametersTrailingPadding(this._handle)
+  }
+
+  set trailingPadding(value) {
+    binding.setCodecParametersTrailingPadding(this._handle, value)
+  }
+
+  get seekPreroll() {
+    return binding.getCodecParametersSeekPreroll(this._handle)
+  }
+
+  set seekPreroll(value) {
+    binding.setCodecParametersSeekPreroll(this._handle, value)
+  }
+
+  get colorSpace() {
+    return binding.getCodecParametersColorSpace(this._handle)
+  }
+
+  set colorSpace(value) {
+    binding.setCodecParametersColorSpace(this._handle, value)
+  }
+
+  get colorPrimaries() {
+    return binding.getCodecParametersColorPrimaries(this._handle)
+  }
+
+  set colorPrimaries(value) {
+    binding.setCodecParametersColorPrimaries(this._handle, value)
+  }
+
+  get colorTRC() {
+    return binding.getCodecParametersColorTRC(this._handle)
+  }
+
+  set colorTRC(value) {
+    binding.setCodecParametersColorTRC(this._handle, value)
+  }
+
+  get colorRange() {
+    return binding.getCodecParametersColorRange(this._handle)
+  }
+
+  set colorRange(value) {
+    binding.setCodecParametersColorRange(this._handle, value)
+  }
+
+  // Methods
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -33,7 +243,45 @@ module.exports = class FFmpegCodecParameters {
     binding.codecParametersToContext(context._handle, this._handle)
   }
 
+  destroy() {
+    if (this._owned) binding.destroyCodecParameters(this._handle)
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }
+
+  // TODO: add other props
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodecParameters },
+      type: this.type,
+      id: this.id,
+      format: this.format,
+      tag: this.tag,
+      frameRate: this.frameRate,
+      videoDelay: this.videoDelay,
+      profile: this.profile,
+      level: this.level,
+      width: this.width,
+      height: this.height,
+      sampleAsectRatio: this.sampleAspectRatio,
+      bitRate: this.bitRate,
+      bitsPerCodedSample: this.bitsPerCodedSample,
+      bitsPerRawSample: this.bitsPerRawSample,
+      sampleRate: this.sampleRate,
+      nbChannels: this.nbChannels,
+      channelLayout: this.channelLayout,
+      extraData: this.extraData,
+      blockAlign: this.blockAlign,
+      initialPadding: this.initialPadding,
+      trailingPadding: this.trailingPadding,
+      seekPreroll: this.seekPreroll,
+      frameSize: this.frameSize
+    }
+  }
+
+  static alloc() {
+    return new FFmpegCodecParameters(binding.allocCodecParameters(), true)
+  }
 }

package/lib/codec.js

@@ -1,6 +1,7 @@
 const Decoder = require('./decoder')
 const Encoder = require('./encoder')
 const constants = require('./constants')
+const binding = require('../binding')
 
 const codecs = new Map()
 
@@ -25,6 +26,21 @@ module.exports = class FFmpegCodec {
     return this._encoder
   }
 
+  get name() {
+    if (Number.isInteger(this._id)) {
+      return binding.getCodecNameByID(this._id)
+    }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodec },
+      id: this.id,
+      name: this.name
+    }
+  }
+
+  /** @return {FFmpegCodec} */
   static for(id) {
     let codec = codecs.get(id)
     if (codec === undefined) {

package/lib/constants.js

@@ -1,19 +1,58 @@
 const binding = require('../binding')
+const errors = require('./errors')
+
+function makeTag(a, b, c, d) {
+  return (
+    a.charCodeAt(0) | (b.charCodeAt(0) << 8) | (c.charCodeAt(0) << 16) | (d.charCodeAt(0) << 24)
+  )
+}
 
 module.exports = exports = {
   codecs: {
     MJPEG: binding.AV_CODEC_ID_MJPEG,
     H264: binding.AV_CODEC_ID_H264,
+    AVC: binding.AV_CODEC_ID_H264, // Alias for H264
     AAC: binding.AV_CODEC_ID_AAC,
     OPUS: binding.AV_CODEC_ID_OPUS,
-    AV1: binding.AV_CODEC_ID_AV1
+    AV1: binding.AV_CODEC_ID_AV1,
+    FLAC: binding.AV_CODEC_ID_FLAC,
+    MP3: binding.AV_CODEC_ID_MP3,
+    H265: binding.AV_CODEC_ID_HEVC,
+    HEVC: binding.AV_CODEC_ID_HEVC,
+    VP8: binding.AV_CODEC_ID_VP8,
+    VP9: binding.AV_CODEC_ID_VP9,
+    VORBIS: binding.AV_CODEC_ID_VORBIS,
+    PCM_S16LE: binding.AV_CODEC_ID_PCM_S16LE,
+    PCM_S16BE: binding.AV_CODEC_ID_PCM_S16BE,
+    PCM_U8: binding.AV_CODEC_ID_PCM_U8,
+    PCM_ALAW: binding.AV_CODEC_ID_PCM_ALAW,
+    PCM_MULAW: binding.AV_CODEC_ID_PCM_MULAW
+  },
+  tags: {
+    MJPEG: makeTag('M', 'J', 'P', 'G'),
+    AV1: makeTag('A', 'V', '0', '1'),
+    H264: makeTag('H', '2', '6', '4'),
+    AAC: 0x00ff,
+    FLAC: 0xf1ac,
+    MP3: 0x0055
+  },
+  profiles: {
+    H264_MAIN: binding.AV_PROFILE_H264_MAIN
+  },
+  levels: {
+    UNKNOWN: binding.AV_LEVEL_UNKNOWN
   },
   pixelFormats: {
+    NONE: binding.AV_PIX_FMT_NONE,
     RGBA: binding.AV_PIX_FMT_RGBA,
     RGB24: binding.AV_PIX_FMT_RGB24,
     YUVJ420P: binding.AV_PIX_FMT_YUVJ420P,
     UYVY422: binding.AV_PIX_FMT_UYVY422,
-    YUV420P: binding.AV_PIX_FMT_YUV420P
+    YUV420P: binding.AV_PIX_FMT_YUV420P,
+    NV12: binding.AV_PIX_FMT_NV12,
+    NV21: binding.AV_PIX_FMT_NV21,
+    NV24: binding.AV_PIX_FMT_NV24,
+    VIDEOTOOLBOX: binding.AV_PIX_FMT_VIDEOTOOLBOX
   },
   mediaTypes: {
     UNKNOWN: binding.AVMEDIA_TYPE_UNKNOWN,
@@ -29,31 +68,319 @@ module.exports = exports = {
     U8: binding.AV_SAMPLE_FMT_U8,
     S16: binding.AV_SAMPLE_FMT_S16,
     S32: binding.AV_SAMPLE_FMT_S32,
+    S64: binding.AV_SAMPLE_FMT_S64,
     FLT: binding.AV_SAMPLE_FMT_FLT,
-    FLTP: binding.AV_SAMPLE_FMT_FLTP,
     DBL: binding.AV_SAMPLE_FMT_DBL,
     U8P: binding.AV_SAMPLE_FMT_U8P,
     S16P: binding.AV_SAMPLE_FMT_S16P,
     S32P: binding.AV_SAMPLE_FMT_S32P,
-    DBLP: binding.AV_SAMPLE_FMT_DBLP,
-    S64: binding.AV_SAMPLE_FMT_S64,
     S64P: binding.AV_SAMPLE_FMT_S64P,
+    FLTP: binding.AV_SAMPLE_FMT_FLTP,
+    DBLP: binding.AV_SAMPLE_FMT_DBLP,
     NB: binding.AV_SAMPLE_FMT_NB
   },
   channelLayouts: {
     MONO: binding.AV_CH_LAYOUT_MONO,
-    STEREO: binding.AV_CH_LAYOUT_STEREO
+    STEREO: binding.AV_CH_LAYOUT_STEREO,
+    QUAD: binding.AV_CH_LAYOUT_QUAD,
+    SURROUND: binding.AV_CH_LAYOUT_SURROUND,
+    2_1: binding.AV_CH_LAYOUT_2POINT1,
+    5_0: binding.AV_CH_LAYOUT_5POINT0,
+    5_1: binding.AV_CH_LAYOUT_5POINT1,
+    7_1: binding.AV_CH_LAYOUT_7POINT1,
+    // Aliases
+    2.1: binding.AV_CH_LAYOUT_2POINT1,
+    '5.0': binding.AV_CH_LAYOUT_5POINT0,
+    5.1: binding.AV_CH_LAYOUT_5POINT1,
+    7.1: binding.AV_CH_LAYOUT_7POINT1
+  },
+  pictureTypes: {
+    NONE: binding.AV_PICTURE_TYPE_NONE,
+    I: binding.AV_PICTURE_TYPE_I,
+    P: binding.AV_PICTURE_TYPE_P,
+    B: binding.AV_PICTURE_TYPE_B,
+    S: binding.AV_PICTURE_TYPE_S,
+    SI: binding.AV_PICTURE_TYPE_SI,
+    SP: binding.AV_PICTURE_TYPE_SP,
+    BI: binding.AV_PICTURE_TYPE_BI
+  },
+  logLevels: {
+    QUIET: binding.AV_LOG_QUIET,
+    PANIC: binding.AV_LOG_PANIC,
+    FATAL: binding.AV_LOG_FATAL,
+    ERROR: binding.AV_LOG_ERROR,
+    WARNING: binding.AV_LOG_WARNING,
+    INFO: binding.AV_LOG_INFO,
+    VERBOSE: binding.AV_LOG_VERBOSE,
+    DEBUG: binding.AV_LOG_DEBUG,
+    TRACE: binding.AV_LOG_TRACE
+  },
+  codecFlags: {
+    COPY_OPAQUE: binding.AV_CODEC_FLAG_COPY_OPAQUE,
+    FRAME_DURATION: binding.AV_CODEC_FLAG_FRAME_DURATION,
+    PASS1: binding.AV_CODEC_FLAG_PASS1,
+    PASS2: binding.AV_CODEC_FLAG_PASS2,
+    LOOP_FILTER: binding.AV_CODEC_FLAG_LOOP_FILTER,
+    GRAY: binding.AV_CODEC_FLAG_GRAY,
+    PSNR: binding.AV_CODEC_FLAG_PSNR,
+    INTERLACED_DCT: binding.AV_CODEC_FLAG_INTERLACED_DCT,
+    LOW_DELAY: binding.AV_CODEC_FLAG_LOW_DELAY,
+    GLOBAL_HEADER: binding.AV_CODEC_FLAG_GLOBAL_HEADER,
+    BITEXACT: binding.AV_CODEC_FLAG_BITEXACT,
+    AC_PRED: binding.AV_CODEC_FLAG_AC_PRED,
+    INTERLACED_ME: binding.AV_CODEC_FLAG_INTERLACED_ME,
+    CLOSED_GOP: binding.AV_CODEC_FLAG_CLOSED_GOP
+  },
+  formatFlags: {
+    SHOW_IDS: binding.AVFMT_SHOW_IDS,
+    GENERIC_INDEX: binding.AVFMT_GENERIC_INDEX,
+    TS_DISCONT: binding.AVFMT_TS_DISCONT,
+    NOBINSEARCH: binding.AVFMT_NOBINSEARCH,
+    NOGENSEARCH: binding.AVFMT_NOGENSEARCH,
+    NO_BYTE_SEEK: binding.AVFMT_NO_BYTE_SEEK,
+    SEEK_TO_PTS: binding.AVFMT_SEEK_TO_PTS,
+    GLOBALHEADER: binding.AVFMT_GLOBALHEADER,
+    VARIABLE_FPS: binding.AVFMT_VARIABLE_FPS,
+    NODIMENSIONS: binding.AVFMT_NODIMENSIONS,
+    NOSTREAMS: binding.AVFMT_NOSTREAMS,
+    TS_NONSTRICT: binding.AVFMT_TS_NONSTRICT,
+    TS_NEGATIVE: binding.AVFMT_TS_NEGATIVE,
+    NOFILE: binding.AVFMT_NOFILE,
+    NEEDNUMBER: binding.AVFMT_NEEDNUMBER,
+    NOTIMESTAMPS: binding.AVFMT_NOTIMESTAMPS
+  },
+  seek: {
+    SIZE: binding.AVSEEK_SIZE,
+    FORCE: binding.AVSEEK_FORCE,
+    CUR: binding.SEEK_CUR,
+    SET: binding.SEEK_SET,
+    END: binding.SEEK_END
+  },
+  packetSideDataType: {
+    PALETTE: binding.AV_PKT_DATA_PALETTE,
+    NEW_EXTRADATA: binding.AV_PKT_DATA_NEW_EXTRADATA,
+    PARAM_CHANGE: binding.AV_PKT_DATA_PARAM_CHANGE,
+    H263_MB_INFO: binding.AV_PKT_DATA_H263_MB_INFO,
+    REPLAYGAIN: binding.AV_PKT_DATA_REPLAYGAIN,
+    DISPLAYMATRIX: binding.AV_PKT_DATA_DISPLAYMATRIX,
+    STEREO3D: binding.AV_PKT_DATA_STEREO3D,
+    AUDIO_SERVICE_TYPE: binding.AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+    QUALITY_STATS: binding.AV_PKT_DATA_QUALITY_STATS,
+    FALLBACK_TRACK: binding.AV_PKT_DATA_FALLBACK_TRACK,
+    CPB_PROPERTIES: binding.AV_PKT_DATA_CPB_PROPERTIES,
+    SKIP_SAMPLES: binding.AV_PKT_DATA_SKIP_SAMPLES,
+    JP_DUALMONO: binding.AV_PKT_DATA_JP_DUALMONO,
+    STRINGS_METADATA: binding.AV_PKT_DATA_STRINGS_METADATA,
+    SUBTITLE_POSITION: binding.AV_PKT_DATA_SUBTITLE_POSITION,
+    MATROSKA_BLOCKADDITIONAL: binding.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
+    WEBVTT_IDENTIFIER: binding.AV_PKT_DATA_WEBVTT_IDENTIFIER,
+    WEBVTT_SETTINGS: binding.AV_PKT_DATA_WEBVTT_SETTINGS,
+    METADATA_UPDATE: binding.AV_PKT_DATA_METADATA_UPDATE,
+    MPEGTS_STREAM_ID: binding.AV_PKT_DATA_MPEGTS_STREAM_ID,
+    MASTERING_DISPLAY_METADATA: binding.AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+    SPHERICAL: binding.AV_PKT_DATA_SPHERICAL,
+    CONTENT_LIGHT_LEVEL: binding.AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+    A53_CC: binding.AV_PKT_DATA_A53_CC,
+    ENCRYPTION_INIT_INFO: binding.AV_PKT_DATA_ENCRYPTION_INIT_INFO,
+    ENCRYPTION_INFO: binding.AV_PKT_DATA_ENCRYPTION_INFO,
+    AFD: binding.AV_PKT_DATA_AFD,
+    PRFT: binding.AV_PKT_DATA_PRFT,
+    ICC_PROFILE: binding.AV_PKT_DATA_ICC_PROFILE,
+    DOVI_CONF: binding.AV_PKT_DATA_DOVI_CONF,
+    S12M_TIMECODE: binding.AV_PKT_DATA_S12M_TIMECODE,
+    DYNAMIC_HDR10_PLUS: binding.AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
+    IAMF_MIX_GAIN_PARAM: binding.AV_PKT_DATA_IAMF_MIX_GAIN_PARAM,
+    IAMF_DEMIXING_INFO_PARAM: binding.AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM,
+    IAMF_RECON_GAIN_INFO_PARAM: binding.AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM,
+    AMBIENT_VIEWING_ENVIRONMENT: binding.AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
+    FRAME_CROPPING: binding.AV_PKT_DATA_FRAME_CROPPING,
+    LCEVC: binding.AV_PKT_DATA_LCEVC,
+    '3D_REFERENCE_DISPLAYS': binding.AV_PKT_DATA_3D_REFERENCE_DISPLAYS,
+    RTCP_SR: binding.AV_PKT_DATA_RTCP_SR,
+    NB: binding.AV_PKT_DATA_NB
+  },
+  codecConfig: {
+    PIX_FORMAT: binding.AV_CODEC_CONFIG_PIX_FORMAT,
+    FRAME_RATE: binding.AV_CODEC_CONFIG_FRAME_RATE,
+    SAMPLE_RATE: binding.AV_CODEC_CONFIG_SAMPLE_RATE,
+    SAMPLE_FORMAT: binding.AV_CODEC_CONFIG_SAMPLE_FORMAT,
+    CHANNEL_LAYOUT: binding.AV_CODEC_CONFIG_CHANNEL_LAYOUT,
+    COLOR_RANGE: binding.AV_CODEC_CONFIG_COLOR_RANGE,
+    COLOR_SPACE: binding.AV_CODEC_CONFIG_COLOR_SPACE
+  },
+  rounding: {
+    AV_ROUND_ZERO: binding.AV_ROUND_ZERO,
+    AV_ROUND_INF: binding.AV_ROUND_INF,
+    AV_ROUND_DOWN: binding.AV_ROUND_DOWN,
+    AV_ROUND_UP: binding.AV_ROUND_UP,
+    AV_ROUND_NEAR_INF: binding.AV_ROUND_NEAR_INF,
+    AV_ROUND_PASS_MINMAX: binding.AV_ROUND_PASS_MINMAX
+  },
+  optionFlags: {
+    SEARCH_CHILDREN: binding.AV_OPT_SEARCH_CHILDREN,
+    SEARCH_FAKE_OBJ: binding.AV_OPT_SEARCH_FAKE_OBJ,
+    ALLOW_NULL: binding.AV_OPT_ALLOW_NULL,
+    ARRAY_REPLACE: binding.AV_OPT_ARRAY_REPLACE,
+    MULTI_COMPONENT_RANGE: binding.AV_OPT_MULTI_COMPONENT_RANGE
+  },
+  hwDeviceTypes: {
+    VIDEOTOOLBOX: binding.AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
+    CUDA: binding.AV_HWDEVICE_TYPE_CUDA,
+    VAAPI: binding.AV_HWDEVICE_TYPE_VAAPI,
+    DXVA2: binding.AV_HWDEVICE_TYPE_DXVA2,
+    QSV: binding.AV_HWDEVICE_TYPE_QSV,
+    D3D11VA: binding.AV_HWDEVICE_TYPE_D3D11VA
+  },
+  hwFrameMapFlags: {
+    NONE: 0,
+    READ: binding.AV_HWFRAME_MAP_READ,
+    WRITE: binding.AV_HWFRAME_MAP_WRITE,
+    OVERWRITE: binding.AV_HWFRAME_MAP_OVERWRITE,
+    DIRECT: binding.AV_HWFRAME_MAP_DIRECT
+  },
+  colorSpace: {
+    RGB: binding.AVCOL_SPC_RGB,
+    BT709: binding.AVCOL_SPC_BT709,
+    UNSPECIFIED: binding.AVCOL_SPC_UNSPECIFIED,
+    RESERVED: binding.AVCOL_SPC_RESERVED,
+    FCC: binding.AVCOL_SPC_FCC,
+    BT470BG: binding.AVCOL_SPC_BT470BG,
+    SMPTE170M: binding.AVCOL_SPC_SMPTE170M,
+    SMPTE240M: binding.AVCOL_SPC_SMPTE240M,
+    YCGCO: binding.AVCOL_SPC_YCGCO,
+    YCOCG: binding.AVCOL_SPC_YCOCG,
+    BT2020_NCL: binding.AVCOL_SPC_BT2020_NCL,
+    BT2020_CL: binding.AVCOL_SPC_BT2020_CL,
+    SMPTE2085: binding.AVCOL_SPC_SMPTE2085,
+    CHROMA_DERIVED_NCL: binding.AVCOL_SPC_CHROMA_DERIVED_NCL,
+    CHROMA_DERIVED_CL: binding.AVCOL_SPC_CHROMA_DERIVED_CL,
+    ICTCP: binding.AVCOL_SPC_ICTCP,
+    IPT_C2: binding.AVCOL_SPC_IPT_C2,
+    YCGCO_RE: binding.AVCOL_SPC_YCGCO_RE,
+    YCGCO_RO: binding.AVCOL_SPC_YCGCO_RO
+  },
+  colorRange: {
+    UNSPECIFIED: binding.AVCOL_RANGE_UNSPECIFIED,
+    MPEG: binding.AVCOL_RANGE_MPEG,
+    JPEG: binding.AVCOL_RANGE_JPEG
+  },
+  colorPrimaries: {
+    BT709: binding.AVCOL_PRI_BT709,
+    UNSPECIFIED: binding.AVCOL_PRI_UNSPECIFIED,
+    RESERVED: binding.AVCOL_PRI_RESERVED,
+    BT470M: binding.AVCOL_PRI_BT470M,
+    BT470BG: binding.AVCOL_PRI_BT470BG,
+    SMPTE170M: binding.AVCOL_PRI_SMPTE170M,
+    SMPTE240M: binding.AVCOL_PRI_SMPTE240M,
+    FILM: binding.AVCOL_PRI_FILM,
+    BT2020: binding.AVCOL_PRI_BT2020,
+    SMPTE428: binding.AVCOL_PRI_SMPTE428,
+    SMPTEST428_1: binding.AVCOL_PRI_SMPTEST428_1,
+    SMPTE431: binding.AVCOL_PRI_SMPTE431,
+    SMPTE432: binding.AVCOL_PRI_SMPTE432,
+    EBU3213: binding.AVCOL_PRI_EBU3213,
+    JEDEC_P22: binding.AVCOL_PRI_JEDEC_P22
+  },
+  colorTRC: {
+    BT709: binding.AVCOL_TRC_BT709,
+    UNSPECIFIED: binding.AVCOL_TRC_UNSPECIFIED,
+    RESERVED: binding.AVCOL_TRC_RESERVED,
+    GAMMA22: binding.AVCOL_TRC_GAMMA22,
+    GAMMA28: binding.AVCOL_TRC_GAMMA28,
+    SMPTE170M: binding.AVCOL_TRC_SMPTE170M,
+    SMPTE240M: binding.AVCOL_TRC_SMPTE240M,
+    LINEAR: binding.AVCOL_TRC_LINEAR,
+    LOG: binding.AVCOL_TRC_LOG,
+    LOG_SQRT: binding.AVCOL_TRC_LOG_SQRT,
+    IEC61966_2_4: binding.AVCOL_TRC_IEC61966_2_4,
+    BT1361_ECG: binding.AVCOL_TRC_BT1361_ECG,
+    IEC61966_2_1: binding.AVCOL_TRC_IEC61966_2_1,
+    BT2020_10: binding.AVCOL_TRC_BT2020_10,
+    BT2020_12: binding.AVCOL_TRC_BT2020_12,
+    SMPTE2084: binding.AVCOL_TRC_SMPTE2084,
+    SMPTEST2084: binding.AVCOL_TRC_SMPTEST2084,
+    SMPTE428: binding.AVCOL_TRC_SMPTE428,
+    SMPTEST428_1: binding.AVCOL_TRC_SMPTEST428_1,
+    ARIB_STD_B67: binding.AVCOL_TRC_ARIB_STD_B67
   }
 }
 
-exports.toPixelFormat = function toPixelFormat(pixelFormat) {
-  if (typeof pixelFormat === 'number') return pixelFormat
+exports.toPixelFormat = function toPixelFormat(format) {
+  if (typeof format === 'number') return format
 
-  if (typeof pixelFormat === 'string') {
-    if (pixelFormat in exports.pixelFormats === false) {
-      throw errors.UNKNOWN_PIXEL_FORMAT(`Unknown pixel format '${pixelFormat}'`)
+  if (typeof format === 'string') {
+    if (format in exports.pixelFormats === false) {
+      throw errors.UNKNOWN_PIXEL_FORMAT(`Unknown pixel format '${format}'`)
     }
 
-    return exports.pixelFormats[pixelFormat]
+    return exports.pixelFormats[format]
   }
+
+  throw new TypeError(
+    `Pixel format must be a number or string. Received ${typeof format} (${format})`
+  )
+}
+
+exports.toSampleFormat = function toSampleFormat(format) {
+  if (typeof format === 'number') return format
+
+  if (typeof format === 'string') {
+    if (format in exports.sampleFormats === false) {
+      throw errors.UNKNOWN_SAMPLE_FORMAT(`Unknown sample format '${format}'`)
+    }
+
+    return exports.sampleFormats[format]
+  }
+
+  throw new TypeError(
+    `Sample format must be a number or string. Received ${typeof format} (${format})`
+  )
+}
+
+exports.toChannelLayout = function toChannelLayout(layout) {
+  if (typeof layout === 'number') return layout
+
+  if (typeof layout === 'string') {
+    if (layout in exports.channelLayouts === false) {
+      throw errors.UNKNOWN_CHANNEL_LAYOUT(`Unknown channel layout '${layout}'`)
+    }
+
+    return exports.channelLayouts[layout]
+  }
+
+  throw new TypeError(
+    `Channel layout must be a number or string. Received ${typeof layout} (${layout})`
+  )
+}
+
+exports.getSampleFormatName = function (sampleFormat) {
+  return binding.getSampleFormatNameByID(sampleFormat)
+}
+
+exports.getPixelFormatName = function (pixelFormat) {
+  return binding.getPixelFormatNameByID(pixelFormat)
+}
+
+exports.getColorSpaceName = function (colorSpace) {
+  return binding.getColorSpaceNameByID(colorSpace)
+}
+
+exports.toColorSpace = function (name) {
+  return binding.getColorSpaceFromName(name)
+}
+
+exports.getColorPrimariesName = function (colorPrimaries) {
+  return binding.getColorPrimariesNameByID(colorPrimaries)
+}
+
+exports.toColorPrimaries = function (name) {
+  return binding.getColorPrimariesFromName(name)
+}
+
+exports.getColorTransferName = function (colorTransfer) {
+  return binding.getColorTransferNameByID(colorTransfer)
+}
+
+exports.toColorTransfer = function (name) {
+  return binding.getColorTransferFromName(name)
 }