AK: Remove try_ prefix from FixedArray creation functions

Author: https://github.com/linusg
Commit: https://github.com/SerenityOS/serenity/commit/9c08bb9555
Pull-request: https://github.com/SerenityOS/serenity/pull/17222

AK/DisjointChunks.h

@@ -226,12 +226,10 @@ FixedArray<T> shatter_chunk(FixedArray<T>& source_chunk, size_t start, size_t sl
     if constexpr (IsTriviallyConstructible<T>) {
         TypedTransfer<T>::move(new_chunk.data(), wanted_slice.data(), wanted_slice.size());
     } else {
-        // FIXME: propagate errors
+        auto copied_chunk = FixedArray<T>::create(wanted_slice).release_value_but_fixme_should_propagate_errors();
-        auto copied_chunk = MUST(FixedArray<T>::try_create(wanted_slice));
         new_chunk.swap(copied_chunk);
     }
-    // FIXME: propagate errors
+    auto rest_of_chunk = FixedArray<T>::create(source_chunk.span().slice(start)).release_value_but_fixme_should_propagate_errors();
-    auto rest_of_chunk = MUST(FixedArray<T>::try_create(source_chunk.span().slice(start)));
     source_chunk.swap(rest_of_chunk);
     return new_chunk;
 }

AK/FixedArray.h

@@ -22,9 +22,9 @@ class FixedArray {
 public:
     FixedArray() = default;
 
-    static ErrorOr<FixedArray<T>> try_create(std::initializer_list<T> initializer)
+    static ErrorOr<FixedArray<T>> create(std::initializer_list<T> initializer)
     {
-        auto array = TRY(try_create(initializer.size()));
+        auto array = TRY(create(initializer.size()));
         auto it = initializer.begin();
         for (size_t i = 0; i < array.size(); ++i) {
             array[i] = move(*it);
@@ -33,7 +33,7 @@ public:
         return array;
     }
 
-    static ErrorOr<FixedArray<T>> try_create(size_t size)
+    static ErrorOr<FixedArray<T>> create(size_t size)
     {
         if (size == 0)
             return FixedArray<T>();
@@ -48,17 +48,17 @@ public:
 
     static FixedArray<T> must_create_but_fixme_should_propagate_errors(size_t size)
     {
-        return MUST(try_create(size));
+        return MUST(create(size));
     }
 
     template<size_t N>
-    static ErrorOr<FixedArray<T>> try_create(T (&&array)[N])
+    static ErrorOr<FixedArray<T>> create(T (&&array)[N])
     {
-        return try_create(Span(array, N));
+        return create(Span(array, N));
     }
 
     template<typename U>
-    static ErrorOr<FixedArray<T>> try_create(Span<U> span)
+    static ErrorOr<FixedArray<T>> create(Span<U> span)
     {
         if (span.size() == 0)
             return FixedArray<T>();
@@ -71,9 +71,9 @@ public:
         return FixedArray<T>(new_storage);
     }
 
-    ErrorOr<FixedArray<T>> try_clone() const
+    ErrorOr<FixedArray<T>> clone() const
     {
-        return try_create(span());
+        return create(span());
     }
 
     static size_t storage_allocation_size(size_t size)

Kernel/Bus/USB/USBConfiguration.cpp

@@ -15,7 +15,7 @@ namespace Kernel::USB {
 
 ErrorOr<void> USBConfiguration::enumerate_interfaces()
 {
-    auto descriptor_hierarchy_buffer = TRY(FixedArray<u8>::try_create(m_descriptor.total_length)); // Buffer for us to store the entire hierarchy into
+    auto descriptor_hierarchy_buffer = TRY(FixedArray<u8>::create(m_descriptor.total_length)); // Buffer for us to store the entire hierarchy into
 
     // The USB spec is a little bit janky here... Interface and Endpoint descriptors aren't fetched
     // through a `GET_DESCRIPTOR` request to the device. Instead, the _entire_ hierarchy is returned

Kernel/Credentials.cpp

@@ -12,7 +12,7 @@ namespace Kernel {
 
 ErrorOr<NonnullRefPtr<Credentials>> Credentials::create(UserID uid, GroupID gid, UserID euid, GroupID egid, UserID suid, GroupID sgid, Span<GroupID const> extra_gids, SessionID sid, ProcessGroupID pgid)
 {
-    auto extra_gids_array = TRY(FixedArray<GroupID>::try_create(extra_gids));
+    auto extra_gids_array = TRY(FixedArray<GroupID>::create(extra_gids));
     return adopt_nonnull_ref_or_enomem(new (nothrow) Credentials(uid, gid, euid, egid, suid, sgid, move(extra_gids_array), sid, pgid));
 }
 

Kernel/Memory/AnonymousVMObject.cpp

@@ -92,7 +92,7 @@ ErrorOr<NonnullLockRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_phys
 {
     auto contiguous_physical_pages = TRY(MM.allocate_contiguous_physical_pages(size));
 
-    auto new_physical_pages = TRY(FixedArray<RefPtr<PhysicalPage>>::try_create(contiguous_physical_pages.span()));
+    auto new_physical_pages = TRY(FixedArray<RefPtr<PhysicalPage>>::create(contiguous_physical_pages.span()));
 
     return adopt_nonnull_lock_ref_or_enomem(new (nothrow) AnonymousVMObject(move(new_physical_pages)));
 }
@@ -113,7 +113,7 @@ ErrorOr<NonnullLockRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_purg
 
 ErrorOr<NonnullLockRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_physical_pages(Span<NonnullRefPtr<PhysicalPage>> physical_pages)
 {
-    auto new_physical_pages = TRY(FixedArray<RefPtr<PhysicalPage>>::try_create(physical_pages));
+    auto new_physical_pages = TRY(FixedArray<RefPtr<PhysicalPage>>::create(physical_pages));
     return adopt_nonnull_lock_ref_or_enomem(new (nothrow) AnonymousVMObject(move(new_physical_pages)));
 }
 

Kernel/Memory/VMObject.cpp

@@ -19,12 +19,12 @@ SpinlockProtected<VMObject::AllInstancesList, LockRank::None>& VMObject::all_ins
 
 ErrorOr<FixedArray<RefPtr<PhysicalPage>>> VMObject::try_clone_physical_pages() const
 {
-    return m_physical_pages.try_clone();
+    return m_physical_pages.clone();
 }
 
 ErrorOr<FixedArray<RefPtr<PhysicalPage>>> VMObject::try_create_physical_pages(size_t size)
 {
-    return FixedArray<RefPtr<PhysicalPage>>::try_create(ceil_div(size, static_cast<size_t>(PAGE_SIZE)));
+    return FixedArray<RefPtr<PhysicalPage>>::create(ceil_div(size, static_cast<size_t>(PAGE_SIZE)));
 }
 
 VMObject::VMObject(FixedArray<RefPtr<PhysicalPage>>&& new_physical_pages)

Tests/AK/TestDisjointChunks.cpp

@@ -61,15 +61,15 @@ TEST_CASE(fixed_array)
     EXPECT(chunks.is_empty());
     chunks.append({});
     EXPECT(chunks.is_empty());
-    chunks.append(MUST(FixedArray<size_t>::try_create({ 0, 1 })));
+    chunks.append(MUST(FixedArray<size_t>::create({ 0, 1 })));
     EXPECT(!chunks.is_empty());
     chunks.append({});
-    chunks.append(MUST(FixedArray<size_t>::try_create(3)));
+    chunks.append(MUST(FixedArray<size_t>::create(3)));
     chunks.last_chunk()[0] = 2;
     chunks.last_chunk()[1] = 3;
     chunks.last_chunk()[2] = 4;
     chunks.append({});
-    chunks.append(MUST(FixedArray<size_t>::try_create(1)));
+    chunks.append(MUST(FixedArray<size_t>::create(1)));
     chunks.last_chunk()[0] = 5;
 
     for (size_t i = 0; i < 6u; ++i)

Userland/Applications/3DFileViewer/WavefrontOBJLoader.cpp

@@ -78,9 +78,9 @@ ErrorOr<NonnullRefPtr<Mesh>> WavefrontOBJLoader::load(Core::File& file)
                 return Error::from_string_literal("Wavefront: Malformed face line.");
             }
 
-            auto vertex_indices = TRY(FixedArray<GLuint>::try_create(number_of_vertices));
+            auto vertex_indices = TRY(FixedArray<GLuint>::create(number_of_vertices));
-            auto tex_coord_indices = TRY(FixedArray<GLuint>::try_create(number_of_vertices));
+            auto tex_coord_indices = TRY(FixedArray<GLuint>::create(number_of_vertices));
-            auto normal_indices = TRY(FixedArray<GLuint>::try_create(number_of_vertices));
+            auto normal_indices = TRY(FixedArray<GLuint>::create(number_of_vertices));
 
             for (size_t i = 0; i < number_of_vertices; ++i) {
                 auto vertex_parts = face_line.at(i).split_view('/', SplitBehavior::KeepEmpty);

Userland/Applications/SoundPlayer/PlaybackManager.cpp

@@ -124,7 +124,7 @@ void PlaybackManager::next_buffer()
 
         m_resampler->reset();
         // FIXME: Handle OOM better.
-        auto resampled = MUST(FixedArray<Audio::Sample>::try_create(m_resampler->resample(move(m_current_buffer)).span()));
+        auto resampled = MUST(FixedArray<Audio::Sample>::create(m_resampler->resample(move(m_current_buffer)).span()));
         m_current_buffer.swap(resampled);
         MUST(m_connection->async_enqueue(m_current_buffer));
     }

Userland/Applications/SoundPlayer/VisualizationWidget.h

@@ -70,7 +70,7 @@ public:
 
     ErrorOr<void> set_render_sample_count(size_t count)
     {
-        auto new_buffer = TRY(FixedArray<float>::try_create(count));
+        auto new_buffer = TRY(FixedArray<float>::create(count));
         m_render_buffer.swap(new_buffer);
         return {};
     }

Userland/Applications/Terminal/main.cpp

@@ -159,7 +159,7 @@ static ErrorOr<void> run_command(DeprecatedString command, bool keep_open)
         arguments.append("-c"sv);
         arguments.append(command);
     }
-    auto env = TRY(FixedArray<StringView>::try_create({ "TERM=xterm"sv, "PAGER=more"sv, "PATH="sv DEFAULT_PATH_SV }));
+    auto env = TRY(FixedArray<StringView>::create({ "TERM=xterm"sv, "PAGER=more"sv, "PATH="sv DEFAULT_PATH_SV }));
     TRY(Core::System::exec(shell, arguments, Core::System::SearchInPath::No, env.span()));
     VERIFY_NOT_REACHED();
 }

Userland/Demos/Tubes/Tubes.cpp

@@ -75,7 +75,7 @@ static IntVector3 vector_for_direction(Direction direction)
 }
 
 Tubes::Tubes(int interval)
-    : m_grid(MUST(FixedArray<u8>::try_create(grid_resolution * grid_resolution * grid_resolution)))
+    : m_grid(MUST(FixedArray<u8>::create(grid_resolution * grid_resolution * grid_resolution)))
 {
     on_screensaver_exit = []() { GUI::Application::the()->quit(); };
     start_timer(interval);

Userland/Libraries/LibAudio/ConnectionToServer.h

@@ -36,7 +36,7 @@ public:
     template<ArrayLike<Sample> Samples>
     ErrorOr<void> async_enqueue(Samples&& samples)
     {
-        return async_enqueue(TRY(FixedArray<Sample>::try_create(samples.span())));
+        return async_enqueue(TRY(FixedArray<Sample>::create(samples.span())));
     }
 
     ErrorOr<void> async_enqueue(FixedArray<Sample>&& samples);

Userland/Libraries/LibAudio/MP3Loader.cpp

@@ -91,7 +91,7 @@ MaybeLoaderError MP3LoaderPlugin::seek(int const position)
 
 LoaderSamples MP3LoaderPlugin::get_more_samples(size_t max_samples_to_read_from_input)
 {
-    FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::try_create(max_samples_to_read_from_input));
+    FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::create(max_samples_to_read_from_input));
 
     size_t samples_to_read = max_samples_to_read_from_input;
     while (samples_to_read > 0) {

Userland/Libraries/LibAudio/WavLoader.cpp

@@ -114,7 +114,7 @@ static ErrorOr<double> read_sample(Core::Stream::Stream& stream)
 
 LoaderSamples WavLoaderPlugin::samples_from_pcm_data(Bytes const& data, size_t samples_to_read) const
 {
-    FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::try_create(samples_to_read));
+    FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::create(samples_to_read));
     auto stream = LOADER_TRY(Core::Stream::FixedMemoryStream::construct(move(data)));
 
     switch (m_sample_format) {

Userland/Libraries/LibCompress/Brotli.h

@@ -67,7 +67,7 @@ public:
     public:
         static ErrorOr<LookbackBuffer> try_create(size_t size)
         {
-            auto buffer = TRY(FixedArray<u8>::try_create(size));
+            auto buffer = TRY(FixedArray<u8>::create(size));
             return LookbackBuffer { buffer };
         }
 

Userland/Libraries/LibCore/MemoryStream.cpp

@@ -212,7 +212,7 @@ ErrorOr<Optional<size_t>> AllocatingMemoryStream::offset_of(ReadonlyBytes needle
     VERIFY(m_chunks.size() * chunk_size - m_write_offset < chunk_size);
 
     auto chunk_count = m_chunks.size();
-    auto search_spans = TRY(FixedArray<ReadonlyBytes>::try_create(chunk_count));
+    auto search_spans = TRY(FixedArray<ReadonlyBytes>::create(chunk_count));
 
     for (size_t i = 0; i < chunk_count; i++) {
         search_spans[i] = m_chunks[i].span();

Userland/Libraries/LibCore/System.cpp

@@ -1118,7 +1118,7 @@ ErrorOr<void> exec(StringView filename, Span<StringView> arguments, SearchInPath
 #ifdef AK_OS_SERENITY
     Syscall::SC_execve_params params;
 
-    auto argument_strings = TRY(FixedArray<Syscall::StringArgument>::try_create(arguments.size()));
+    auto argument_strings = TRY(FixedArray<Syscall::StringArgument>::create(arguments.size()));
     for (size_t i = 0; i < arguments.size(); ++i) {
         argument_strings[i] = { arguments[i].characters_without_null_termination(), arguments[i].length() };
     }
@@ -1133,7 +1133,7 @@ ErrorOr<void> exec(StringView filename, Span<StringView> arguments, SearchInPath
             ++env_count;
     }
 
-    auto environment_strings = TRY(FixedArray<Syscall::StringArgument>::try_create(env_count));
+    auto environment_strings = TRY(FixedArray<Syscall::StringArgument>::create(env_count));
     if (environment.has_value()) {
         for (size_t i = 0; i < env_count; ++i) {
             environment_strings[i] = { environment->at(i).characters_without_null_termination(), environment->at(i).length() };
@@ -1172,8 +1172,8 @@ ErrorOr<void> exec(StringView filename, Span<StringView> arguments, SearchInPath
 #else
     DeprecatedString filename_string { filename };
 
-    auto argument_strings = TRY(FixedArray<DeprecatedString>::try_create(arguments.size()));
+    auto argument_strings = TRY(FixedArray<DeprecatedString>::create(arguments.size()));
-    auto argv = TRY(FixedArray<char*>::try_create(arguments.size() + 1));
+    auto argv = TRY(FixedArray<char*>::create(arguments.size() + 1));
     for (size_t i = 0; i < arguments.size(); ++i) {
         argument_strings[i] = arguments[i].to_deprecated_string();
         argv[i] = const_cast<char*>(argument_strings[i].characters());
@@ -1182,8 +1182,8 @@ ErrorOr<void> exec(StringView filename, Span<StringView> arguments, SearchInPath
 
     int rc = 0;
     if (environment.has_value()) {
-        auto environment_strings = TRY(FixedArray<DeprecatedString>::try_create(environment->size()));
+        auto environment_strings = TRY(FixedArray<DeprecatedString>::create(environment->size()));
-        auto envp = TRY(FixedArray<char*>::try_create(environment->size() + 1));
+        auto envp = TRY(FixedArray<char*>::create(environment->size() + 1));
         for (size_t i = 0; i < environment->size(); ++i) {
             environment_strings[i] = environment->at(i).to_deprecated_string();
             envp[i] = const_cast<char*>(environment_strings[i].characters());

Userland/Libraries/LibDSP/Track.cpp

@@ -63,7 +63,7 @@ bool NoteTrack::check_processor_chain_valid() const
 
 ErrorOr<void> Track::resize_internal_buffers_to(size_t buffer_size)
 {
-    m_secondary_sample_buffer = TRY(FixedArray<Sample>::try_create(buffer_size));
+    m_secondary_sample_buffer = TRY(FixedArray<Sample>::create(buffer_size));
     return {};
 }
 

Userland/Libraries/LibGfx/Font/OpenType/Font.cpp

@@ -180,7 +180,7 @@ ErrorOr<Kern> Kern::from_slice(ReadonlyBytes slice)
         return Error::from_string_literal("Kern table does not contain any subtables");
 
     // Read all subtable offsets
-    auto subtable_offsets = TRY(FixedArray<size_t>::try_create(number_of_subtables));
+    auto subtable_offsets = TRY(FixedArray<size_t>::create(number_of_subtables));
     size_t offset = sizeof(Header);
     for (size_t i = 0; i < number_of_subtables; ++i) {
         if (slice.size() < offset + sizeof(SubtableHeader))

Userland/Libraries/LibGfx/PNGWriter.cpp

@@ -175,7 +175,7 @@ ErrorOr<void> PNGWriter::add_IDAT_chunk(Gfx::Bitmap const& bitmap)
     ByteBuffer uncompressed_block_data;
     TRY(uncompressed_block_data.try_ensure_capacity(bitmap.size_in_bytes() + bitmap.height()));
 
-    auto dummy_scanline = TRY(FixedArray<Pixel>::try_create(bitmap.width()));
+    auto dummy_scanline = TRY(FixedArray<Pixel>::create(bitmap.width()));
     auto const* scanline_minus_1 = dummy_scanline.data();
 
     for (int y = 0; y < bitmap.height(); ++y) {

Userland/Libraries/LibSoftGPU/Buffer/Typed3DBuffer.h

@@ -25,7 +25,7 @@ public:
     static ErrorOr<NonnullRefPtr<Typed3DBuffer<T>>> try_create(int width, int height, int depth)
     {
         VERIFY(width > 0 && height > 0 && depth > 0);
-        auto data = TRY(FixedArray<T>::try_create(width * height * depth));
+        auto data = TRY(FixedArray<T>::create(width * height * depth));
         return adopt_ref(*new Typed3DBuffer(width, height, depth, move(data)));
     }
 

Userland/Libraries/LibVideo/VP9/Context.h

@@ -143,9 +143,9 @@ private:
 static ErrorOr<NonZeroTokens> create_non_zero_tokens(u32 size_in_sub_blocks, bool subsampling)
 {
     return NonZeroTokens {
-        TRY(FixedArray<bool>::try_create(size_in_sub_blocks)),
+        TRY(FixedArray<bool>::create(size_in_sub_blocks)),
-        TRY(FixedArray<bool>::try_create(size_in_sub_blocks >>= subsampling)),
+        TRY(FixedArray<bool>::create(size_in_sub_blocks >>= subsampling)),
-        TRY(FixedArray<bool>::try_create(size_in_sub_blocks)),
+        TRY(FixedArray<bool>::create(size_in_sub_blocks)),
     };
 }
 
@@ -191,9 +191,9 @@ public:
             above_partition_context,
             above_non_zero_tokens,
             above_segmentation_ids,
-            TRY(PartitionContext::try_create(superblocks_to_blocks(blocks_ceiled_to_superblocks(height)))),
+            TRY(PartitionContext::create(superblocks_to_blocks(blocks_ceiled_to_superblocks(height)))),
             TRY(create_non_zero_tokens(blocks_to_sub_blocks(height), frame_context.color_config.subsampling_y)),
-            TRY(SegmentationPredictionContext::try_create(height)),
+            TRY(SegmentationPredictionContext::create(height)),
         };
     }
 

Userland/Libraries/LibVideo/VP9/Decoder.cpp

@@ -153,9 +153,9 @@ DecoderErrorOr<void> Decoder::create_video_frame(FrameContext const& frame_conte
         output_y_size.height() >> frame_context.color_config.subsampling_y,
     };
     Array<FixedArray<u16>, 3> output_buffers = {
-        DECODER_TRY_ALLOC(FixedArray<u16>::try_create(output_y_size.width() * output_y_size.height())),
+        DECODER_TRY_ALLOC(FixedArray<u16>::create(output_y_size.width() * output_y_size.height())),
-        DECODER_TRY_ALLOC(FixedArray<u16>::try_create(output_uv_size.width() * output_uv_size.height())),
+        DECODER_TRY_ALLOC(FixedArray<u16>::create(output_uv_size.width() * output_uv_size.height())),
-        DECODER_TRY_ALLOC(FixedArray<u16>::try_create(output_uv_size.width() * output_uv_size.height())),
+        DECODER_TRY_ALLOC(FixedArray<u16>::create(output_uv_size.width() * output_uv_size.height())),
     };
     for (u8 plane = 0; plane < 3; plane++) {
         auto& buffer = output_buffers[plane];

Userland/Libraries/LibVideo/VP9/Parser.cpp

@@ -858,9 +858,9 @@ DecoderErrorOr<void> Parser::decode_tiles(FrameContext& frame_context)
     auto tile_cols = 1 << log2_dimensions.width();
     auto tile_rows = 1 << log2_dimensions.height();
 
-    PartitionContext above_partition_context = DECODER_TRY_ALLOC(PartitionContext::try_create(superblocks_to_blocks(frame_context.superblock_columns())));
+    PartitionContext above_partition_context = DECODER_TRY_ALLOC(PartitionContext::create(superblocks_to_blocks(frame_context.superblock_columns())));
     NonZeroTokens above_non_zero_tokens = DECODER_TRY_ALLOC(create_non_zero_tokens(blocks_to_sub_blocks(frame_context.columns()), frame_context.color_config.subsampling_x));
-    SegmentationPredictionContext above_segmentation_ids = DECODER_TRY_ALLOC(SegmentationPredictionContext::try_create(frame_context.columns()));
+    SegmentationPredictionContext above_segmentation_ids = DECODER_TRY_ALLOC(SegmentationPredictionContext::create(frame_context.columns()));
 
     // FIXME: To implement tiled decoding, we'll need to pre-parse the tile positions and sizes into a 2D vector of ReadonlyBytes,
     //        then run through each column of tiles in top to bottom order afterward. Each column can be sent to a worker thread

Userland/Libraries/LibVideo/VideoFrame.cpp

@@ -18,9 +18,9 @@ ErrorOr<NonnullOwnPtr<SubsampledYUVFrame>> SubsampledYUVFrame::try_create(
     bool subsampling_horizontal, bool subsampling_vertical,
     Span<u16> plane_y, Span<u16> plane_u, Span<u16> plane_v)
 {
-    auto plane_y_array = TRY(FixedArray<u16>::try_create(plane_y));
+    auto plane_y_array = TRY(FixedArray<u16>::create(plane_y));
-    auto plane_u_array = TRY(FixedArray<u16>::try_create(plane_u));
+    auto plane_u_array = TRY(FixedArray<u16>::create(plane_u));
-    auto plane_v_array = TRY(FixedArray<u16>::try_create(plane_v));
+    auto plane_v_array = TRY(FixedArray<u16>::create(plane_v));
     return adopt_nonnull_own_or_enomem(new (nothrow) SubsampledYUVFrame(size, bit_depth, cicp, subsampling_horizontal, subsampling_vertical, plane_y_array, plane_u_array, plane_v_array));
 }
 
@@ -28,8 +28,8 @@ DecoderErrorOr<void> SubsampledYUVFrame::output_to_bitmap(Gfx::Bitmap& bitmap)
 {
     size_t width = this->width();
     size_t height = this->height();
-    auto u_sample_row = DECODER_TRY_ALLOC(FixedArray<u16>::try_create(width));
+    auto u_sample_row = DECODER_TRY_ALLOC(FixedArray<u16>::create(width));
-    auto v_sample_row = DECODER_TRY_ALLOC(FixedArray<u16>::try_create(width));
+    auto v_sample_row = DECODER_TRY_ALLOC(FixedArray<u16>::create(width));
     size_t uv_width = width >> m_subsampling_horizontal;
 
     auto converter = TRY(ColorConverter::create(bit_depth(), cicp()));