Function SliceKernelImplChannelLast

dali/kernels/slice/slice_cpu.h:44–145

 */
template <typename OutputType, typename InputType, bool AllFill, boundary::BoundaryType BorderType>
void SliceKernelImplChannelLast(OutputType *output,
                                const InputType *input,
                                const int64_t *out_strides,
                                const int64_t *in_strides,
                                const int64_t *out_shape,
                                const int64_t *in_shape,
                                const int64_t *anchor,
                                const int64_t *step,
                                const OutputType *fill_values,
                                int channel_dim,  // negative if no channel dim or already processed
                                std::integral_constant<boundary::BoundaryType, BorderType>,
                                std::integral_constant<bool, AllFill>) {
  static_assert(!AllFill || BorderType == boundary::BoundaryType::CONSTANT);
  constexpr int d = 0;
  assert(channel_dim == 1);
  int64_t out_nchannels = out_shape[channel_dim];
  int64_t in_nchannels = in_shape[channel_dim];
  int64_t npixels = out_shape[d];

  if constexpr (AllFill) {
    PadFill(output, fill_values, npixels, out_nchannels);
    return;
  }

  if constexpr (BorderType == boundary::BoundaryType::CONSTANT) {
    // If the whole row is out of bounds, just fill
    // Calculate number of pixels to pad on the left and right, and the number of pixels to be
    // copied
    int64_t pad_pixels_before, copy_pixels, pad_pixels_after;
    std::tie(pad_pixels_before, copy_pixels, pad_pixels_after) =
        CalcPadCopyExtents(anchor[d], in_shape[d], out_shape[d]);

    // Padding pixels on the left, if needed
    if (pad_pixels_before > 0) {
      PadFill(output, fill_values, pad_pixels_before, out_nchannels);
      output += pad_pixels_before * out_strides[d];
    }

    // If the anchor is positive, advance the input pointer
    if (anchor[d] > 0)
      input += anchor[d] * in_strides[d];

    bool channel_dim_unchanged = in_nchannels == out_nchannels && anchor[channel_dim] == 0;
    if (channel_dim_unchanged) {
      auto n = copy_pixels * out_nchannels;
      for (int64_t i = 0; i < n; i++)
        output[i] = input[i];
      output += n;
    } else {
      // Calculate number of channels to pad on the left, right and the number of channels to be
      // copied
      int64_t pad_channels_before, copy_channels, pad_channels_after;
      std::tie(pad_channels_before, copy_channels, pad_channels_after) =
          CalcPadCopyExtents(anchor[channel_dim], in_nchannels, out_nchannels);
      int64_t anchor_channel_in = std::max<int64_t>(0, anchor[channel_dim]);
      // Copy pixels with potential padding on the channel dimension
      for (int64_t i = 0; i < copy_pixels; i++) {
        int64_t out_c = 0;