util.cc

浏览该文件的文档.

/******************************************************************************
 * Copyright 2018 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/
 
#include "modules/drivers/camera/util.h"
 
#include <cstdarg>
#include <cstdint>
 
namespace apollo {
namespace drivers {
namespace camera {
 
void print_m256(__m256i a) {
  unsigned char snoop[32];
  bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
  if (dst_align)
    Store<true>(reinterpret_cast<__m256i*>(snoop), a);
  else
    Store<false>(reinterpret_cast<__m256i*>(snoop), a);
  for (int i = 0; i < 32; ++i) {
    printf("DEBUG8 %d %u \n", i, snoop[i]);
  }
}
void print_m256_i32(const __m256i a) {
  unsigned int snoop[8];
  bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
  if (dst_align)
    Store<true>(reinterpret_cast<__m256i*>(snoop), a);
  else
    Store<false>(reinterpret_cast<__m256i*>(snoop), a);
  for (int i = 0; i < 8; ++i) {
    printf("DEBUG32 %d %u \n", i, snoop[i]);
  }
}
 
void print_m256_i16(const __m256i a) {
  uint16_t snoop[16];
  bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
  if (dst_align)
    Store<true>(reinterpret_cast<__m256i*>(snoop), a);
  else
    Store<false>(reinterpret_cast<__m256i*>(snoop), a);
  for (int i = 0; i < 16; ++i) {
    printf("DEBUG16 %d %u \n", i, snoop[i]);
  }
}
 
template <bool align>
SIMD_INLINE void yuv_separate_avx2(uint8_t* y, __m256i* y0, __m256i* y1,
                                   __m256i* u0, __m256i* v0) {
  __m256i yuv_m256[4];
 
  if (align) {
    yuv_m256[0] = Load<true>(reinterpret_cast<__m256i*>(y));
    yuv_m256[1] = Load<true>(reinterpret_cast<__m256i*>(y) + 1);
    yuv_m256[2] = Load<true>(reinterpret_cast<__m256i*>(y) + 2);
    yuv_m256[3] = Load<true>(reinterpret_cast<__m256i*>(y) + 3);
  } else {
    yuv_m256[0] = Load<false>(reinterpret_cast<__m256i*>(y));
    yuv_m256[1] = Load<false>(reinterpret_cast<__m256i*>(y) + 1);
    yuv_m256[2] = Load<false>(reinterpret_cast<__m256i*>(y) + 2);
    yuv_m256[3] = Load<false>(reinterpret_cast<__m256i*>(y) + 3);
  }
 
  *y0 =
      _mm256_or_si256(_mm256_permute4x64_epi64(
                          _mm256_shuffle_epi8(yuv_m256[0], Y_SHUFFLE0), 0xD8),
                      _mm256_permute4x64_epi64(
                          _mm256_shuffle_epi8(yuv_m256[1], Y_SHUFFLE1), 0xD8));
  *y1 =
      _mm256_or_si256(_mm256_permute4x64_epi64(
                          _mm256_shuffle_epi8(yuv_m256[2], Y_SHUFFLE0), 0xD8),
                      _mm256_permute4x64_epi64(
                          _mm256_shuffle_epi8(yuv_m256[3], Y_SHUFFLE1), 0xD8));
 
  *u0 = _mm256_permutevar8x32_epi32(
      _mm256_or_si256(
          _mm256_or_si256(_mm256_shuffle_epi8(yuv_m256[0], U_SHUFFLE0),
                          _mm256_shuffle_epi8(yuv_m256[1], U_SHUFFLE1)),
          _mm256_or_si256(_mm256_shuffle_epi8(yuv_m256[2], U_SHUFFLE2),
                          _mm256_shuffle_epi8(yuv_m256[3], U_SHUFFLE3))),
      U_SHUFFLE4);
  *v0 = _mm256_permutevar8x32_epi32(
      _mm256_or_si256(
          _mm256_or_si256(_mm256_shuffle_epi8(yuv_m256[0], V_SHUFFLE0),
                          _mm256_shuffle_epi8(yuv_m256[1], V_SHUFFLE1)),
          _mm256_or_si256(_mm256_shuffle_epi8(yuv_m256[2], V_SHUFFLE2),
                          _mm256_shuffle_epi8(yuv_m256[3], V_SHUFFLE3))),
      U_SHUFFLE4);
}
 
template <bool align>
void yuv2rgb_avx2(__m256i y0, __m256i u0, __m256i v0, uint8_t* rgb) {
  __m256i r0 = YuvToRed(y0, v0);
  __m256i g0 = YuvToGreen(y0, u0, v0);
  __m256i b0 = YuvToBlue(y0, u0);
 
  Store<align>(reinterpret_cast<__m256i*>(rgb) + 0,
               InterleaveBgr<0>(r0, g0, b0));
  Store<align>(reinterpret_cast<__m256i*>(rgb) + 1,
               InterleaveBgr<1>(r0, g0, b0));
  Store<align>(reinterpret_cast<__m256i*>(rgb) + 2,
               InterleaveBgr<2>(r0, g0, b0));
}
 
template <bool align>
void yuv2rgb_avx2(uint8_t* yuv, uint8_t* rgb) {
  __m256i y0, y1, u0, v0;
 
  yuv_separate_avx2<align>(yuv, &y0, &y1, &u0, &v0);
  __m256i u0_u0 = _mm256_permute4x64_epi64(u0, 0xD8);
  __m256i v0_v0 = _mm256_permute4x64_epi64(v0, 0xD8);
  yuv2rgb_avx2<align>(y0, _mm256_unpacklo_epi8(u0_u0, u0_u0),
                      _mm256_unpacklo_epi8(v0_v0, v0_v0), rgb);
  yuv2rgb_avx2<align>(y1, _mm256_unpackhi_epi8(u0_u0, u0_u0),
                      _mm256_unpackhi_epi8(v0_v0, v0_v0),
                      rgb + 3 * sizeof(__m256i));
}
 
void yuyv2rgb_avx(unsigned char* YUV, unsigned char* RGB, int NumPixels) {
  assert(NumPixels == (1920 * 1080));
  bool align = Aligned(YUV) & Aligned(RGB);
  uint8_t* yuv_offset = YUV;
  uint8_t* rgb_offset = RGB;
  if (align) {
    for (int i = 0; i < NumPixels;
         i = i + static_cast<int>(2 * sizeof(__m256i)),
             yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
             rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
      yuv2rgb_avx2<true>(yuv_offset, rgb_offset);
    }
  } else {
    for (int i = 0; i < NumPixels;
         i = i + static_cast<int>(2 * sizeof(__m256i)),
             yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
             rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
      yuv2rgb_avx2<false>(yuv_offset, rgb_offset);
    }
  }
}
 
}  // namespace camera
}  // namespace drivers
}  // namespace apollo