/* * Copyright 2011 The LibYuv Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "libyuv/row.h" #include <assert.h> #include <string.h> // For memcpy and memset. #include "libyuv/basic_types.h" #include "libyuv/convert_argb.h" // For kYuvI601Constants #ifdef __cplusplus namespace libyuv { extern "C" { #endif #ifdef __cplusplus #define STATIC_CAST … #else #define STATIC_CAST … #endif // This macro controls YUV to RGB using unsigned math to extend range of // YUV to RGB coefficients to 0 to 4 instead of 0 to 2 for more accuracy on B: // LIBYUV_UNLIMITED_DATA // Macros to enable unlimited data for each colorspace // LIBYUV_UNLIMITED_BT601 // LIBYUV_UNLIMITED_BT709 // LIBYUV_UNLIMITED_BT2020 // The following macro from row_win makes the C code match the row_win code, // which is 7 bit fixed point for ARGBToI420: #if !defined(LIBYUV_BIT_EXACT) && !defined(LIBYUV_DISABLE_X86) && \ defined(_MSC_VER) && !defined(__clang__) && \ (defined(_M_IX86) || defined(_M_X64)) #define LIBYUV_RGB7 … #endif #if !defined(LIBYUV_BIT_EXACT) && (defined(__x86_64__) || defined(_M_X64) || \ defined(__i386__) || defined(_M_IX86)) #define LIBYUV_ARGBTOUV_PAVGB … #define LIBYUV_RGBTOU_TRUNCATE … #endif #if defined(LIBYUV_BIT_EXACT) #define LIBYUV_UNATTENUATE_DUP … #endif // llvm x86 is poor at ternary operator, so use branchless min/max. #define USE_BRANCHLESS … #if defined(USE_BRANCHLESS) static __inline int32_t clamp0(int32_t v) { … } // TODO(fbarchard): make clamp255 preserve negative values. static __inline int32_t clamp255(int32_t v) { … } static __inline int32_t clamp1023(int32_t v) { … } // clamp to max static __inline int32_t ClampMax(int32_t v, int32_t max) { … } static __inline uint32_t Abs(int32_t v) { … } #else // USE_BRANCHLESS static __inline int32_t clamp0(int32_t v) { return (v < 0) ? 0 : v; } static __inline int32_t clamp255(int32_t v) { return (v > 255) ? 255 : v; } static __inline int32_t clamp1023(int32_t v) { return (v > 1023) ? 1023 : v; } static __inline int32_t ClampMax(int32_t v, int32_t max) { return (v > max) ? max : v; } static __inline uint32_t Abs(int32_t v) { return (v < 0) ? -v : v; } #endif // USE_BRANCHLESS static __inline uint32_t Clamp(int32_t val) { … } static __inline uint32_t Clamp10(int32_t val) { … } // Little Endian #if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \ defined(_M_IX86) || defined(__arm__) || defined(_M_ARM) || \ (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) #define WRITEWORD(p, v) … #else static inline void WRITEWORD(uint8_t* p, uint32_t v) { p[0] = (uint8_t)(v & 255); p[1] = (uint8_t)((v >> 8) & 255); p[2] = (uint8_t)((v >> 16) & 255); p[3] = (uint8_t)((v >> 24) & 255); } #endif void RGB24ToARGBRow_C(const uint8_t* src_rgb24, uint8_t* dst_argb, int width) { … } void RAWToARGBRow_C(const uint8_t* src_raw, uint8_t* dst_argb, int width) { … } void RAWToRGBARow_C(const uint8_t* src_raw, uint8_t* dst_rgba, int width) { … } void RAWToRGB24Row_C(const uint8_t* src_raw, uint8_t* dst_rgb24, int width) { … } void RGB565ToARGBRow_C(const uint8_t* src_rgb565, uint8_t* dst_argb, int width) { … } void ARGB1555ToARGBRow_C(const uint8_t* src_argb1555, uint8_t* dst_argb, int width) { … } void ARGB4444ToARGBRow_C(const uint8_t* src_argb4444, uint8_t* dst_argb, int width) { … } void AR30ToARGBRow_C(const uint8_t* src_ar30, uint8_t* dst_argb, int width) { … } void AR30ToABGRRow_C(const uint8_t* src_ar30, uint8_t* dst_abgr, int width) { … } void AR30ToAB30Row_C(const uint8_t* src_ar30, uint8_t* dst_ab30, int width) { … } void ARGBToABGRRow_C(const uint8_t* src_argb, uint8_t* dst_abgr, int width) { … } void ARGBToBGRARow_C(const uint8_t* src_argb, uint8_t* dst_bgra, int width) { … } void ARGBToRGBARow_C(const uint8_t* src_argb, uint8_t* dst_rgba, int width) { … } void ARGBToRGB24Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) { … } void ARGBToRAWRow_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) { … } void RGBAToARGBRow_C(const uint8_t* src_rgba, uint8_t* dst_argb, int width) { … } void ARGBToRGB565Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) { … } // dither4 is a row of 4 values from 4x4 dither matrix. // The 4x4 matrix contains values to increase RGB. When converting to // fewer bits (565) this provides an ordered dither. // The order in the 4x4 matrix in first byte is upper left. // The 4 values are passed as an int, then referenced as an array, so // endian will not affect order of the original matrix. But the dither4 // will containing the first pixel in the lower byte for little endian // or the upper byte for big endian. void ARGBToRGB565DitherRow_C(const uint8_t* src_argb, uint8_t* dst_rgb, uint32_t dither4, int width) { … } void ARGBToARGB1555Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) { … } void ARGBToARGB4444Row_C(const uint8_t* src_argb, uint8_t* dst_rgb, int width) { … } void ABGRToAR30Row_C(const uint8_t* src_abgr, uint8_t* dst_ar30, int width) { … } void ARGBToAR30Row_C(const uint8_t* src_argb, uint8_t* dst_ar30, int width) { … } void ARGBToAR64Row_C(const uint8_t* src_argb, uint16_t* dst_ar64, int width) { … } void ARGBToAB64Row_C(const uint8_t* src_argb, uint16_t* dst_ab64, int width) { … } void AR64ToARGBRow_C(const uint16_t* src_ar64, uint8_t* dst_argb, int width) { … } void AB64ToARGBRow_C(const uint16_t* src_ab64, uint8_t* dst_argb, int width) { … } void AR64ToAB64Row_C(const uint16_t* src_ar64, uint16_t* dst_ab64, int width) { … } // TODO(fbarchard): Make shuffle compatible with SIMD versions void AR64ShuffleRow_C(const uint8_t* src_ar64, uint8_t* dst_ar64, const uint8_t* shuffler, int width) { … } #ifdef LIBYUV_RGB7 // Old 7 bit math for compatibility on unsupported platforms. static __inline uint8_t RGBToY(uint8_t r, uint8_t g, uint8_t b) { return STATIC_CAST(uint8_t, ((33 * r + 65 * g + 13 * b) >> 7) + 16); } #else // 8 bit // Intel SSE/AVX uses the following equivalent formula // 0x7e80 = (66 + 129 + 25) * -128 + 0x1000 (for +16) and 0x0080 for round. // return (66 * ((int)r - 128) + 129 * ((int)g - 128) + 25 * ((int)b - 128) + // 0x7e80) >> 8; static __inline uint8_t RGBToY(uint8_t r, uint8_t g, uint8_t b) { … } #endif #define AVGB(a, b) … // LIBYUV_RGBTOU_TRUNCATE mimics x86 code that does not round. #ifdef LIBYUV_RGBTOU_TRUNCATE static __inline uint8_t RGBToU(uint8_t r, uint8_t g, uint8_t b) { … } static __inline uint8_t RGBToV(uint8_t r, uint8_t g, uint8_t b) { … } #else // TODO(fbarchard): Add rounding to x86 SIMD and use this static __inline uint8_t RGBToU(uint8_t r, uint8_t g, uint8_t b) { return STATIC_CAST(uint8_t, (112 * b - 74 * g - 38 * r + 0x8080) >> 8); } static __inline uint8_t RGBToV(uint8_t r, uint8_t g, uint8_t b) { return STATIC_CAST(uint8_t, (112 * r - 94 * g - 18 * b + 0x8080) >> 8); } #endif // LIBYUV_ARGBTOUV_PAVGB mimics x86 code that subsamples with 2 pavgb. #if !defined(LIBYUV_ARGBTOUV_PAVGB) static __inline int RGB2xToU(uint16_t r, uint16_t g, uint16_t b) { return STATIC_CAST( uint8_t, ((112 / 2) * b - (74 / 2) * g - (38 / 2) * r + 0x8080) >> 8); } static __inline int RGB2xToV(uint16_t r, uint16_t g, uint16_t b) { return STATIC_CAST( uint8_t, ((112 / 2) * r - (94 / 2) * g - (18 / 2) * b + 0x8080) >> 8); } #endif // ARGBToY_C and ARGBToUV_C // Intel version mimic SSE/AVX which does 2 pavgb #if defined(LIBYUV_ARGBTOUV_PAVGB) #define MAKEROWY … #else // ARM version does sum / 2 then multiply by 2x smaller coefficients #define MAKEROWY … #endif MAKEROWY(ARGB, 2, 1, 0, 4) MAKEROWY(BGRA, 1, 2, 3, 4) MAKEROWY(ABGR, 0, 1, 2, 4) MAKEROWY(RGBA, 3, 2, 1, 4) MAKEROWY(RGB24, 2, 1, 0, 3) MAKEROWY(RAW, 0, 1, 2, 3) #undef MAKEROWY // JPeg uses a variation on BT.601-1 full range // y = 0.29900 * r + 0.58700 * g + 0.11400 * b // u = -0.16874 * r - 0.33126 * g + 0.50000 * b + center // v = 0.50000 * r - 0.41869 * g - 0.08131 * b + center // BT.601 Mpeg range uses: // b 0.1016 * 255 = 25.908 = 25 // g 0.5078 * 255 = 129.489 = 129 // r 0.2578 * 255 = 65.739 = 66 // JPeg 7 bit Y (deprecated) // b 0.11400 * 128 = 14.592 = 15 // g 0.58700 * 128 = 75.136 = 75 // r 0.29900 * 128 = 38.272 = 38 // JPeg 8 bit Y: // b 0.11400 * 256 = 29.184 = 29 // g 0.58700 * 256 = 150.272 = 150 // r 0.29900 * 256 = 76.544 = 77 // JPeg 8 bit U: // b 0.50000 * 255 = 127.5 = 127 // g -0.33126 * 255 = -84.4713 = -84 // r -0.16874 * 255 = -43.0287 = -43 // JPeg 8 bit V: // b -0.08131 * 255 = -20.73405 = -20 // g -0.41869 * 255 = -106.76595 = -107 // r 0.50000 * 255 = 127.5 = 127 #ifdef LIBYUV_RGB7 // Old 7 bit math for compatibility on unsupported platforms. static __inline uint8_t RGBToYJ(uint8_t r, uint8_t g, uint8_t b) { return (38 * r + 75 * g + 15 * b + 64) >> 7; } #else // 8 bit static __inline uint8_t RGBToYJ(uint8_t r, uint8_t g, uint8_t b) { … } #endif #if defined(LIBYUV_ARGBTOUV_PAVGB) static __inline uint8_t RGBToUJ(uint8_t r, uint8_t g, uint8_t b) { … } static __inline uint8_t RGBToVJ(uint8_t r, uint8_t g, uint8_t b) { … } #else static __inline uint8_t RGB2xToUJ(uint16_t r, uint16_t g, uint16_t b) { return ((127 / 2) * b - (84 / 2) * g - (43 / 2) * r + 0x8080) >> 8; } static __inline uint8_t RGB2xToVJ(uint16_t r, uint16_t g, uint16_t b) { return ((127 / 2) * r - (107 / 2) * g - (20 / 2) * b + 0x8080) >> 8; } #endif // ARGBToYJ_C and ARGBToUVJ_C // Intel version mimic SSE/AVX which does 2 pavgb #if defined(LIBYUV_ARGBTOUV_PAVGB) #define MAKEROWYJ … #else // ARM version does sum / 2 then multiply by 2x smaller coefficients #define MAKEROWYJ … #endif MAKEROWYJ(ARGB, 2, 1, 0, 4) MAKEROWYJ(ABGR, 0, 1, 2, 4) MAKEROWYJ(RGBA, 3, 2, 1, 4) MAKEROWYJ(RGB24, 2, 1, 0, 3) MAKEROWYJ(RAW, 0, 1, 2, 3) #undef MAKEROWYJ void RGB565ToYRow_C(const uint8_t* src_rgb565, uint8_t* dst_y, int width) { … } void ARGB1555ToYRow_C(const uint8_t* src_argb1555, uint8_t* dst_y, int width) { … } void ARGB4444ToYRow_C(const uint8_t* src_argb4444, uint8_t* dst_y, int width) { … } void RGB565ToUVRow_C(const uint8_t* src_rgb565, int src_stride_rgb565, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ARGB1555ToUVRow_C(const uint8_t* src_argb1555, int src_stride_argb1555, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ARGB4444ToUVRow_C(const uint8_t* src_argb4444, int src_stride_argb4444, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ARGBToUV444Row_C(const uint8_t* src_argb, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ARGBGrayRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } // Convert a row of image to Sepia tone. void ARGBSepiaRow_C(uint8_t* dst_argb, int width) { … } // Apply color matrix to a row of image. Matrix is signed. // TODO(fbarchard): Consider adding rounding (+32). void ARGBColorMatrixRow_C(const uint8_t* src_argb, uint8_t* dst_argb, const int8_t* matrix_argb, int width) { … } // Apply color table to a row of image. void ARGBColorTableRow_C(uint8_t* dst_argb, const uint8_t* table_argb, int width) { … } // Apply color table to a row of image. void RGBColorTableRow_C(uint8_t* dst_argb, const uint8_t* table_argb, int width) { … } void ARGBQuantizeRow_C(uint8_t* dst_argb, int scale, int interval_size, int interval_offset, int width) { … } #define REPEAT8 … #define SHADE … void ARGBShadeRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width, uint32_t value) { … } #undef REPEAT8 #undef SHADE #define REPEAT8 … #define SHADE … void ARGBMultiplyRow_C(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #undef REPEAT8 #undef SHADE #define SHADE … void ARGBAddRow_C(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #undef SHADE #define SHADE … void ARGBSubtractRow_C(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #undef SHADE // Sobel functions which mimics SSSE3. void SobelXRow_C(const uint8_t* src_y0, const uint8_t* src_y1, const uint8_t* src_y2, uint8_t* dst_sobelx, int width) { … } void SobelYRow_C(const uint8_t* src_y0, const uint8_t* src_y1, uint8_t* dst_sobely, int width) { … } void SobelRow_C(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_argb, int width) { … } void SobelToPlaneRow_C(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_y, int width) { … } void SobelXYRow_C(const uint8_t* src_sobelx, const uint8_t* src_sobely, uint8_t* dst_argb, int width) { … } void J400ToARGBRow_C(const uint8_t* src_y, uint8_t* dst_argb, int width) { … } // Macros to create SIMD specific yuv to rgb conversion constants. // clang-format off #if defined(__aarch64__) || defined(__arm__) || defined(__riscv) // Bias values include subtract 128 from U and V, bias from Y and rounding. // For B and R bias is negative. For G bias is positive. #define YUVCONSTANTSBODY … #else #define YUVCONSTANTSBODY(YG, YB, UB, UG, VG, VR) … #endif // clang-format on #define MAKEYUVCONSTANTS … // TODO(fbarchard): Generate SIMD structures from float matrix. // BT.601 limited range YUV to RGB reference // R = (Y - 16) * 1.164 + V * 1.596 // G = (Y - 16) * 1.164 - U * 0.391 - V * 0.813 // B = (Y - 16) * 1.164 + U * 2.018 // KR = 0.299; KB = 0.114 // U and V contributions to R,G,B. #if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT601) #define UB … #else #define UB … #endif #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. #define YG … #define YB … MAKEYUVCONSTANTS(I601, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR // BT.601 full range YUV to RGB reference (aka JPEG) // * R = Y + V * 1.40200 // * G = Y - U * 0.34414 - V * 0.71414 // * B = Y + U * 1.77200 // KR = 0.299; KB = 0.114 // U and V contributions to R,G,B. #define UB … #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. #define YG … #define YB … MAKEYUVCONSTANTS(JPEG, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR // BT.709 limited range YUV to RGB reference // R = (Y - 16) * 1.164 + V * 1.793 // G = (Y - 16) * 1.164 - U * 0.213 - V * 0.533 // B = (Y - 16) * 1.164 + U * 2.112 // KR = 0.2126, KB = 0.0722 // U and V contributions to R,G,B. #if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT709) #define UB … #else #define UB … #endif #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. #define YG … #define YB … MAKEYUVCONSTANTS(H709, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR // BT.709 full range YUV to RGB reference // R = Y + V * 1.5748 // G = Y - U * 0.18732 - V * 0.46812 // B = Y + U * 1.8556 // KR = 0.2126, KB = 0.0722 // U and V contributions to R,G,B. #define UB … #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. (same as jpeg) #define YG … #define YB … MAKEYUVCONSTANTS(F709, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR // BT.2020 limited range YUV to RGB reference // R = (Y - 16) * 1.164384 + V * 1.67867 // G = (Y - 16) * 1.164384 - U * 0.187326 - V * 0.65042 // B = (Y - 16) * 1.164384 + U * 2.14177 // KR = 0.2627; KB = 0.0593 // U and V contributions to R,G,B. #if defined(LIBYUV_UNLIMITED_DATA) || defined(LIBYUV_UNLIMITED_BT2020) #define UB … #else #define UB … #endif #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. #define YG … #define YB … MAKEYUVCONSTANTS(2020, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR // BT.2020 full range YUV to RGB reference // R = Y + V * 1.474600 // G = Y - U * 0.164553 - V * 0.571353 // B = Y + U * 1.881400 // KR = 0.2627; KB = 0.0593 #define UB … #define UG … #define VG … #define VR … // Y contribution to R,G,B. Scale and bias. (same as jpeg) #define YG … #define YB … MAKEYUVCONSTANTS(V2020, YG, YB, UB, UG, VG, VR) #undef YG #undef YB #undef UB #undef UG #undef VG #undef VR #undef BB #undef BG #undef BR #undef MAKEYUVCONSTANTS #if defined(__aarch64__) || defined(__arm__) || defined(__riscv) #define LOAD_YUV_CONSTANTS … #define CALC_RGB16 … #else #define LOAD_YUV_CONSTANTS … #define CALC_RGB16 … #endif // C reference code that mimics the YUV assembly. // Reads 8 bit YUV and leaves result as 16 bit. static __inline void YuvPixel(uint8_t y, uint8_t u, uint8_t v, uint8_t* b, uint8_t* g, uint8_t* r, const struct YuvConstants* yuvconstants) { … } // Reads 8 bit YUV and leaves result as 16 bit. static __inline void YuvPixel8_16(uint8_t y, uint8_t u, uint8_t v, int* b, int* g, int* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 16 bit assembly. // Reads 10 bit YUV and leaves result as 16 bit. static __inline void YuvPixel10_16(uint16_t y, uint16_t u, uint16_t v, int* b, int* g, int* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 16 bit assembly. // Reads 12 bit YUV and leaves result as 16 bit. static __inline void YuvPixel12_16(int16_t y, int16_t u, int16_t v, int* b, int* g, int* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 10 bit assembly. // Reads 10 bit YUV and clamps down to 8 bit RGB. static __inline void YuvPixel10(uint16_t y, uint16_t u, uint16_t v, uint8_t* b, uint8_t* g, uint8_t* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 12 bit assembly. // Reads 12 bit YUV and clamps down to 8 bit RGB. static __inline void YuvPixel12(uint16_t y, uint16_t u, uint16_t v, uint8_t* b, uint8_t* g, uint8_t* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 16 bit assembly. // Reads 16 bit YUV and leaves result as 8 bit. static __inline void YuvPixel16_8(uint16_t y, uint16_t u, uint16_t v, uint8_t* b, uint8_t* g, uint8_t* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV 16 bit assembly. // Reads 16 bit YUV and leaves result as 16 bit. static __inline void YuvPixel16_16(uint16_t y, uint16_t u, uint16_t v, int* b, int* g, int* r, const struct YuvConstants* yuvconstants) { … } // C reference code that mimics the YUV assembly. // Reads 8 bit YUV and leaves result as 8 bit. static __inline void YPixel(uint8_t y, uint8_t* b, uint8_t* g, uint8_t* r, const struct YuvConstants* yuvconstants) { … } void I444ToARGBRow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I444ToRGB24Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } // Also used for 420 void I422ToARGBRow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } // 10 bit YUV to ARGB void I210ToARGBRow_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I410ToARGBRow_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I210AlphaToARGBRow_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, const uint16_t* src_a, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I410AlphaToARGBRow_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, const uint16_t* src_a, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } // 12 bit YUV to ARGB void I212ToARGBRow_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } static void StoreAR30(uint8_t* rgb_buf, int b, int g, int r) { … } // 10 bit YUV to 10 bit AR30 void I210ToAR30Row_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } // 12 bit YUV to 10 bit AR30 void I212ToAR30Row_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I410ToAR30Row_C(const uint16_t* src_y, const uint16_t* src_u, const uint16_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } // P210 has 10 bits in msb of 16 bit NV12 style layout. void P210ToARGBRow_C(const uint16_t* src_y, const uint16_t* src_uv, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void P410ToARGBRow_C(const uint16_t* src_y, const uint16_t* src_uv, uint8_t* dst_argb, const struct YuvConstants* yuvconstants, int width) { … } void P210ToAR30Row_C(const uint16_t* src_y, const uint16_t* src_uv, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } void P410ToAR30Row_C(const uint16_t* src_y, const uint16_t* src_uv, uint8_t* dst_ar30, const struct YuvConstants* yuvconstants, int width) { … } // 8 bit YUV to 10 bit AR30 // Uses same code as 10 bit YUV bit shifts the 8 bit values up to 10 bits. void I422ToAR30Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I444AlphaToARGBRow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, const uint8_t* src_a, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I422AlphaToARGBRow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, const uint8_t* src_a, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I422ToRGB24Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I422ToARGB4444Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb4444, const struct YuvConstants* yuvconstants, int width) { … } void I422ToARGB1555Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb1555, const struct YuvConstants* yuvconstants, int width) { … } void I422ToRGB565Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } void NV12ToARGBRow_C(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void NV21ToARGBRow_C(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void NV12ToRGB24Row_C(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void NV21ToRGB24Row_C(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void NV12ToRGB565Row_C(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } void YUY2ToARGBRow_C(const uint8_t* src_yuy2, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void UYVYToARGBRow_C(const uint8_t* src_uyvy, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I422ToRGBARow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void I400ToARGBRow_C(const uint8_t* src_y, uint8_t* rgb_buf, const struct YuvConstants* yuvconstants, int width) { … } void MirrorRow_C(const uint8_t* src, uint8_t* dst, int width) { … } void MirrorRow_16_C(const uint16_t* src, uint16_t* dst, int width) { … } void MirrorUVRow_C(const uint8_t* src_uv, uint8_t* dst_uv, int width) { … } void MirrorSplitUVRow_C(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void ARGBMirrorRow_C(const uint8_t* src, uint8_t* dst, int width) { … } void RGB24MirrorRow_C(const uint8_t* src_rgb24, uint8_t* dst_rgb24, int width) { … } void SplitUVRow_C(const uint8_t* src_uv, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void MergeUVRow_C(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) { … } void DetileRow_C(const uint8_t* src, ptrdiff_t src_tile_stride, uint8_t* dst, int width) { … } void DetileRow_16_C(const uint16_t* src, ptrdiff_t src_tile_stride, uint16_t* dst, int width) { … } void DetileSplitUVRow_C(const uint8_t* src_uv, ptrdiff_t src_tile_stride, uint8_t* dst_u, uint8_t* dst_v, int width) { … } void DetileToYUY2_C(const uint8_t* src_y, ptrdiff_t src_y_tile_stride, const uint8_t* src_uv, ptrdiff_t src_uv_tile_stride, uint8_t* dst_yuy2, int width) { … } // Unpack MT2T into tiled P010 64 pixels at a time. MT2T's bitstream is encoded // in 80 byte blocks representing 64 pixels each. The first 16 bytes of the // block contain all of the lower 2 bits of each pixel packed together, and the // next 64 bytes represent all the upper 8 bits of the pixel. The lower bits are // packed into 1x4 blocks, whereas the upper bits are packed in normal raster // order. void UnpackMT2T_C(const uint8_t* src, uint16_t* dst, size_t size) { … } void SplitRGBRow_C(const uint8_t* src_rgb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } void MergeRGBRow_C(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, uint8_t* dst_rgb, int width) { … } void SplitARGBRow_C(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, uint8_t* dst_a, int width) { … } void MergeARGBRow_C(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, const uint8_t* src_a, uint8_t* dst_argb, int width) { … } void MergeXR30Row_C(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint8_t* dst_ar30, int depth, int width) { … } void MergeAR64Row_C(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, const uint16_t* src_a, uint16_t* dst_ar64, int depth, int width) { … } void MergeARGB16To8Row_C(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, const uint16_t* src_a, uint8_t* dst_argb, int depth, int width) { … } void MergeXR64Row_C(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint16_t* dst_ar64, int depth, int width) { … } void MergeXRGB16To8Row_C(const uint16_t* src_r, const uint16_t* src_g, const uint16_t* src_b, uint8_t* dst_argb, int depth, int width) { … } void SplitXRGBRow_C(const uint8_t* src_argb, uint8_t* dst_r, uint8_t* dst_g, uint8_t* dst_b, int width) { … } void MergeXRGBRow_C(const uint8_t* src_r, const uint8_t* src_g, const uint8_t* src_b, uint8_t* dst_argb, int width) { … } // Convert lsb formats to msb, depending on sample depth. void MergeUVRow_16_C(const uint16_t* src_u, const uint16_t* src_v, uint16_t* dst_uv, int depth, int width) { … } // Convert msb formats to lsb, depending on sample depth. void SplitUVRow_16_C(const uint16_t* src_uv, uint16_t* dst_u, uint16_t* dst_v, int depth, int width) { … } void MultiplyRow_16_C(const uint16_t* src_y, uint16_t* dst_y, int scale, int width) { … } void DivideRow_16_C(const uint16_t* src_y, uint16_t* dst_y, int scale, int width) { … } // Use scale to convert lsb formats to msb, depending how many bits there are: // 32768 = 9 bits // 16384 = 10 bits // 4096 = 12 bits // 256 = 16 bits // TODO(fbarchard): change scale to bits #define C16TO8(v, scale) … void Convert16To8Row_C(const uint16_t* src_y, uint8_t* dst_y, int scale, int width) { … } // Use scale to convert lsb formats to msb, depending how many bits there are: // 1024 = 10 bits void Convert8To16Row_C(const uint8_t* src_y, uint16_t* dst_y, int scale, int width) { … } void CopyRow_C(const uint8_t* src, uint8_t* dst, int count) { … } void CopyRow_16_C(const uint16_t* src, uint16_t* dst, int count) { … } void SetRow_C(uint8_t* dst, uint8_t v8, int width) { … } void ARGBSetRow_C(uint8_t* dst_argb, uint32_t v32, int width) { … } // Filter 2 rows of YUY2 UV's (422) into U and V (420). void YUY2ToUVRow_C(const uint8_t* src_yuy2, int src_stride_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } // Filter 2 rows of YUY2 UV's (422) into UV (NV12). void YUY2ToNVUVRow_C(const uint8_t* src_yuy2, int src_stride_yuy2, uint8_t* dst_uv, int width) { … } // Copy row of YUY2 UV's (422) into U and V (422). void YUY2ToUV422Row_C(const uint8_t* src_yuy2, uint8_t* dst_u, uint8_t* dst_v, int width) { … } // Copy row of YUY2 Y's (422) into Y (420/422). void YUY2ToYRow_C(const uint8_t* src_yuy2, uint8_t* dst_y, int width) { … } // Filter 2 rows of UYVY UV's (422) into U and V (420). void UYVYToUVRow_C(const uint8_t* src_uyvy, int src_stride_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } // Copy row of UYVY UV's (422) into U and V (422). void UYVYToUV422Row_C(const uint8_t* src_uyvy, uint8_t* dst_u, uint8_t* dst_v, int width) { … } // Copy row of UYVY Y's (422) into Y (420/422). void UYVYToYRow_C(const uint8_t* src_uyvy, uint8_t* dst_y, int width) { … } #define BLEND … // Blend src_argb over src_argb1 and store to dst_argb. // dst_argb may be src_argb or src_argb1. // This code mimics the SSSE3 version for better testability. void ARGBBlendRow_C(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) { … } #undef BLEND #define UBLEND … void BlendPlaneRow_C(const uint8_t* src0, const uint8_t* src1, const uint8_t* alpha, uint8_t* dst, int width) { … } #undef UBLEND #define ATTENUATE … // Multiply source RGB by alpha and store to destination. void ARGBAttenuateRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } #undef ATTENUATE // Divide source RGB by alpha and store to destination. // b = (b * 255 + (a / 2)) / a; // g = (g * 255 + (a / 2)) / a; // r = (r * 255 + (a / 2)) / a; // Reciprocal method is off by 1 on some values. ie 125 // 8.8 fixed point inverse table with 1.0 in upper short and 1 / a in lower. #define T … const uint32_t fixed_invtbl8[256] = …; #undef T #if defined(LIBYUV_UNATTENUATE_DUP) // This code mimics the Intel SIMD version for better testability. #define UNATTENUATE … #else #define UNATTENUATE(f, ia) … #endif // mimics the Intel SIMD code for exactness. void ARGBUnattenuateRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width) { … } void ComputeCumulativeSumRow_C(const uint8_t* row, int32_t* cumsum, const int32_t* previous_cumsum, int width) { … } void CumulativeSumToAverageRow_C(const int32_t* tl, const int32_t* bl, int w, int area, uint8_t* dst, int count) { … } // Copy pixels from rotated source to destination row with a slope. LIBYUV_API void ARGBAffineRow_C(const uint8_t* src_argb, int src_argb_stride, uint8_t* dst_argb, const float* uv_dudv, int width) { … } // Blend 2 rows into 1. static void HalfRow_C(const uint8_t* src_uv, ptrdiff_t src_uv_stride, uint8_t* dst_uv, int width) { … } static void HalfRow_16_C(const uint16_t* src_uv, ptrdiff_t src_uv_stride, uint16_t* dst_uv, int width) { … } static void HalfRow_16To8_C(const uint16_t* src_uv, ptrdiff_t src_uv_stride, uint8_t* dst_uv, int scale, int width) { … } // C version 2x2 -> 2x1. void InterpolateRow_C(uint8_t* dst_ptr, const uint8_t* src_ptr, ptrdiff_t src_stride, int width, int source_y_fraction) { … } // C version 2x2 -> 2x1. void InterpolateRow_16_C(uint16_t* dst_ptr, const uint16_t* src_ptr, ptrdiff_t src_stride, int width, int source_y_fraction) { … } // C version 2x2 16 bit-> 2x1 8 bit. // Use scale to convert lsb formats to msb, depending how many bits there are: // 32768 = 9 bits // 16384 = 10 bits // 4096 = 12 bits // 256 = 16 bits // TODO(fbarchard): change scale to bits void InterpolateRow_16To8_C(uint8_t* dst_ptr, const uint16_t* src_ptr, ptrdiff_t src_stride, int scale, int width, int source_y_fraction) { … } // Use first 4 shuffler values to reorder ARGB channels. void ARGBShuffleRow_C(const uint8_t* src_argb, uint8_t* dst_argb, const uint8_t* shuffler, int width) { … } void I422ToYUY2Row_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_frame, int width) { … } void I422ToUYVYRow_C(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_frame, int width) { … } void ARGBPolynomialRow_C(const uint8_t* src_argb, uint8_t* dst_argb, const float* poly, int width) { … } // Samples assumed to be unsigned in low 9, 10 or 12 bits. Scale factor // adjust the source integer range to the half float range desired. // This magic constant is 2^-112. Multiplying by this // is the same as subtracting 112 from the exponent, which // is the difference in exponent bias between 32-bit and // 16-bit floats. Once we've done this subtraction, we can // simply extract the low bits of the exponent and the high // bits of the mantissa from our float and we're done. // Work around GCC 7 punning warning -Wstrict-aliasing #if defined(__GNUC__) uint32_alias_t; #else typedef uint32_t uint32_alias_t; #endif void HalfFloatRow_C(const uint16_t* src, uint16_t* dst, float scale, int width) { … } void ByteToFloatRow_C(const uint8_t* src, float* dst, float scale, int width) { … } void ARGBLumaColorTableRow_C(const uint8_t* src_argb, uint8_t* dst_argb, int width, const uint8_t* luma, uint32_t lumacoeff) { … } void ARGBCopyAlphaRow_C(const uint8_t* src, uint8_t* dst, int width) { … } void ARGBExtractAlphaRow_C(const uint8_t* src_argb, uint8_t* dst_a, int width) { … } void ARGBCopyYToAlphaRow_C(const uint8_t* src, uint8_t* dst, int width) { … } // Maximum temporary width for wrappers to process at a time, in pixels. #define MAXTWIDTH … #if !(defined(_MSC_VER) && !defined(__clang__) && defined(_M_IX86)) && \ defined(HAS_I422TORGB565ROW_SSSE3) // row_win.cc has asm version, but GCC uses 2 step wrapper. void I422ToRGB565Row_SSSE3(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TOARGB1555ROW_SSSE3) void I422ToARGB1555Row_SSSE3(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb1555, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TOARGB4444ROW_SSSE3) void I422ToARGB4444Row_SSSE3(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb4444, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV12TORGB565ROW_SSSE3) void NV12ToRGB565Row_SSSE3(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV12TORGB24ROW_SSSE3) void NV12ToRGB24Row_SSSE3(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV21TORGB24ROW_SSSE3) void NV21ToRGB24Row_SSSE3(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV12TORGB24ROW_AVX2) void NV12ToRGB24Row_AVX2(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV21TORGB24ROW_AVX2) void NV21ToRGB24Row_AVX2(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TORGB565ROW_AVX2) void I422ToRGB565Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TOARGB1555ROW_AVX2) void I422ToARGB1555Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb1555, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TOARGB4444ROW_AVX2) void I422ToARGB4444Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_argb4444, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I422TORGB24ROW_AVX2) void I422ToRGB24Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_I444TORGB24ROW_AVX2) void I444ToRGB24Row_AVX2(const uint8_t* src_y, const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_rgb24, const struct YuvConstants* yuvconstants, int width) { … } #endif #if defined(HAS_NV12TORGB565ROW_AVX2) void NV12ToRGB565Row_AVX2(const uint8_t* src_y, const uint8_t* src_uv, uint8_t* dst_rgb565, const struct YuvConstants* yuvconstants, int width) { … } #endif #ifdef HAS_RGB24TOYJROW_AVX2 // Convert 16 RGB24 pixels (64 bytes) to 16 YJ values. void RGB24ToYJRow_AVX2(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) { … } #endif // HAS_RGB24TOYJROW_AVX2 #ifdef HAS_RAWTOYJROW_AVX2 // Convert 16 RAW pixels (64 bytes) to 16 YJ values. void RAWToYJRow_AVX2(const uint8_t* src_raw, uint8_t* dst_yj, int width) { … } #endif // HAS_RAWTOYJROW_AVX2 #ifdef HAS_RGB24TOYJROW_SSSE3 // Convert 16 RGB24 pixels (64 bytes) to 16 YJ values. void RGB24ToYJRow_SSSE3(const uint8_t* src_rgb24, uint8_t* dst_yj, int width) { … } #endif // HAS_RGB24TOYJROW_SSSE3 #ifdef HAS_RAWTOYJROW_SSSE3 // Convert 16 RAW pixels (64 bytes) to 16 YJ values. void RAWToYJRow_SSSE3(const uint8_t* src_raw, uint8_t* dst_yj, int width) { … } #endif // HAS_RAWTOYJROW_SSSE3 #ifdef HAS_INTERPOLATEROW_16TO8_AVX2 void InterpolateRow_16To8_AVX2(uint8_t* dst_ptr, const uint16_t* src_ptr, ptrdiff_t src_stride, int scale, int width, int source_y_fraction) { … } #endif // HAS_INTERPOLATEROW_16TO8_AVX2 float ScaleSumSamples_C(const float* src, float* dst, float scale, int width) { … } float ScaleMaxSamples_C(const float* src, float* dst, float scale, int width) { … } void ScaleSamples_C(const float* src, float* dst, float scale, int width) { … } void GaussRow_C(const uint32_t* src, uint16_t* dst, int width) { … } // filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. void GaussCol_C(const uint16_t* src0, const uint16_t* src1, const uint16_t* src2, const uint16_t* src3, const uint16_t* src4, uint32_t* dst, int width) { … } void GaussRow_F32_C(const float* src, float* dst, int width) { … } // filter 5 rows with 1, 4, 6, 4, 1 coefficients to produce 1 row. void GaussCol_F32_C(const float* src0, const float* src1, const float* src2, const float* src3, const float* src4, float* dst, int width) { … } // Convert biplanar NV21 to packed YUV24 void NV21ToYUV24Row_C(const uint8_t* src_y, const uint8_t* src_vu, uint8_t* dst_yuv24, int width) { … } // Filter 2 rows of AYUV UV's (444) into UV (420). // AYUV is VUYA in memory. UV for NV12 is UV order in memory. void AYUVToUVRow_C(const uint8_t* src_ayuv, int src_stride_ayuv, uint8_t* dst_uv, int width) { … } // Filter 2 rows of AYUV UV's (444) into VU (420). void AYUVToVURow_C(const uint8_t* src_ayuv, int src_stride_ayuv, uint8_t* dst_vu, int width) { … } // Copy row of AYUV Y's into Y void AYUVToYRow_C(const uint8_t* src_ayuv, uint8_t* dst_y, int width) { … } // Convert UV plane of NV12 to VU of NV21. void SwapUVRow_C(const uint8_t* src_uv, uint8_t* dst_vu, int width) { … } void HalfMergeUVRow_C(const uint8_t* src_u, int src_stride_u, const uint8_t* src_v, int src_stride_v, uint8_t* dst_uv, int width) { … } #undef STATIC_CAST #ifdef __cplusplus } // extern "C" } // namespace libyuv #endif
Codebase Browser
chromium