WIP PR - Per-Title Fixed Resolutions and Bitrates

bitmovin/resources/enums/__init__.py

@@ -73,5 +73,7 @@
 from .h265_adaptive_quantization_mode import H265AdaptiveQuantizationMode
 from .hls_version import HlsVersion
 from .stream_conditions_mode import StreamConditionsMode
+from .per_title_fixed_resolution_and_bitrate_calculation_mode import PerTitleFixedResolutionAndBitrateCalculationMode
+from .bitrate_selection_mode import BitrateSelectionMode
 from .internal_chunk_length_mode import InternalChunkLengthMode
 from .caption_character_encoding import CaptionCharacterEncoding

bitmovin/resources/enums/bitrate_selection_mode.py

@@ -0,0 +1,6 @@
+import enum
+
+
+class BitrateSelectionMode(enum.Enum):
+    OPTIMIZED = 'OPTIMIZED'
+    COMPLEXITY_RANGE = 'COMPLEXITY_RANGE'

bitmovin/resources/enums/per_title_fixed_resolution_and_bitrate_calculation_mode.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class PerTitleFixedResolutionAndBitrateCalculationMode(Enum):
+    LAST_CALCULATED_BITRATE = 'LAST_CALCULATED_BITRATE'
+    MINIMUM = 'MINIMUM'
+    MAXIMUM = 'MAXIMUM'
+    AVERAGE = 'AVERAGE'

bitmovin/resources/enums/stream_mode.py

@@ -6,3 +6,4 @@ class StreamMode(Enum):
     STANDARD = 'STANDARD'
     PER_TITLE_RESULT = 'PER_TITLE_RESULT'
     PER_TITLE_TEMPLATE_FIXED_RESOLUTION = 'PER_TITLE_TEMPLATE_FIXED_RESOLUTION'
+    PER_TITLE_TEMPLATE_FIXED_RESOLUTION_AND_BITRATE = 'PER_TITLE_TEMPLATE_FIXED_RESOLUTION_AND_BITRATE'

bitmovin/resources/models/codecconfigurations/h265_codec_configuration.py

@@ -18,7 +18,8 @@ def __init__(self, name, bitrate, rate, profile, id_=None, description=None, cus
                  scene_cut_threshold=None, enable_hlg_signaling=None, video_format=None, hdr=None, master_display=None,
                  max_content_light_level=None, max_picture_average_light_level=None, sample_aspect_ratio_numerator=None,
                  sample_aspect_ratio_denominator=None, adaptive_quantization_mode=None, psy_rate_distortion_optimization=None,
-                 psy_rate_distortion_optimization_quantization=None, cutree=None, qp_min=None, qp_max=None):
+                 psy_rate_distortion_optimization_quantization=None, cutree=None, qp_min=None, qp_max=None,
+                 adaptive_quantization_strength=None):
 
         super().__init__(id_=id_, custom_data=custom_data, name=name, description=description, bitrate=bitrate,
                          rate=rate, width=width, height=height, pixel_format=pixel_format)
@@ -69,6 +70,7 @@ def __init__(self, name, bitrate, rate, profile, id_=None, description=None, cus
         self.sampleAspectRatioDenominator = sample_aspect_ratio_denominator
         self._adaptive_quantization_mode = None
         self.adaptiveQuantizationMode = adaptive_quantization_mode
+        self.adaptiveQuantizationStrength = adaptive_quantization_strength
         self.psyRateDistortionOptimization = psy_rate_distortion_optimization
         self.psyRateDistortionOptimizedQuantization = psy_rate_distortion_optimization_quantization
         self.cutree = cutree
@@ -313,6 +315,7 @@ def parse_from_json_object(cls, json_object):
         aspect_ratio_numerator = json_object.get('sampleAspectRatioNumerator')
         aspect_ratio_denominator = json_object.get('sampleAspectRatioDenominator')
         adaptive_quantization_mode = json_object.get('adaptiveQuantizationMode')
+        adaptive_quantization_strength = json_object.get('adaptiveQuantizationStrength')
         psy_rate_distortion_optimization = json_object.get('psyRateDistortionOptimization')
         psy_rate_distortion_optimization_quantization = json_object.get('psyRateDistortionOptimizedQuantization')
         cutree = json_object.get('cutree')
@@ -370,6 +373,7 @@ def parse_from_json_object(cls, json_object):
                                                           sample_aspect_ratio_numerator=aspect_ratio_numerator,
                                                           sample_aspect_ratio_denominator=aspect_ratio_denominator,
                                                           adaptive_quantization_mode=adaptive_quantization_mode,
+                                                          adaptive_quantization_strength=adaptive_quantization_strength,
                                                           psy_rate_distortion_optimization=psy_rate_distortion_optimization,
                                                           psy_rate_distortion_optimization_quantization=psy_rate_distortion_optimization_quantization,
                                                           cutree=cutree,

bitmovin/resources/models/codecconfigurations/vp9_codec_configuration.py

@@ -5,7 +5,7 @@
 
 from bitmovin.utils import Serializable
 from .video_codec_configuration import VideoCodecConfiguration
-
+from .color_config import ColorConfig
 
 class VP9CodecConfiguration(VideoCodecConfiguration, Serializable):
 
@@ -15,7 +15,7 @@ def __init__(self, name, bitrate, rate=None, id_=None, description=None, custom_
                  rate_overshoot_pct=None, cpu_used=None, noise_sensitivity=None, quality=None,
                  lossless=None, static_thresh=None, aq_mode=None, arnr_max_frames=None, 
                  arnr_strength=None, arnr_type=None, pixel_format=None, min_gop=None, max_gop=None,
-                 min_keyframe_interval=None, max_keyframe_interval=None):
+                 min_keyframe_interval=None, max_keyframe_interval=None, color_config=None):
 
         super().__init__(id_=id_, custom_data=custom_data, name=name, description=description, bitrate=bitrate,
                          rate=rate, width=width, height=height, pixel_format=pixel_format)
@@ -46,6 +46,8 @@ def __init__(self, name, bitrate, rate=None, id_=None, description=None, custom_
         self.maxGop = max_gop
         self.minKeyframeInterval = min_keyframe_interval
         self.maxKeyframeInterval = max_keyframe_interval
+        self._colorConfig = None
+        self.colorConfig = color_config
 
     @property
     def quality(self):
@@ -95,6 +97,19 @@ def arnrType(self, new_arnrType):
             raise InvalidTypeError(
                 'Invalid type {} for arnrType: must be either str or VP9ARNRType!'.format(type(new_arnrType)))
 
+    @property
+    def colorConfig(self):
+        return self._colorConfig
+
+    @colorConfig.setter
+    def colorConfig(self, new_color_config):
+        if new_color_config is None:
+            self._colorConfig = None
+        elif isinstance(new_color_config, ColorConfig):
+            self._colorConfig = new_color_config
+        else:
+            raise InvalidTypeError('colorConfig has to be of type ColorConfig')
+
     @classmethod
     def parse_from_json_object(cls, json_object):
         video_codec_configuration = VideoCodecConfiguration.parse_from_json_object(json_object=json_object)
@@ -132,7 +147,33 @@ def parse_from_json_object(cls, json_object):
         max_gop = json_object.get('maxGop')
         min_keyframe_interval = json_object.get('minKeyframeInterval')
         max_keyframe_interval = json_object.get('maxKeyframeInterval')
-
+
+        color_config = None
+        color_config_json = json_object.get('colorConfig')
+        if color_config_json is not None:
+            copy_chroma_location_flag = color_config_json.get('copyChromaLocationFlag')
+            copy_color_space_flag = color_config_json.get('copyColorSpaceFlag')
+            copy_color_primaries_flag = color_config_json.get('copyColorPrimariesFlag')
+            copy_color_range_flag = color_config_json.get('copyColorRangeFlag')
+            copy_color_transfer_flag = color_config_json.get('copyColorTransferFlag')
+            chroma_location = color_config_json.get('chromaLocation')
+            color_space = color_config_json.get('colorSpace')
+            color_primaries = color_config_json.get('colorPrimaries')
+            color_range = color_config_json.get('colorRange')
+            color_transfer = color_config_json.get('colorTransfer')
+            input_color_space = color_config_json.get('inputColorSpace')
+            input_color_range = color_config_json.get('inputColorRange')
+
+            color_config = ColorConfig(copy_chroma_location_flag=copy_chroma_location_flag,
+                                       copy_color_space_flag=copy_color_space_flag,
+                                       copy_color_primaries_flag=copy_color_primaries_flag,
+                                       copy_color_range_flag=copy_color_range_flag,
+                                       copy_color_transfer_flag=copy_color_transfer_flag,
+                                       chroma_location=chroma_location, color_space=color_space,
+                                       color_primaries=color_primaries, color_range=color_range,
+                                       color_transfer=color_transfer, input_color_space=input_color_space,
+                                       input_color_range=input_color_range)
+
         vp9_codec_configuration = VP9CodecConfiguration(name=name, bitrate=bitrate, rate=rate, id_=id_, 
                                                         description=description, custom_data=custom_data, width=width, 
                                                         height=height, lag_in_frames=lag_in_frames, 
@@ -147,7 +188,8 @@ def parse_from_json_object(cls, json_object):
                                                         arnr_strength=arnr_strength, arnr_type=arnr_type,
                                                         pixel_format=pixel_format, min_gop=min_gop, max_gop=max_gop,
                                                         min_keyframe_interval=min_keyframe_interval,
-                                                        max_keyframe_interval=max_keyframe_interval)
+                                                        max_keyframe_interval=max_keyframe_interval,
+                                                        color_config=color_config)
 
         return vp9_codec_configuration
 
@@ -156,4 +198,8 @@ def serialize(self):
         serialized['quality'] = self.quality
         serialized['aqMode'] = self.aqMode
         serialized['arnrType'] = self.arnrType
+
+        if isinstance(self.colorConfig, ColorConfig):
+            serialized['colorConfig'] = self.colorConfig.serialize()
+
         return serialized

bitmovin/resources/models/encodings/__init__.py

@@ -27,7 +27,8 @@
 from .conditions import ConditionType, Condition, AndConjunction, OrConjunction
 from .stream_metadata import StreamMetadata
 from .pertitle import PerTitle, PerTitleConfiguration, H264PerTitleConfiguration, H265PerTitleConfiguration, \
-    VP9PerTitleConfiguration, AutoRepresentation
+    VP9PerTitleConfiguration, AutoRepresentation, StreamPerTitleSettings, StreamPerTitleFixedResolutionAndBitrateSettings, \
+    PerTitleFixedResolutionAndBitrateConfiguration
 from .captions import BurnInSrtSubtitle
 from .encoding_input import EncodingInput
 from .inputstreams import IngestInputStream, ConcatenationInputStreamConfiguration, ConcatenationInputStream, \

bitmovin/resources/models/encodings/pertitle/__init__.py

@@ -4,3 +4,6 @@
 from .h265_per_title_configuration import H265PerTitleConfiguration
 from .vp9_per_title_configuration import VP9PerTitleConfiguration
 from .per_title_configuration import PerTitleConfiguration
+from .stream_per_title_fixed_res_bitrate_settings import StreamPerTitleFixedResolutionAndBitrateSettings
+from .stream_per_title_settings import StreamPerTitleSettings
+from .fixed_resolution_and_bitrate_configuration import PerTitleFixedResolutionAndBitrateConfiguration

bitmovin/resources/models/encodings/pertitle/fixed_resolution_and_bitrate_configuration.py

@@ -0,0 +1,32 @@
+from bitmovin.utils import Serializable
+from bitmovin.resources.enums import PerTitleFixedResolutionAndBitrateCalculationMode
+
+class PerTitleFixedResolutionAndBitrateConfiguration(Serializable):
+    def __init__(self, forced_renditions, forced_rendition_factor, forced_rendition_calculation_mode):
+        self.forcedRenditionAboveHighestFixedRepresentation = forced_renditions
+        self.forcedRenditionAboveHighestFixedRepresentationFactor = forced_rendition_factor
+
+        self._forced_rendition_calculation_mode = None
+        self.forcedRenditionAboveHighestFixedRepresentationCalculationMode = forced_rendition_calculation_mode
+
+    @property
+    def forcedRenditionAboveHighestFixedRepresentationCalculationMode(self):
+        return self._forced_rendition_calculation_mode
+
+    @forcedRenditionAboveHighestFixedRepresentationCalculationMode.setter
+    def forcedRenditionAboveHighestFixedRepresentationCalculationMode(self, new_forced_rendition_calculation_mode):
+        if new_forced_rendition_calculation_mode is None:
+            self._forced_rendition_calculation_mode = None
+            return
+        if isinstance(new_forced_rendition_calculation_mode, str):
+            self._forced_rendition_calculation_mode = new_forced_rendition_calculation_mode
+        elif isinstance(new_forced_rendition_calculation_mode, PerTitleFixedResolutionAndBitrateCalculationMode):
+            self._forced_rendition_calculation_mode = new_forced_rendition_calculation_mode.value
+        else:
+            raise InvalidTypeError(
+                'Invalid type {} for forcedRenditionAboveHighestFixedRepresentationCalculationMode: must be either str or PerTitleFixedResolutionAndBitrateCalculationMode!'.format(type(new_forced_rendition_calculation_mode)))
+
+    def serialize(self):
+        serialized = super().serialize()
+        serialized['forcedRenditionAboveHighestFixedRepresentationCalculationMode'] = self.forcedRenditionAboveHighestFixedRepresentationCalculationMode
+        return serialized

bitmovin/resources/models/encodings/pertitle/h264_per_title_configuration.py

@@ -5,10 +5,10 @@ class H264PerTitleConfiguration(PerTitleConfiguration):
     def __init__(self, min_bitrate=None, max_bitrate=None, min_bitrate_step_size=None,
                  max_bitrate_step_size=None, target_quality_crf=None, auto_representations=None,
                  codec_min_bitrate_factor=None, codec_max_bitrate_factor=None, codec_bufsize_factor=None,
-                 complexity_factor=None):
+                 complexity_factor=None, fixed_resolution_and_bitrate_configuration=None):
         super().__init__(min_bitrate=min_bitrate, max_bitrate=max_bitrate, min_bitrate_step_size=min_bitrate_step_size,
                          max_bitrate_step_size=max_bitrate_step_size, auto_representations=auto_representations,
-                         complexity_factor=complexity_factor)
+                         complexity_factor=complexity_factor, fixed_resolution_and_bitrate_configuration=fixed_resolution_and_bitrate_configuration)
         self.targetQualityCrf = target_quality_crf
         self.codecMinBitrateFactor = codec_min_bitrate_factor
         self.codecMaxBitrateFactor = codec_max_bitrate_factor 

bitmovin/resources/models/encodings/pertitle/h265_per_title_configuration.py

@@ -5,10 +5,10 @@ class H265PerTitleConfiguration(PerTitleConfiguration):
     def __init__(self, min_bitrate=None, max_bitrate=None, min_bitrate_step_size=None,
                  max_bitrate_step_size=None, target_quality_crf=None, auto_representations=None,
                  codec_min_bitrate_factor=None, codec_max_bitrate_factor=None, codec_bufsize_factor=None,
-                 complexity_factor=None):
+                 complexity_factor=None, fixed_resolution_and_bitrate_configuration=None):
         super().__init__(min_bitrate=min_bitrate, max_bitrate=max_bitrate, min_bitrate_step_size=min_bitrate_step_size,
                          max_bitrate_step_size=max_bitrate_step_size, auto_representations=auto_representations,
-                         complexity_factor=complexity_factor)
+                         complexity_factor=complexity_factor, fixed_resolution_and_bitrate_configuration=fixed_resolution_and_bitrate_configuration)
         self.targetQualityCrf = target_quality_crf
         self.codecMinBitrateFactor = codec_min_bitrate_factor
         self.codecMaxBitrateFactor = codec_max_bitrate_factor

bitmovin/resources/models/encodings/pertitle/per_title_configuration.py

@@ -1,11 +1,12 @@
 from bitmovin.errors import InvalidTypeError
 from bitmovin.utils import Serializable
 from .auto_representation import AutoRepresentation
+from .fixed_resolution_and_bitrate_configuration import PerTitleFixedResolutionAndBitrateConfiguration
 
 
 class PerTitleConfiguration(Serializable):
     def __init__(self, min_bitrate=None, max_bitrate=None, min_bitrate_step_size=None, max_bitrate_step_size=None,
-                 auto_representations=None, complexity_factor=None):
+                 auto_representations=None, complexity_factor=None, fixed_resolution_and_bitrate_configuration=None):
         super().__init__()
         self.minBitrate = min_bitrate
         self.maxBitrate = max_bitrate
@@ -15,6 +16,9 @@ def __init__(self, min_bitrate=None, max_bitrate=None, min_bitrate_step_size=Non
 
         self._auto_representations = None
         self.autoRepresentations = auto_representations
+
+        self._fixedResolutionAndBitrateConfiguration = None
+        self.fixedResolutionAndBitrateConfiguration = fixed_resolution_and_bitrate_configuration
 
     @property
     def autoRepresentations(self):
@@ -33,7 +37,25 @@ def autoRepresentations(self, new_auto_representations):
 
         self._auto_representations = new_auto_representations
 
+    @property
+    def fixedResolutionAndBitrateConfiguration(self):
+        return self._fixedResolutionAndBitrateConfiguration
+
+    @fixedResolutionAndBitrateConfiguration.setter
+    def fixedResolutionAndBitrateConfiguration(self, new_fixed_resolution_and_bitrate_configuration):
+        if new_fixed_resolution_and_bitrate_configuration is None:
+            self._fixedResolutionAndBitrateConfiguration = None
+            return
+
+        if not isinstance(new_fixed_resolution_and_bitrate_configuration, PerTitleFixedResolutionAndBitrateConfiguration):
+            raise InvalidTypeError(
+                'Invalid type {} for fixed_resolution_and_bitrate_configuration: must be PerTitleFixedResolutionAndBitrateConfiguration!'.format(
+                    type(new_fixed_resolution_and_bitrate_configuration)))
+
+        self._fixedResolutionAndBitrateConfiguration = new_fixed_resolution_and_bitrate_configuration
+
     def serialize(self):
         serialized = super().serialize()
         serialized['autoRepresentations'] = self.autoRepresentations
+        serialized['fixedResolutionAndBitrateConfiguration'] = self.fixedResolutionAndBitrateConfiguration
         return serialized