def transfer_function(state, video_parameters):
"""(11.4.10.4)"""
custom_transfer_function_flag = read_bool(state)
# (C.3) Check level allows custom transfer functions
## Begin not in spec
assert_level_constraint(
state, "custom_transfer_function_flag", custom_transfer_function_flag
)
## End not in spec
if custom_transfer_function_flag:
index = read_uint(state)
# (11.4.10.3) Index should be a supported value
## Begin not in spec
assert_in_enum(index, PresetTransferFunctions, BadPresetTransferFunction)
## End not in spec
# (C.3) Check level allows the specified preset
## Begin not in spec
assert_level_constraint(state, "transfer_function_index", index)
## End not in spec
# (11.2.2) Preset must be supported by current version
## Begin not in spec
minimum_required_version = preset_transfer_function_version_implication(index)
if state["major_version"] < minimum_required_version:
raise PresetTransferFunctionNotSupportedByVersion(
index, state["major_version"]
)
log_version_lower_bound(state, minimum_required_version)
## End not in spec
preset_transfer_function(video_parameters, index)
def scan_format(state, video_parameters):
"""(11.4.5)"""
custom_scan_format_flag = read_bool(state)
# (C.3) Check level allows custom scan formats
## Begin not in spec
assert_level_constraint(state, "custom_scan_format_flag", custom_scan_format_flag)
## End not in spec
if custom_scan_format_flag:
video_parameters["source_sampling"] = read_uint(state)
# (11.4.5) Mode be a known value
## Begin not in spec
assert_in_enum(
video_parameters["source_sampling"],
SourceSamplingModes,
BadSourceSamplingMode,
)
## End not in spec
# (C.3) Check level allows this value
## Begin not in spec
assert_level_constraint(
state,
"source_sampling",
video_parameters["source_sampling"],
)
def color_spec(state, video_parameters):
"""(11.4.10.1)"""
custom_color_spec_flag = read_bool(state)
# (C.3) Check level allows custom color specs
## Begin not in spec
assert_level_constraint(state, "custom_color_spec_flag", custom_color_spec_flag)
## End not in spec
if custom_color_spec_flag:
index = read_uint(state)
# (11.4.10.1) Index should be a supported value
assert_in_enum(index, PresetColorSpecs, BadPresetColorSpec) ## Not in spec
# (C.3) Check level allows the specified preset
assert_level_constraint(state, "color_spec_index", index) ## Not in spec
preset_color_spec(video_parameters, index)
if index == 0:
color_primaries(state, video_parameters)
color_matrix(state, video_parameters)
transfer_function(state, video_parameters)
## Begin not in spec
else:
# (11.2.2) Color spec must be supported by current version
minimum_required_version = preset_color_spec_version_implication(index)
if state["major_version"] < minimum_required_version:
raise PresetColorSpecNotSupportedByVersion(
index, state["major_version"]
)
log_version_lower_bound(state, minimum_required_version)
def transform_parameters(state):
"""(12.4.1)"""
state["wavelet_index"] = read_uint(state)
# (12.4.1) Check wavelet type is supported
## Begin not in spec
assert_in_enum(state["wavelet_index"], WaveletFilters, BadWaveletIndex)
## End not in spec
# (C.3) Check level allows this wavelet type
## Begin not in spec
assert_level_constraint(state, "wavelet_index", state["wavelet_index"])
## End not in spec
state["dwt_depth"] = read_uint(state)
# (C.3) Check level allows this wavelet depth
assert_level_constraint(state, "dwt_depth",
state["dwt_depth"]) ## Not in spec
state["wavelet_index_ho"] = state["wavelet_index"]
state["dwt_depth_ho"] = 0
if state["major_version"] >= 3:
extended_transform_parameters(state)
slice_parameters(state)
quant_matrix(state)
def color_diff_sampling_format(state, video_parameters):
"""(11.4.4)"""
custom_color_diff_format_flag = read_bool(state)
# (C.3) Check level allows custom color difference sampling
## Begin not in spec
assert_level_constraint(
state, "custom_color_diff_format_flag", custom_color_diff_format_flag
)
## End not in spec
if custom_color_diff_format_flag:
video_parameters["color_diff_format_index"] = read_uint(state)
# (11.4.4) Index shall be a known value
## Begin not in spec
assert_in_enum(
video_parameters["color_diff_format_index"],
ColorDifferenceSamplingFormats,
BadColorDifferenceSamplingFormat,
)
## End not in spec
# (C.3) Check level allows this value
## Begin not in spec
assert_level_constraint(
state,
"color_diff_format_index",
video_parameters["color_diff_format_index"],
)
def clean_area(state, video_parameters):
"""(11.4.8)"""
custom_clean_area_flag = read_bool(state)
# (C.3) Check level allows custom clean area
## Begin not in spec
assert_level_constraint(state, "custom_clean_area_flag", custom_clean_area_flag)
## End not in spec
if custom_clean_area_flag:
video_parameters["clean_width"] = read_uint(state)
# (C.3) Check level allows this width
## Begin not in spec
assert_level_constraint(state, "clean_width", video_parameters["clean_width"])
## End not in spec
video_parameters["clean_height"] = read_uint(state)
# (C.3) Check level allows this height
## Begin not in spec
assert_level_constraint(state, "clean_height", video_parameters["clean_height"])
## End not in spec
video_parameters["left_offset"] = read_uint(state)
# (C.3) Check level allows this offset
## Begin not in spec
assert_level_constraint(state, "left_offset", video_parameters["left_offset"])
## End not in spec
video_parameters["top_offset"] = read_uint(state)
# (C.3) Check level allows this offset
## Begin not in spec
assert_level_constraint(state, "top_offset", video_parameters["top_offset"])
## End not in spec
# (11.4.8) The clean area is restricted to being within the existing
# picture area
## Begin not in spec
if not (
video_parameters["clean_width"] + video_parameters["left_offset"]
<= video_parameters["frame_width"]
and video_parameters["clean_height"] + video_parameters["top_offset"]
<= video_parameters["frame_height"]
):
raise CleanAreaOutOfRange(
video_parameters["clean_width"],
video_parameters["clean_height"],
video_parameters["left_offset"],
video_parameters["top_offset"],
video_parameters["frame_width"],
video_parameters["frame_height"],
)
def parse_parameters(state):
"""(11.2.1)"""
state["major_version"] = read_uint(state)
# (11.2.2) Check the major_version is at least 1. (It may need to be
# higher depending on the features used on the sequence, but this will be
# checked as the stream is processed. Later, at the end of the stream we'll
# also check the major_version was not too high for the set of features
# actually used.)
## Begin not in spec
if state["major_version"] < MINIMUM_MAJOR_VERSION:
raise MajorVersionTooLow(state["major_version"])
## End not in spec
state["minor_version"] = read_uint(state)
# (11.2.2) Check the minor_version is 0.
## Begin not in spec
if state["minor_version"] != 0:
raise MinorVersionNotZero(state["minor_version"])
## End not in spec
state["profile"] = read_uint(state)
# (C.2) Profile must be a supported value
assert_in_enum(state["profile"], Profiles, BadProfile) ## Not in spec
# (11.2.2) Profile must be supported by current version
## Begin not in spec
minimum_required_version = profile_version_implication(state["profile"])
if state["major_version"] < minimum_required_version:
raise ProfileNotSupportedByVersion(state["profile"], state["major_version"])
log_version_lower_bound(state, minimum_required_version)
## End not in spec
state["level"] = read_uint(state)
# (C.3) Level must be a supported value
assert_in_enum(state["level"], Levels, BadLevel) ## Not in spec
# (C.3) Levels may constrain the order and choice of data units in a
# sequence. See the various level standards documents (e.g. ST 2042-2) for
# details.
## Begin not in spec
if "_level_sequence_matcher" not in state:
state["_level_sequence_matcher"] = Matcher(
LEVEL_SEQUENCE_RESTRICTIONS[state["level"]].sequence_restriction_regex
)
# If we're at this point we're currently reading the first sequence
# header (in the first data unit) of a sequence. Advance the state
# machine accordingly.
assert state["_level_sequence_matcher"].match_symbol("sequence_header")
## End not in spec
# (C.3) Levels may constrain the allowed profiles and versions
## Begin not in spec
assert_level_constraint(state, "level", state["level"])
assert_level_constraint(state, "profile", state["profile"])
assert_level_constraint(state, "major_version", state["major_version"])
assert_level_constraint(state, "minor_version", state["minor_version"])
def test_level_constraints():
state = State()
# Should be allowed
assert_level_constraint(state, "level", 1)
assert state["_level_constrained_values"] == {"level": 1}
# Should not be allowed
with pytest.raises(ValueNotAllowedInLevel) as exc_info:
assert_level_constraint(state, "base_video_format", 0)
assert exc_info.value.level_constrained_values == {"level": 1}
assert exc_info.value.key == "base_video_format"
assert exc_info.value.value == 0
assert exc_info.value.allowed_values == ValueSet(1, 2, 3, 4, 5, 6)
def pixel_aspect_ratio(state, video_parameters):
"""(11.4.7)"""
custom_pixel_aspect_ratio_flag = read_bool(state)
# (C.3) Check level allows custom pixel aspect ratio
## Begin not in spec
assert_level_constraint(
state, "custom_pixel_aspect_ratio_flag", custom_pixel_aspect_ratio_flag
)
## End not in spec
if custom_pixel_aspect_ratio_flag:
index = read_uint(state)
# (C.3) Check level allows the specified preset
## Begin not in spec
assert_level_constraint(state, "pixel_aspect_ratio_index", index)
## End not in spec
if index == 0:
video_parameters["pixel_aspect_ratio_numer"] = read_uint(state)
# (C.3) Check level allows the specified numerator
## Begin not in spec
assert_level_constraint(
state,
"pixel_aspect_ratio_numer",
video_parameters["pixel_aspect_ratio_numer"],
)
## End not in spec
video_parameters["pixel_aspect_ratio_denom"] = read_uint(state)
# (C.3) Check level allows the specified denominator
## Begin not in spec
assert_level_constraint(
state,
"pixel_aspect_ratio_denom",
video_parameters["pixel_aspect_ratio_denom"],
)
## End not in spec
# Errata: spec fails to require ratio to be non-zero on either side
#
# (11.4.7) ratio must not contain zeros
## Begin not in spec
if (
video_parameters["pixel_aspect_ratio_numer"] == 0
or video_parameters["pixel_aspect_ratio_denom"] == 0
):
raise PixelAspectRatioContainsZeros(
video_parameters["pixel_aspect_ratio_numer"],
video_parameters["pixel_aspect_ratio_denom"],
)
## End not in spec
else:
# (11.4.7) Pixel aspect ratio preset must be a known value
## Begin not in spec
assert_in_enum(index, PresetPixelAspectRatios, BadPresetPixelAspectRatio)
## End not in spec
preset_pixel_aspect_ratio(video_parameters, index)
def frame_size(state, video_parameters):
"""(11.4.3)"""
custom_dimensions_flag = read_bool(state)
# (C.3) Check level allows this value
## Begin not in spec
assert_level_constraint(state, "custom_dimensions_flag", custom_dimensions_flag)
## End not in spec
if custom_dimensions_flag:
video_parameters["frame_width"] = read_uint(state)
# (C.3) Check level allows this value
## Begin not in spec
assert_level_constraint(state, "frame_width", video_parameters["frame_width"])
## End not in spec
video_parameters["frame_height"] = read_uint(state)
# (C.3) Check level allows this value
## Begin not in spec
assert_level_constraint(state, "frame_height", video_parameters["frame_height"])
## End not in spec
# Errata: spec doesn't prevent zero-pixel pictures
#
# (11.4.3) Frames must be at least one pixel wide and tall
## Begin not in spec
if (
video_parameters["frame_width"] == 0
or video_parameters["frame_height"] == 0
):
raise ZeroPixelFrameSize(
video_parameters["frame_width"],
video_parameters["frame_height"],
)
def extended_transform_parameters(state):
"""(12.4.4.1)"""
asym_transform_index_flag = read_bool(state)
# (C.3) Check level allows an asymmetric transform types
## Begin not in spec
assert_level_constraint(state, "asym_transform_index_flag",
asym_transform_index_flag)
## End not in spec
if asym_transform_index_flag:
state["wavelet_index_ho"] = read_uint(state)
# (12.4.4.2) Check wavelet type is supported
## Begin not in spec
assert_in_enum(state["wavelet_index_ho"], WaveletFilters,
BadHOWaveletIndex)
## End not in spec
# (C.3) Check level allows this wavelet type
## Begin not in spec
assert_level_constraint(state, "wavelet_index_ho",
state["wavelet_index_ho"])
## End not in spec
asym_transform_flag = read_bool(state)
# (C.3) Check level allows an asymmetric transform depths
## Begin not in spec
assert_level_constraint(state, "asym_transform_flag", asym_transform_flag)
## End not in spec
if asym_transform_flag:
state["dwt_depth_ho"] = read_uint(state)
# (C.3) Check level allows this wavelet depth
## Begin not in spec
assert_level_constraint(state, "dwt_depth_ho", state["dwt_depth_ho"])
## End not in spec
# (11.2.2) Log increased minimum version requirements if an asymmetric
# transform was used.
## Begin not in spec
minimum_required_version = wavelet_transform_version_implication(
state["wavelet_index"],
state["wavelet_index_ho"],
state["dwt_depth_ho"],
)
log_version_lower_bound(state, minimum_required_version)
def signal_range(state, video_parameters):
"""(11.4.9)"""
custom_signal_range_flag = read_bool(state)
# (C.3) Check level allows custom signal range
## Begin not in spec
assert_level_constraint(state, "custom_signal_range_flag", custom_signal_range_flag)
## End not in spec
if custom_signal_range_flag:
index = read_uint(state)
# (C.3) Check level allows the specified preset
## Begin not in spec
assert_level_constraint(state, "custom_signal_range_index", index)
## End not in spec
if index == 0:
video_parameters["luma_offset"] = read_uint(state)
# (C.3) Check level allows this offset
## Begin not in spec
assert_level_constraint(
state, "luma_offset", video_parameters["luma_offset"]
)
## End not in spec
video_parameters["luma_excursion"] = read_uint(state)
# (C.3) Check level allows this excursion
## Begin not in spec
assert_level_constraint(
state, "luma_excursion", video_parameters["luma_excursion"]
)
## End not in spec
# (11.4.9) Check luma_excursion is valid
#
# Errata: Spec fails to constrain excursions. Excursions *must* be
# >= 1 or the pseudocode behaviour will be undefined.
## Begin not in spec
if video_parameters["luma_excursion"] < 1:
raise BadCustomSignalExcursion(
"luma", video_parameters["luma_excursion"]
)
## End not in spec
video_parameters["color_diff_offset"] = read_uint(state)
# (C.3) Check level allows this offset
## Begin not in spec
assert_level_constraint(
state, "color_diff_offset", video_parameters["color_diff_offset"]
)
## End not in spec
video_parameters["color_diff_excursion"] = read_uint(state)
# (C.3) Check level allows this excursion
## Begin not in spec
assert_level_constraint(
state, "color_diff_excursion", video_parameters["color_diff_excursion"]
)
## End not in spec
# (11.4.9) Check color_diff_excursion is valid
#
# Errata: Spec fails to constrain excursions. Excursions *must* be
# >= 1 or the pseudocode behaviour will be undefined.
## Begin not in spec
if video_parameters["color_diff_excursion"] < 1:
raise BadCustomSignalExcursion(
"color_diff", video_parameters["color_diff_excursion"]
)
## End not in spec
else:
# (11.4.9) Signal range preset must be a known value
## Begin not in spec
assert_in_enum(index, PresetSignalRanges, BadPresetSignalRange)
## End not in spec
# (11.2.2) Signal range preset must be supported by current version
## Begin not in spec
minimum_required_version = preset_signal_range_version_implication(index)
if state["major_version"] < minimum_required_version:
raise PresetSignalRangeNotSupportedByVersion(
index, state["major_version"]
)
log_version_lower_bound(state, minimum_required_version)
## End not in spec
preset_signal_range(video_parameters, index)
def frame_rate(state, video_parameters):
"""(11.4.6)"""
custom_frame_rate_flag = read_bool(state)
# (C.3) Check level allows custom frame rates
## Begin not in spec
assert_level_constraint(state, "custom_frame_rate_flag", custom_frame_rate_flag)
## End not in spec
if custom_frame_rate_flag:
index = read_uint(state)
# (C.3) Check level allows the specified preset
assert_level_constraint(state, "frame_rate_index", index) ## Not in spec
if index == 0:
video_parameters["frame_rate_numer"] = read_uint(state)
# (C.3) Check level allows the specified numerator
## Begin not in spec
assert_level_constraint(
state,
"frame_rate_numer",
video_parameters["frame_rate_numer"],
)
## End not in spec
video_parameters["frame_rate_denom"] = read_uint(state)
# (C.3) Check level allows the specified denominator
## Begin not in spec
assert_level_constraint(
state,
"frame_rate_denom",
video_parameters["frame_rate_denom"],
)
## End not in spec
# Errata: spec doesn't prevent divide-by-zero in custom frame rate
# fractions.
#
# (11.4.6) frame_rate_denom must not be zero (i.e. a divide by zero)
## Begin not in spec
if video_parameters["frame_rate_denom"] == 0:
raise FrameRateHasZeroDenominator(video_parameters["frame_rate_numer"])
## End not in spec
# Errata: spec doesn't prevent 0 fps
#
# (11.4.6) frame_rate_numer must not be zero (i.e. 0 fps)
## Begin not in spec
if video_parameters["frame_rate_numer"] == 0:
raise FrameRateHasZeroNumerator(video_parameters["frame_rate_denom"])
## End not in spec
else:
# (11.4.6) Frame rate preset must be a known value
## Begin not in spec
assert_in_enum(index, PresetFrameRates, BadPresetFrameRateIndex)
## End not in spec
# (11.2.2) Frame rate preset must be supported by current version
## Begin not in spec
minimum_required_version = preset_frame_rate_version_implication(index)
if state["major_version"] < minimum_required_version:
raise PresetFrameRateNotSupportedByVersion(
index, state["major_version"]
)
log_version_lower_bound(state, minimum_required_version)
## End not in spec
preset_frame_rate(video_parameters, index)
def sequence_header(state):
"""(11.1)"""
# Record this sequence_header as it appears in the bitstream
## Begin not in spec
this_sequence_header_offset = tell(state)[0]
record_bitstream_start(state)
## End not in spec
parse_parameters(state)
base_video_format = read_uint(state)
# (11.4.1) Check base video format is supported
## Begin not in spec
assert_in_enum(base_video_format, BaseVideoFormats, BadBaseVideoFormat)
## End not in spec
# (C.3) Check level allows this base format
## Begin not in spec
assert_level_constraint(state, "base_video_format", base_video_format)
## End not in spec
video_parameters = source_parameters(state, base_video_format)
state["picture_coding_mode"] = read_uint(state)
# (11.5) Ensure picture coding mode is valid
## Begin not in spec
assert_in_enum(
state["picture_coding_mode"], PictureCodingModes, BadPictureCodingMode
)
## End not in spec
# (C.3) Check level allows this picture coding mode
## Begin not in spec
assert_level_constraint(state, "picture_coding_mode", state["picture_coding_mode"])
## End not in spec
set_coding_parameters(state, video_parameters)
# Errata: The spec only says the frame_height must be an integer multiple
# of the color_diff_height but, in addition, the luma_height should be a
# multiple and the color_diff_width should be a multiple of
# luma_width/frame_width
#
# (11.6.2) Check frame_height is an integer multiple of color_diff_height
## Begin not in spec
if (
# Prevent divide-by-zero in tests below
state["luma_height"] == 0
or state["luma_width"] == 0
or state["color_diff_height"] == 0
or state["color_diff_width"] == 0
or
# Actually check multiples
video_parameters["frame_height"] % state["luma_height"] != 0
or video_parameters["frame_width"] % state["luma_width"] != 0
or video_parameters["frame_height"] % state["color_diff_height"] != 0
or video_parameters["frame_width"] % state["color_diff_width"] != 0
):
raise PictureDimensionsNotMultipleOfFrameDimensions(
state["luma_width"],
state["luma_height"],
state["color_diff_width"],
state["color_diff_height"],
video_parameters["frame_width"],
video_parameters["frame_height"],
)
## End not in spec
# (11.1) Check that the this sequence_header is byte-for-byte identical
# with the previous sequence_header in the sequence
## Begin not in spec
this_sequence_header_bytes = record_bitstream_finish(state)
if "_last_sequence_header_bytes" in state:
if this_sequence_header_bytes != state["_last_sequence_header_bytes"]:
raise SequenceHeaderChangedMidSequence(
state["_last_sequence_header_offset"],
state["_last_sequence_header_bytes"],
this_sequence_header_offset,
this_sequence_header_bytes,
)
state["_last_sequence_header_bytes"] = this_sequence_header_bytes
state["_last_sequence_header_offset"] = this_sequence_header_offset
## End not in spec
return video_parameters
def quant_matrix(state):
"""(12.4.5.3)"""
custom_quant_matrix = read_bool(state)
# (C.3) Check level allows use of custom quantisation matrices
## Begin not in spec
assert_level_constraint(state, "custom_quant_matrix", custom_quant_matrix)
## End not in spec
if custom_quant_matrix:
# (C.3) Check that quantisation matrix values are in the level-defined
# range
## Begin not in spec
allowed_values = allowed_values_for(
LEVEL_CONSTRAINTS,
"quant_matrix_values",
state["_level_constrained_values"],
)
def check(quant_matrix_value):
assert_in(
quant_matrix_value,
allowed_values,
QuantisationMatrixValueNotAllowedInLevel,
state["_level_constrained_values"],
)
## End not in spec
# NB: For historical reasons, we use a dict not an array in this
# implementation.
### state["quant_matrix"] = new_array(state["dwt_depth_ho"] + state["dwt_depth"] + 1)
state["quant_matrix"] = {} ## Not in spec
if state["dwt_depth_ho"] == 0:
state["quant_matrix"][0] = {}
state["quant_matrix"][0]["LL"] = read_uint(state)
check(state["quant_matrix"][0]["LL"]) ## Not in spec
else:
state["quant_matrix"][0] = {}
state["quant_matrix"][0]["L"] = read_uint(state)
check(state["quant_matrix"][0]["L"]) ## Not in spec
for level in range(1, state["dwt_depth_ho"] + 1):
state["quant_matrix"][level] = {}
state["quant_matrix"][level]["H"] = read_uint(state)
check(state["quant_matrix"][level]["H"]) ## Not in spec
for level in range(state["dwt_depth_ho"] + 1,
state["dwt_depth_ho"] + state["dwt_depth"] + 1):
state["quant_matrix"][level] = {}
state["quant_matrix"][level]["HL"] = read_uint(state)
check(state["quant_matrix"][level]["HL"]) ## Not in spec
state["quant_matrix"][level]["LH"] = read_uint(state)
check(state["quant_matrix"][level]["LH"]) ## Not in spec
state["quant_matrix"][level]["HH"] = read_uint(state)
check(state["quant_matrix"][level]["HH"]) ## Not in spec
else:
# (12.4.5.3) If no custom quantisation matrix has been specified, a
# default table must be available
## Begin not in spec
configuration = (
state["wavelet_index"],
state["wavelet_index_ho"],
state["dwt_depth"],
state["dwt_depth_ho"],
)
if configuration not in QUANTISATION_MATRICES:
raise NoQuantisationMatrixAvailable(*configuration)
## End not in spec
set_quant_matrix(state)
def slice_parameters(state):
"""(12.4.5.2)"""
state["slices_x"] = read_uint(state)
# (C.3) Check level allows this number of horizontal slices
assert_level_constraint(state, "slices_x",
state["slices_x"]) ## Not in spec
state["slices_y"] = read_uint(state)
# (C.3) Check level allows this number of vertical slices
assert_level_constraint(state, "slices_y",
state["slices_y"]) ## Not in spec
# Errata: Spec doesn't prevent zero-slice pictures
#
# (12.4.5.2) Must have at least once slice
## Begin not in spec
if state["slices_x"] == 0 or state["slices_y"] == 0:
raise ZeroSlicesInCodedPicture(state["slices_x"], state["slices_y"])
## End not in spec
# (C.3) Check if this level expects slice counts which result in every
# slice having the same number of transform components
## Begin not in spec
assert_level_constraint(state, "slices_have_same_dimensions",
slices_have_same_dimensions(state))
## End not in spec
if is_ld(state):
state["slice_bytes_numerator"] = read_uint(state)
# (C.3) Check level allows the specified numerator
## Begin not in spec
assert_level_constraint(state, "slice_bytes_numerator",
state["slice_bytes_numerator"])
## End not in spec
state["slice_bytes_denominator"] = read_uint(state)
# (C.3) Check level allows the specified denominator
## Begin not in spec
assert_level_constraint(state, "slice_bytes_denominator",
state["slice_bytes_denominator"])
## End not in spec
# Errata: spec doesn't disallow a slice_bytes_denominator of zero
#
# (12.4.5.2) Must have non-zero slice_bytes denominator (i.e. no divide
# by zero)
## Begin not in spec
if state["slice_bytes_denominator"] == 0:
raise SliceBytesHasZeroDenominator(state["slice_bytes_numerator"])
## End not in spec
# Errata: spec doesn't disallow slice_bytes_* values which evaluate to
# less than one byte.
#
# (12.4.5.2) slice_bytes_numerator/slice_bytes_denominator must be
# greater than or equal to one byte to avoid zero-byte slices in the
# bitstream.
## Begin not in spec
if state["slice_bytes_numerator"] < state["slice_bytes_denominator"]:
raise SliceBytesIsLessThanOne(
state["slice_bytes_numerator"],
state["slice_bytes_denominator"],
)
## End not in spec
if is_hq(state):
state["slice_prefix_bytes"] = read_uint(state)
# (C.3) Check level allows the specified prefix byte count
## Begin not in spec
assert_level_constraint(state, "slice_prefix_bytes",
state["slice_prefix_bytes"])
## End not in spec
state["slice_size_scaler"] = read_uint(state)
# Errata: not enforced in spec
#
# (12.4.5.2) slice size scaler should not be zero
## Begin not in spec
if state["slice_size_scaler"] == 0:
raise SliceSizeScalerIsZero()
## End not in spec
# (C.3) Check level allows the specified slice size scaler
## Begin not in spec
assert_level_constraint(state, "slice_size_scaler",
state["slice_size_scaler"])