bitmovin-ruby 0.3.0 → 0.4.0

data/examples/hls_multi_codec.rb

@@ -0,0 +1,205 @@
+require 'bitmovin-ruby'
+
+# CONFIGURATION
+BITMOVIN_API_KEY = "YOUR API KEY HERE"
+
+S3_INPUT_ID = "The ID of the Input"
+S3_OUTPUT_ID = "The ID of the Output"
+OUTPUT_PATH = "/encoding_test/bitmovin-ruby/#{Time.now.strftime("%v-%H-%M")}/"
+M3U8_NAME = "playlist.m3u8" 
+
+Bitmovin.init(BITMOVIN_API_KEY)
+
+# This will create a Input Bucket you can reuse in future encodings
+# To get a list of all your S3Inputs do:
+# Bitmovin::Encoding::Inputs::S3Input.list
+s3_input = Bitmovin::Encoding::Inputs::S3Input.find(S3_INPUT_ID)
+
+# This will create a Output Bucket you can reuse in future encodings
+# To get a list of all your Output do:
+# Bitmovin::Encoding::Outputs::S3Output.list
+s3_output = Bitmovin::Encoding::Outputs::S3Output.find(S3_OUTPUT_ID)
+
+# Please note inputs/outputs are not individual files but rather the 
+# Bucket you are reading/writing files to and they can be reused between encodings.
+
+
+# This hash contains the H264 Codec Configurations we want to create
+# Codec Configurations are similar to Inputs/Outputs in that they are configured once
+# and can be reused for future encodings. 
+video_configs = [
+  { name: "h264_360p_600",    profile: "HIGH", height: 360,  bitrate: 600000 },
+  { name: "h264_432p_700",    profile: "HIGH", height: 432,  bitrate: 700000 },
+  { name: "h264_576p_1050",   profile: "HIGH", height: 576,  bitrate: 1050000 },
+  { name: "h264_720p_1380",   profile: "HIGH", height: 720,  bitrate: 1380000 },
+  { name: "h264_720p_1800",   profile: "HIGH", height: 720,  bitrate: 1800000 },
+  { name: "h264_1080p_2150",  profile: "HIGH", height: 1080, bitrate: 2150000 },
+  { name: "h264_1080p_2900",  profile: "HIGH", height: 1080, bitrate: 2900000 },
+  { name: "h264_2160p_4000",  profile: "HIGH", height: 2160, bitrate: 4000000 },
+  { name: "h264_2160p_6000",  profile: "HIGH", height: 2160, bitrate: 6000000 },
+  { name: "h264_2160p_8500",  profile: "HIGH", height: 2160, bitrate: 8500000 },
+  { name: "h264_2160p_10000", profile: "HIGH", height: 2160, bitrate: 10000000 },
+
+  { name: "h265_360p_420",    profile: "main", height: 360,  bitrate: 420000 },
+  { name: "h265_432p_490",    profile: "main", height: 432,  bitrate: 490000 },
+  { name: "h265_576p_735",    profile: "main", height: 576,  bitrate: 735000 },
+  { name: "h265_720p_966",    profile: "main", height: 720,  bitrate: 966000 },
+  { name: "h265_720p_1260",   profile: "main", height: 720,  bitrate: 1260000 },
+  { name: "h265_1080p_1505",  profile: "main", height: 1080, bitrate: 1505000 },
+  { name: "h265_1080p_2030",  profile: "main", height: 1080, bitrate: 2030000 },
+  { name: "h265_2160p_2800",  profile: "main", height: 2160, bitrate: 2800000 },
+  { name: "h265_2160p_4200",  profile: "main", height: 2160, bitrate: 4200000 },
+  { name: "h265_2160p_5950",  profile: "main", height: 2160, bitrate: 5950000 },
+  { name: "h265_2160p_7000",  profile: "main", height: 2160, bitrate: 7000000 }
+]
+
+# The actual instance of the encoding task you are about to start
+enc = Bitmovin::Encoding::Encodings::EncodingTask.new({
+  name: "VOD h264/h265 Encoding HLS"
+})
+enc.save!
+
+
+# Let's also start the Manifest generation
+manifest = Bitmovin::Encoding::Manifests::HlsManifest.new({
+  name: 'Test Ruby Manifest',
+  description: "Test encoding with ruby",
+  manifest_name: M3U8_NAME
+})
+
+manifest.outputs << Bitmovin::Encoding::StreamOutput.new({
+  output_id: s3_output.id,
+  output_path: OUTPUT_PATH
+})
+manifest.save!
+
+create_audio!(enc, manifest, s3_input, s3_output)
+
+# Adding Video Streams to Encoding
+video_configs.each do |config|
+  if (config[:name].start_with?("h264"))
+    codec_config = Bitmovin::Encoding::CodecConfigurations::H264Configuration.new(config)
+  else
+    codec_config = Bitmovin::Encoding::CodecConfigurations::H265Configuration.new(config)
+  end
+  codec_config.save!
+  config = OpenStruct.new(config)
+
+  str = enc.streams.build(name: codec_config.name)
+  str.codec_configuration = codec_config
+  str.build_input_stream(input_path: INPUT_FILE_PATH, input_id: s3_input.id, selection_mode: 'AUTO')
+  str.conditions = {
+    type: "CONDITION",
+    attribute: "HEIGHT",
+    operator: "<=",
+    value: codec_config.height
+  }
+  str.save!
+
+  muxing = enc.muxings.fmp4.build(name: "#{codec_config.name} muxing", segment_length: 4)
+  muxing.streams << str.id
+  muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, config.name),
+    acl: [{
+      permission: "PUBLIC_READ"
+    }]
+  })
+  muxing.save!
+  puts "Finished muxing #{muxing.name}"
+
+  # Add the Stream to the Manifest too
+  hls_stream = manifest.build_stream({
+    audio: 'audio_group',
+    closed_captions: 'NONE',
+    segmentPath: config.name,
+    encoding_id: enc.id,
+    muxing_id: muxing.id,
+    stream_id: str.id,
+    #drm_id: aes_muxing.id,
+    uri:  config.name + '.m3u8'
+  })
+  hls_stream.save!
+end
+
+# Starting an encoding and monitoring it's status
+enc.start!
+
+while(enc.status != 'FINISHED')
+  puts "Encoding Status is #{enc.status}"
+  progress = enc.progress
+  if (progress > 0)
+    puts "Progress: #{enc.progress} %"
+  end
+  sleep 2
+end
+puts "Encoding finished!"
+
+# Now that the encoding is finished we can start writing the m3u8 Manifest
+manifest.start!
+
+while(manifest.status != 'FINISHED')
+  puts "manifestoding Status is #{manifest.status}"
+  progress = manifest.progress
+  if (progress > 0)
+    puts "Progress: #{manifest.progress} %"
+  end
+  sleep 2
+end
+
+BEGIN {
+  # Begin is a hack to have this method available but define it at the end of the file
+def create_audio!(enc, manifest, s3_input, s3_output)
+
+  # Create or load the Audio Config
+  #audio_config = Bitmovin::Encoding::CodecConfigurations::AacConfiguration.find("<EXISTING_AAC_CONFIG_ID>")
+  audio_config = Bitmovin::Encoding::CodecConfigurations::AacConfiguration.new({
+    name: "AAC_PROFILE_128k",
+    bitrate: 128000,
+    rate: 48000
+  })
+  audio_config.save!
+  #
+  # Adding Audio Stream to Encoding
+  stream_aac = enc.streams.build(name: 'audio stream')
+  stream_aac.codec_configuration = audio_config
+  stream_aac.build_input_stream(input_path: INPUT_FILE_PATH, input_id: s3_input.id, selection_mode: 'AUTO')
+  stream_aac.conditions = {
+    type: "CONDITION",
+    attribute: "INPUTSTREAM",
+    operator: "==",
+    value: "TRUE"
+  }
+  puts stream_aac.conditions.to_json
+  stream_aac.save!
+
+  # Audio Muxing
+  audio_muxing = enc.muxings.fmp4.build(name: 'audio-muxing', segment_length: 4)
+  audio_muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, "audio/aac")
+  })
+  audio_muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, "audio/aac"),
+    acl: [{
+      permission: "PUBLIC_READ"
+    }]
+  })
+  audio_muxing.streams << stream_aac.id
+  audio_muxing.save!
+
+  # Adding Audio Stream to HLS Manifest
+  audio_stream_medium = manifest.build_audio_medium({
+    name: "HLS Audio Media",
+    group_id: "audio_group",
+    segment_path: "audio/aac",
+    encoding_id: enc.id,
+    stream_id: stream_aac.id,
+    muxing_id: audio_muxing.id,
+    language: "en",
+    uri: "audio_media.m3u8"
+  })
+  audio_stream_medium.save!
+end
+}

data/examples/simple_dash_with_http_input.rb

@@ -0,0 +1,216 @@
+# CONFIGURATION
+BITMOVIN_API_KEY = 'YOUR API KEY HERE'
+
+HTTP_INPUT_HOST = 'your.host.com'
+HTTP_INPUT_FILE_PATH = '/path/to/your/input/file.mkv'
+
+OUTPUT_AWS_ACCESS_KEY = 'YOUR AWS_ACCESS_KEY'
+OUTPUT_AWS_SECRET_KEY = 'YOUR AWS_SECRET_KEY'
+
+BUCKET_NAME = 'YOUR BUCKET NAME HERE'
+OUTPUT_PATH = 'path/to/output'
+MPD_NAME = 'manifest.mpd'
+
+# Please refer to our API spec to get available cloud regions
+# https://bitmovin.com/encoding-documentation/bitmovin-api/#/reference/encoding/encodings/create-encoding
+ENCODING_CLOUD_REGION = 'GOOGLE_EUROPE_WEST_1'
+
+Bitmovin.init(BITMOVIN_API_KEY)
+
+# This will create a http input
+# To get a list of all your HTTP outputs do:
+# Bitmovin::Encoding::Outputs::HttpOutput.list
+http_input = Bitmovin::Encoding::Inputs::HttpInput.new({
+                                                           host: HTTP_INPUT_HOST
+                                                       }).save!
+
+# For reuse set http_input_id = '<YOUR HTTP INPUT ID>' and omit creation
+http_input_id = http_input.id
+
+# This will create a Output Bucket you can reuse in future encodings
+# To get a list of all your Output do:
+# Bitmovin::Encoding::Outputs::S3Output.list
+s3_output = Bitmovin::Encoding::Outputs::S3Output.new({
+                                                          accessKey: OUTPUT_AWS_ACCESS_KEY,
+                                                          secretKey: OUTPUT_AWS_SECRET_KEY,
+                                                          bucketName: BUCKET_NAME
+                                                      }).save!
+
+# For reuse set s3_output_id = '<YOUR S3 OUTPUT ID>' and omit creation
+s3_output_id = s3_output.id
+
+# Codec Configurations are similar to Inputs/Outputs in that they are configured once
+# and can be reused for future encodings.
+codec_config_720_700 = Bitmovin::Encoding::CodecConfigurations::H264Configuration.new({
+                                                                                          name: 'H264 1280x720 700kb/s',
+                                                                                          profile: 'MAIN',
+                                                                                          width: 1280,
+                                                                                          height: 720,
+                                                                                          bitrate: 700000
+                                                                                      })
+codec_config_720_700.save!
+codec_config_720_1500 = Bitmovin::Encoding::CodecConfigurations::H264Configuration.new({
+                                                                                           name: 'H264 1280x720 1500kb/s',
+                                                                                           profile: 'MAIN',
+                                                                                           width: 1280,
+                                                                                           height: 720,
+                                                                                           bitrate: 1500000
+                                                                                       })
+codec_config_720_1500.save!
+codec_config_720_2400 = Bitmovin::Encoding::CodecConfigurations::H264Configuration.new({
+                                                                                           name: 'H264 1280x720 2400kb/s',
+                                                                                           profile: 'MAIN',
+                                                                                           width: 1280,
+                                                                                           height: 720,
+                                                                                           bitrate: 2400000
+                                                                                       })
+codec_config_720_2400.save!
+
+audio_config = Bitmovin::Encoding::CodecConfigurations::AacConfiguration.new({
+                                                                                 name: 'AAC_PROFILE_128k',
+                                                                                 bitrate: 128000,
+                                                                                 rate: 48000
+                                                                             })
+audio_config.save!
+
+
+# The actual instance of the encoding task you are about to start
+enc = Bitmovin::Encoding::Encodings::EncodingTask.new({
+                                                          name: 'VOD Encoding Ruby',
+                                                          cloud_region: ENCODING_CLOUD_REGION
+                                                      })
+enc.save!
+
+# Stream Configuration
+
+stream_720_700 = enc.streams.build(name: 'H264 1280x720 700kb/s')
+stream_720_700.codec_configuration = codec_config_720_700
+stream_720_700.build_input_stream(input_path: INPUT_FILE_PATH, input_id: http_input_id, selection_mode: 'AUTO')
+stream_720_700.save!
+
+stream_720_1500 = enc.streams.build(name: 'H264 1280x720 1500/s')
+stream_720_1500.codec_configuration = codec_config_720_1500
+stream_720_1500.build_input_stream(input_path: INPUT_FILE_PATH, input_id: http_input_id, selection_mode: 'AUTO')
+stream_720_1500.save!
+
+stream_720_2400 = enc.streams.build(name: 'H264 1280x720 2400/s')
+stream_720_2400.codec_configuration = codec_config_720_2400
+stream_720_2400.build_input_stream(input_path: INPUT_FILE_PATH, input_id: http_input_id, selection_mode: 'AUTO')
+stream_720_2400.save!
+
+stream_aac = enc.streams.build(name: 'audio stream')
+stream_aac.codec_configuration = audio_config
+stream_aac.build_input_stream(input_path: INPUT_FILE_PATH, input_id: http_input_id, selection_mode: 'AUTO')
+stream_aac.save!
+
+# Muxing Configuration
+
+fmp4_muxing_720_700 = enc.muxings.fmp4.build(name: 'H264 1280x720 700kb/s', segment_length: 4)
+fmp4_muxing_720_700.build_output({
+                                     output_id: s3_output_id,
+                                     output_path: File.join(OUTPUT_PATH, 'video/720_700')
+                                 })
+fmp4_muxing_720_700.streams << stream_720_700.id
+fmp4_muxing_720_700.save!
+
+fmp4_muxing_720_1500 = enc.muxings.fmp4.build(name: 'H264 1280x720 1500kb/s', segment_length: 4)
+fmp4_muxing_720_1500.build_output({
+                                      output_id: s3_output_id,
+                                      output_path: File.join(OUTPUT_PATH, 'video/720_1500')
+                                  })
+fmp4_muxing_720_1500.streams << stream_720_1500.id
+fmp4_muxing_720_1500.save!
+
+fmp4_muxing_720_2400 = enc.muxings.fmp4.build(name: 'H264 1280x720 2400kb/s', segment_length: 4)
+fmp4_muxing_720_2400.build_output({
+                                      output_id: s3_output_id,
+                                      output_path: File.join(OUTPUT_PATH, 'video/720_2400')
+                                  })
+fmp4_muxing_720_2400.streams << stream_720_2400.id
+fmp4_muxing_720_2400.save!
+
+audio_muxing = enc.muxings.fmp4.build(name: 'audio-muxing', segment_length: 4)
+audio_muxing.build_output({
+                              output_id: s3_output_id,
+                              output_path: File.join(OUTPUT_PATH, 'audio/aac')
+                          })
+audio_muxing.streams << stream_aac.id
+audio_muxing.save!
+
+
+# Starting an encoding and monitoring it's status
+enc.start!
+
+while enc.status != 'FINISHED' && enc.status != 'ERROR'
+  puts "Encoding Status is #{enc.status}"
+  progress = enc.progress
+  if progress > 0
+    puts "Progress: #{enc.progress} %"
+  end
+  sleep 2
+end
+puts "Encoding finished with status #{enc.status}!"
+
+
+# Generating a DASH Manifest
+puts 'Starting Manifest generation'
+manifest = Bitmovin::Encoding::Manifests::DashManifest.new({
+                                                               name: 'Test Ruby Manifest',
+                                                               description: 'Test encoding with ruby',
+                                                               manifest_name: MPD_NAME
+                                                           })
+
+manifest.outputs << Bitmovin::Encoding::StreamOutput.new({
+                                                             output_id: s3_output_id,
+                                                             output_path: OUTPUT_PATH
+                                                         })
+manifest.save!
+
+period = manifest.build_period()
+period.save!
+
+video_adaptationset = period.build_video_adaptationset()
+video_adaptationset.save!
+
+audio_adaptationset = period.build_audio_adaptationset({lang: 'en'})
+audio_adaptationset.save!
+
+video_adaptationset.build_fmp4_representation({
+                                                  encoding_id: enc.id,
+                                                  muxing_id: fmp4_muxing_720_2400.id,
+                                                  type: 'TEMPLATE',
+                                                  segment_path: 'video/720_2400'
+                                              }).save!
+video_adaptationset.build_fmp4_representation({
+                                                  encoding_id: enc.id,
+                                                  muxing_id: fmp4_muxing_720_1500.id,
+                                                  type: 'TEMPLATE',
+                                                  segment_path: 'video/720_1500'
+                                              }).save!
+video_adaptationset.build_fmp4_representation({
+                                                  encoding_id: enc.id,
+                                                  muxing_id: fmp4_muxing_720_700.id,
+                                                  type: 'TEMPLATE',
+                                                  segment_path: 'video/720_700'
+                                              }).save!
+
+audio_adaptationset.build_fmp4_representation({
+                                                  encoding_id: enc.id,
+                                                  muxing_id: audio_muxing.id,
+                                                  name: 'Audio representation',
+                                                  type: 'TEMPLATE',
+                                                  segment_path: 'audio/aac'
+                                              }).save!
+
+manifest.start!
+
+while manifest.status != 'FINISHED' && manifest.status != 'ERROR'
+  puts "Manifest Status is #{manifest.status}"
+  progress = manifest.progress
+  if progress > 0
+    puts "Progress: #{manifest.progress} %"
+  end
+  sleep 2
+end
+
+puts "Manifest generation finished with status #{manifest.status}!"

data/examples/simple_hls_with_aes128.rb

@@ -0,0 +1,197 @@
+require 'bitmovin-ruby'
+
+# CONFIGURATION
+BITMOVIN_API_KEY = "YOUR API KEY HERE"
+
+S3_INPUT_ID = "The ID of the Input"
+S3_OUTPUT_ID = "The ID of the Output"
+INPUT_FILE_PATH = "encoding/awolnation.mkv"
+OUTPUT_PATH = "/encoding_test/bitmovin-ruby/#{Time.now.strftime("%v-%H-%M")}/"
+M3U8_NAME = "playlist.m3u8" 
+
+DRM_AES_KEY = "759678DC403B3CB84125E8E0F0824CD6" # Change this to something else
+DRM_AES_IV = "196E6EB871BBC09191A3995318406198" 
+
+Bitmovin.init(BITMOVIN_API_KEY)
+
+# This will create a Input Bucket you can reuse in future encodings
+# To get a list of all your S3Inputs do:
+# Bitmovin::Encoding::Inputs::S3Input.list
+s3_input = Bitmovin::Encoding::Inputs::S3Input.find(S3_INPUT_ID)
+
+# This will create a Output Bucket you can reuse in future encodings
+# To get a list of all your Output do:
+# Bitmovin::Encoding::Outputs::S3Output.list
+s3_output = Bitmovin::Encoding::Outputs::S3Output.find(S3_OUTPUT_ID)
+
+# Please note inputs/outputs are not individual files but rather the 
+# Bucket you are reading/writing files to and they can be reused between encodings.
+
+
+# This hash contains the H264 Codec Configurations we want to create
+# Codec Configurations are similar to Inputs/Outputs in that they are configured once
+# and can be reused for future encodings. 
+video_configs = [
+  { name: "h264_720p_700",
+    profile: "MAIN",
+    height: 720,
+    bitrate: 700000
+}, {
+  name: "h264_540p_500",
+    profile: "MAIN",
+    height: 540,
+    bitrate: 500000
+  }
+]
+
+# The actual instance of the encoding task you are about to start
+enc = Bitmovin::Encoding::Encodings::EncodingTask.new({
+  name: "VOD Encoding HLS AES128 Ruby"
+})
+enc.save!
+
+
+# Let's also start the Manifest generation
+manifest = Bitmovin::Encoding::Manifests::HlsManifest.new({
+  name: 'Test Ruby Manifest',
+  description: "Test encoding with ruby",
+  manifest_name: M3U8_NAME
+})
+
+manifest.outputs << Bitmovin::Encoding::StreamOutput.new({
+  output_id: s3_output.id,
+  output_path: OUTPUT_PATH
+})
+manifest.save!
+
+create_audio!(enc, manifest, s3_input, s3_output)
+
+# Adding Video Streams to Encoding
+video_configs.each do |config|
+  h264_config = Bitmovin::Encoding::CodecConfigurations::H264Configuration.new(config)
+  h264_config.save!
+  config = OpenStruct.new(config)
+
+  str = enc.streams.build(name: h264_config.name)
+  str.codec_configuration = h264_config
+  str.build_input_stream(input_path: INPUT_FILE_PATH, input_id: s3_input.id, selection_mode: 'AUTO')
+  str.save!
+
+  muxing = enc.muxings.ts.build(name: "#{h264_config.name} muxing", segment_length: 4)
+  muxing.streams << str.id
+  muxing.save!
+
+  aes_muxing = muxing.drms.aes.build({
+    key: DRM_AES_KEY,
+    iv: DRM_AES_IV,
+    method: 'AES_128',
+    name: "AES DRM for #{muxing.name}"
+  })
+  aes_muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, config.name),
+    acl: [{
+      permission: "PUBLIC_READ"
+    }]
+  })
+  aes_muxing.save!
+  puts "Finished DRM Muxing"
+
+  # Add the Stream to the Manifest too
+  hls_stream = manifest.build_stream({
+    audio: 'audio_group',
+    closed_captions: 'NONE',
+    segmentPath: config.name,
+    encoding_id: enc.id,
+    muxing_id: muxing.id,
+    stream_id: str.id,
+    drm_id: aes_muxing.id,
+    uri:  config.name + '.m3u8'
+  })
+  hls_stream.save!
+end
+
+# Starting an encoding and monitoring it's status
+enc.start!
+
+while(enc.status != 'FINISHED')
+  puts "Encoding Status is #{enc.status}"
+  progress = enc.progress
+  if (progress > 0)
+    puts "Progress: #{enc.progress} %"
+  end
+  sleep 2
+end
+puts "Encoding finished!"
+
+# Now that the encoding is finished we can start writing the m3u8 Manifest
+manifest.start!
+
+while(manifest.status != 'FINISHED')
+  puts "manifestoding Status is #{manifest.status}"
+  progress = manifest.progress
+  if (progress > 0)
+    puts "Progress: #{manifest.progress} %"
+  end
+  sleep 2
+end
+
+BEGIN {
+  # Begin is a hack to have this method available but define it at the end of the file
+def create_audio!(enc, manifest, s3_input, s3_output)
+
+  # Create or load the Audio Config
+  #audio_config = Bitmovin::Encoding::CodecConfigurations::AacConfiguration.find("<EXISTING_AAC_CONFIG_ID>")
+  audio_config = Bitmovin::Encoding::CodecConfigurations::AacConfiguration.new({
+    name: "AAC_PROFILE_128k",
+    bitrate: 128000,
+    rate: 48000
+  })
+  audio_config.save!
+  #
+  # Adding Audio Stream to Encoding
+  stream_aac = enc.streams.build(name: 'audio stream')
+  stream_aac.codec_configuration = audio_config
+  stream_aac.build_input_stream(input_path: INPUT_FILE_PATH, input_id: s3_input.id, selection_mode: 'AUTO')
+  stream_aac.save!
+
+  # Audio Muxing
+  audio_muxing = enc.muxings.ts.build(name: 'audio-muxing', segment_length: 4)
+  audio_muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, "audio/aac")
+  })
+  audio_muxing.streams << stream_aac.id
+  audio_muxing.save!
+
+  aes_audio_muxing = audio_muxing.drms.aes.build({
+    key: DRM_AES_KEY,
+    iv: DRM_AES_IV,
+    method: 'AES_128',
+    name: "AES DRM for Audio"
+  })
+  aes_audio_muxing.build_output({
+    output_id: s3_output.id,
+    output_path: File.join(OUTPUT_PATH, "audio/aac"),
+    acl: [{
+      permission: "PUBLIC_READ"
+    }]
+  })
+  aes_audio_muxing.save!
+  puts "Finished DRM Muxing"
+
+  # Adding Audio Stream to HLS Manifest
+  audio_stream_medium = manifest.build_audio_medium({
+    name: "HLS Audio Media",
+    group_id: "audio_group",
+    segment_path: "audio/aac",
+    encoding_id: enc.id,
+    stream_id: stream_aac.id,
+    muxing_id: audio_muxing.id,
+    drm_id: aes_audio_muxing.id,
+    language: "en",
+    uri: "audio_media.m3u8"
+  })
+  audio_stream_medium.save!
+end
+}

data/lib/bitmovin/encoding/codec_configurations/h265_configuration.rb

@@ -3,6 +3,7 @@ module Bitmovin::Encoding::CodecConfigurations
     init 'encoding/configurations/video/h265'
 
   attr_accessor :id, :name, :description, :created_at, :modified_at
+  attr_accessor :width, :height
   attr_accessor :name, :description, :bitrate, :rate, :profile, :bframes, :ref_frames, :qp, :max_bitrate, :min_bitrate, :bufsize, :min_gop, :max_gop, :level, :rc_lookahead, :b_adapt, :max_ctu_size, :tu_intra_depth, :tu_inter_depth, :motion_search, :sub_me, :motion_search_range, :weight_prediction_on_p_slice, :weight_prediction_on_b_slice, :sao
   end
 end

data/lib/bitmovin/encoding/encodings/muxings/drms/drm_muxing_resource.rb

@@ -0,0 +1,54 @@
+module Bitmovin::Encoding::Encodings::Muxings::Drms
+  class DrmMuxingResource < Bitmovin::Resource
+    attr_accessor :name, :description, :created_at, :modified_at
+    attr_accessor :encoding_id, :muxing_id
+    attr_accessor :id
+    attr_accessor :outputs
+
+    def initialize(encoding_id, muxing_id, hash = {})
+      hsh = ActiveSupport::HashWithIndifferentAccess.new(underscore_hash(hash))
+      @encoding_id = encoding_id
+      @muxing_id = muxing_id
+      muxing_type = self.class.name.demodulize.gsub(/(.*)Muxing.*/, '\1').downcase
+      encryption_type = self.class.name.demodulize.gsub(/.*Muxing(.*)Encryption/, '\1').downcase
+      self.class.init(File.join("/v1/encoding/encodings/", encoding_id, "muxings", muxing_type, muxing_id, "drm", encryption_type))
+      super(hsh)
+      @outputs = (hsh[:outputs] || []).map do |output|
+        Bitmovin::Encoding::StreamOutput.new(output)
+      end
+    end
+
+    def build_output(opts = {})
+      output = Bitmovin::Encoding::StreamOutput.new(opts)
+      @outputs << output
+      output
+    end
+
+    private
+
+    def collect_attributes
+      val = Hash.new
+      ignored_variables = []
+      if (self.respond_to?(:ignore_fields))
+        ignored_variables = self.ignore_fields
+      end
+      instance_variables.each do |name|
+        if ignored_variables.include?(name)
+          next
+        end
+        if name == :@outputs
+          val["outputs"] = @outputs.map { |o| o.send(:collect_attributes) }
+          next
+        end
+
+        if name == :@streams
+          val["streams"] = @streams.map { |s| { "streamId" => s } }
+          next
+        end
+        json_name = ActiveSupport::Inflector.camelize(name.to_s.gsub(/@/, ''), false)
+        val[json_name] = instance_variable_get(name)
+      end
+      val
+    end
+  end
+end

data/lib/bitmovin/encoding/encodings/muxings/drms/drm_muxings.rb

@@ -0,0 +1,6 @@
+module Bitmovin::Encoding::Encodings::Muxings::Ts
+  module Drm
+  end
+end
+require_relative 'drm_muxing_resource'
+require_relative 'ts_muxing_aes_encryption'