LCOV - code coverage report
Current view: top level - src/libswscale - input.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 628 716 87.7 %
Date: 2017-01-19 23:52:33 Functions: 126 155 81.3 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2001-2012 Michael Niedermayer <michaelni@gmx.at>
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include <math.h>
      22             : #include <stdint.h>
      23             : #include <stdio.h>
      24             : #include <string.h>
      25             : 
      26             : #include "libavutil/avutil.h"
      27             : #include "libavutil/bswap.h"
      28             : #include "libavutil/cpu.h"
      29             : #include "libavutil/intreadwrite.h"
      30             : #include "libavutil/mathematics.h"
      31             : #include "libavutil/pixdesc.h"
      32             : #include "libavutil/avassert.h"
      33             : #include "config.h"
      34             : #include "rgb2rgb.h"
      35             : #include "swscale.h"
      36             : #include "swscale_internal.h"
      37             : 
      38             : #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
      39             : 
      40             : #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? b_r : r_b)
      41             : #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? r_b : b_r)
      42             : 
      43             : static av_always_inline void
      44        1280 : rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
      45             :                     enum AVPixelFormat origin, int32_t *rgb2yuv)
      46             : {
      47        1280 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
      48             :     int i;
      49      423168 :     for (i = 0; i < width; i++) {
      50      421888 :         unsigned int r_b = input_pixel(&src[i*4+0]);
      51      421888 :         unsigned int   g = input_pixel(&src[i*4+1]);
      52      421888 :         unsigned int b_r = input_pixel(&src[i*4+2]);
      53             : 
      54      421888 :         dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
      55             :     }
      56        1280 : }
      57             : 
      58             : static av_always_inline void
      59        1280 : rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
      60             :                     const uint16_t *src1, const uint16_t *src2,
      61             :                     int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
      62             : {
      63             :     int i;
      64        1280 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
      65        1280 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
      66             :     av_assert1(src1==src2);
      67      423168 :     for (i = 0; i < width; i++) {
      68      421888 :         int r_b = input_pixel(&src1[i*4+0]);
      69      421888 :         int   g = input_pixel(&src1[i*4+1]);
      70      421888 :         int b_r = input_pixel(&src1[i*4+2]);
      71             : 
      72      421888 :         dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
      73      421888 :         dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
      74             :     }
      75        1280 : }
      76             : 
      77             : static av_always_inline void
      78           0 : rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
      79             :                           const uint16_t *src1, const uint16_t *src2,
      80             :                           int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
      81             : {
      82             :     int i;
      83           0 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
      84           0 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
      85             :     av_assert1(src1==src2);
      86           0 :     for (i = 0; i < width; i++) {
      87           0 :         int r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
      88           0 :         int   g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
      89           0 :         int b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;
      90             : 
      91           0 :         dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
      92           0 :         dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
      93             :     }
      94           0 : }
      95             : 
      96             : #define rgb64funcs(pattern, BE_LE, origin) \
      97             : static void pattern ## 64 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
      98             :                                     int width, uint32_t *rgb2yuv) \
      99             : { \
     100             :     const uint16_t *src = (const uint16_t *) _src; \
     101             :     uint16_t *dst = (uint16_t *) _dst; \
     102             :     rgb64ToY_c_template(dst, src, width, origin, rgb2yuv); \
     103             : } \
     104             :  \
     105             : static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
     106             :                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
     107             :                                     int width, uint32_t *rgb2yuv) \
     108             : { \
     109             :     const uint16_t *src1 = (const uint16_t *) _src1, \
     110             :                    *src2 = (const uint16_t *) _src2; \
     111             :     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
     112             :     rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
     113             : } \
     114             :  \
     115             : static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
     116             :                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
     117             :                                     int width, uint32_t *rgb2yuv) \
     118             : { \
     119             :     const uint16_t *src1 = (const uint16_t *) _src1, \
     120             :                    *src2 = (const uint16_t *) _src2; \
     121             :     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
     122             :     rgb64ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
     123             : }
     124             : 
     125         576 : rgb64funcs(rgb, LE, AV_PIX_FMT_RGBA64LE)
     126         832 : rgb64funcs(rgb, BE, AV_PIX_FMT_RGBA64BE)
     127         576 : rgb64funcs(bgr, LE, AV_PIX_FMT_BGRA64LE)
     128         576 : rgb64funcs(bgr, BE, AV_PIX_FMT_BGRA64BE)
     129             : 
     130       46765 : static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
     131             :                                                  const uint16_t *src, int width,
     132             :                                                  enum AVPixelFormat origin,
     133             :                                                  int32_t *rgb2yuv)
     134             : {
     135       46765 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
     136             :     int i;
     137    15935722 :     for (i = 0; i < width; i++) {
     138    15888957 :         unsigned int r_b = input_pixel(&src[i * 3 + 0]);
     139    15888957 :         unsigned int g   = input_pixel(&src[i * 3 + 1]);
     140    15888957 :         unsigned int b_r = input_pixel(&src[i * 3 + 2]);
     141             : 
     142    15888957 :         dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
     143             :     }
     144       46765 : }
     145             : 
     146        1865 : static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
     147             :                                                   uint16_t *dstV,
     148             :                                                   const uint16_t *src1,
     149             :                                                   const uint16_t *src2,
     150             :                                                   int width,
     151             :                                                   enum AVPixelFormat origin,
     152             :                                                   int32_t *rgb2yuv)
     153             : {
     154             :     int i;
     155        1865 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     156        1865 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     157             :     av_assert1(src1 == src2);
     158      626622 :     for (i = 0; i < width; i++) {
     159      624757 :         int r_b = input_pixel(&src1[i * 3 + 0]);
     160      624757 :         int g   = input_pixel(&src1[i * 3 + 1]);
     161      624757 :         int b_r = input_pixel(&src1[i * 3 + 2]);
     162             : 
     163      624757 :         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
     164      624757 :         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
     165             :     }
     166        1865 : }
     167             : 
     168       44900 : static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
     169             :                                                        uint16_t *dstV,
     170             :                                                        const uint16_t *src1,
     171             :                                                        const uint16_t *src2,
     172             :                                                        int width,
     173             :                                                        enum AVPixelFormat origin,
     174             :                                                        int32_t *rgb2yuv)
     175             : {
     176             :     int i;
     177       44900 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     178       44900 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     179             :     av_assert1(src1 == src2);
     180     7677000 :     for (i = 0; i < width; i++) {
     181    22896300 :         int r_b = (input_pixel(&src1[6 * i + 0]) +
     182    15264200 :                    input_pixel(&src1[6 * i + 3]) + 1) >> 1;
     183    22896300 :         int g   = (input_pixel(&src1[6 * i + 1]) +
     184    15264200 :                    input_pixel(&src1[6 * i + 4]) + 1) >> 1;
     185    22896300 :         int b_r = (input_pixel(&src1[6 * i + 2]) +
     186    15264200 :                    input_pixel(&src1[6 * i + 5]) + 1) >> 1;
     187             : 
     188     7632100 :         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
     189     7632100 :         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
     190             :     }
     191       44900 : }
     192             : 
     193             : #undef r
     194             : #undef b
     195             : #undef input_pixel
     196             : 
     197             : #define rgb48funcs(pattern, BE_LE, origin)                              \
     198             : static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst,              \
     199             :                                             const uint8_t *_src,        \
     200             :                                             const uint8_t *unused0, const uint8_t *unused1,\
     201             :                                             int width,                  \
     202             :                                             uint32_t *rgb2yuv)          \
     203             : {                                                                       \
     204             :     const uint16_t *src = (const uint16_t *)_src;                       \
     205             :     uint16_t *dst       = (uint16_t *)_dst;                             \
     206             :     rgb48ToY_c_template(dst, src, width, origin, rgb2yuv);              \
     207             : }                                                                       \
     208             :                                                                         \
     209             : static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU,            \
     210             :                                              uint8_t *_dstV,            \
     211             :                                              const uint8_t *unused0,    \
     212             :                                              const uint8_t *_src1,      \
     213             :                                              const uint8_t *_src2,      \
     214             :                                              int width,                 \
     215             :                                              uint32_t *rgb2yuv)         \
     216             : {                                                                       \
     217             :     const uint16_t *src1 = (const uint16_t *)_src1,                     \
     218             :                    *src2 = (const uint16_t *)_src2;                     \
     219             :     uint16_t *dstU = (uint16_t *)_dstU,                                 \
     220             :              *dstV = (uint16_t *)_dstV;                                 \
     221             :     rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);        \
     222             : }                                                                       \
     223             :                                                                         \
     224             : static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU,       \
     225             :                                                   uint8_t *_dstV,       \
     226             :                                                   const uint8_t *unused0,    \
     227             :                                                   const uint8_t *_src1, \
     228             :                                                   const uint8_t *_src2, \
     229             :                                                   int width,            \
     230             :                                                   uint32_t *rgb2yuv)    \
     231             : {                                                                       \
     232             :     const uint16_t *src1 = (const uint16_t *)_src1,                     \
     233             :                    *src2 = (const uint16_t *)_src2;                     \
     234             :     uint16_t *dstU = (uint16_t *)_dstU,                                 \
     235             :              *dstV = (uint16_t *)_dstV;                                 \
     236             :     rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);   \
     237             : }
     238             : 
     239       90970 : rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
     240        1408 : rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
     241         576 : rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
     242         576 : rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
     243             : 
     244             : #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA ||                      \
     245             :                          origin == AV_PIX_FMT_BGRA ||                      \
     246             :                          origin == AV_PIX_FMT_ARGB ||                      \
     247             :                          origin == AV_PIX_FMT_ABGR)                        \
     248             :                         ? AV_RN32A(&src[(i) * 4])                       \
     249             :                         : (isBE(origin) ? AV_RB16(&src[(i) * 2])        \
     250             :                                         : AV_RL16(&src[(i) * 2])))
     251             : 
     252      712564 : static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
     253             :                                                     const uint8_t *src,
     254             :                                                     int width,
     255             :                                                     enum AVPixelFormat origin,
     256             :                                                     int shr, int shg,
     257             :                                                     int shb, int shp,
     258             :                                                     int maskr, int maskg,
     259             :                                                     int maskb, int rsh,
     260             :                                                     int gsh, int bsh, int S,
     261             :                                                     int32_t *rgb2yuv)
     262             : {
     263      712564 :     const int ry       = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
     264      712564 :     const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
     265             :     int i;
     266             : 
     267   273889148 :     for (i = 0; i < width; i++) {
     268   273176584 :         int px = input_pixel(i) >> shp;
     269   273176584 :         int b  = (px & maskb) >> shb;
     270   273176584 :         int g  = (px & maskg) >> shg;
     271   273176584 :         int r  = (px & maskr) >> shr;
     272             : 
     273   273176584 :         dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
     274             :     }
     275      712564 : }
     276             : 
     277      246972 : static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
     278             :                                                      int16_t *dstV,
     279             :                                                      const uint8_t *src,
     280             :                                                      int width,
     281             :                                                      enum AVPixelFormat origin,
     282             :                                                      int shr, int shg,
     283             :                                                      int shb, int shp,
     284             :                                                      int maskr, int maskg,
     285             :                                                      int maskb, int rsh,
     286             :                                                      int gsh, int bsh, int S,
     287             :                                                      int32_t *rgb2yuv)
     288             : {
     289      246972 :     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
     290      246972 :               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh;
     291      246972 :     const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
     292             :     int i;
     293             : 
     294    57868308 :     for (i = 0; i < width; i++) {
     295    57621336 :         int px = input_pixel(i) >> shp;
     296    57621336 :         int b  = (px & maskb)   >> shb;
     297    57621336 :         int g  = (px & maskg)   >> shg;
     298    57621336 :         int r  = (px & maskr)   >> shr;
     299             : 
     300    57621336 :         dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
     301    57621336 :         dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
     302             :     }
     303      246972 : }
     304             : 
     305      398242 : static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
     306             :                                                           int16_t *dstV,
     307             :                                                           const uint8_t *src,
     308             :                                                           int width,
     309             :                                                           enum AVPixelFormat origin,
     310             :                                                           int shr, int shg,
     311             :                                                           int shb, int shp,
     312             :                                                           int maskr, int maskg,
     313             :                                                           int maskb, int rsh,
     314             :                                                           int gsh, int bsh, int S,
     315             :                                                           int32_t *rgb2yuv)
     316             : {
     317      398242 :     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
     318      398242 :               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh,
     319      398242 :               maskgx   = ~(maskr | maskb);
     320      398242 :     const unsigned rnd = (256U<<(S)) + (1<<(S-6));
     321             :     int i;
     322             : 
     323      398242 :     maskr |= maskr << 1;
     324      398242 :     maskb |= maskb << 1;
     325      398242 :     maskg |= maskg << 1;
     326    96727716 :     for (i = 0; i < width; i++) {
     327    96329474 :         unsigned px0 = input_pixel(2 * i + 0) >> shp;
     328    96329474 :         unsigned px1 = input_pixel(2 * i + 1) >> shp;
     329    96329474 :         int b, r, g = (px0 & maskgx) + (px1 & maskgx);
     330    96329474 :         int rb = px0 + px1 - g;
     331             : 
     332    96329474 :         b = (rb & maskb) >> shb;
     333    96329474 :         if (shp ||
     334    96246018 :             origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
     335    88512542 :             origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
     336     7867620 :             g >>= shg;
     337             :         } else {
     338    88461854 :             g = (g & maskg) >> shg;
     339             :         }
     340    96329474 :         r = (rb & maskr) >> shr;
     341             : 
     342    96329474 :         dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
     343    96329474 :         dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
     344             :     }
     345      398242 : }
     346             : 
     347             : #undef input_pixel
     348             : 
     349             : #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,          \
     350             :                          maskg, maskb, rsh, gsh, bsh, S)                \
     351             : static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,            \
     352             :                           int width, uint32_t *tab)                     \
     353             : {                                                                       \
     354             :     rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp,    \
     355             :                            maskr, maskg, maskb, rsh, gsh, bsh, S, tab); \
     356             : }                                                                       \
     357             :                                                                         \
     358             : static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV,                \
     359             :                            const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy,    \
     360             :                            int width, uint32_t *tab)                    \
     361             : {                                                                       \
     362             :     rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,                \
     363             :                             shr, shg, shb, shp,                         \
     364             :                             maskr, maskg, maskb, rsh, gsh, bsh, S, tab);\
     365             : }                                                                       \
     366             :                                                                         \
     367             : static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV,           \
     368             :                                 const uint8_t *unused0, const uint8_t *src,                     \
     369             :                                 const uint8_t *dummy,                   \
     370             :                                 int width, uint32_t *tab)               \
     371             : {                                                                       \
     372             :     rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,           \
     373             :                                  shr, shg, shb, shp,                    \
     374             :                                  maskr, maskg, maskb,                   \
     375             :                                  rsh, gsh, bsh, S, tab);                \
     376             : }
     377             : 
     378      989946 : rgb16_32_wrapper(AV_PIX_FMT_BGR32,    bgr32,  16, 0,  0, 0, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
     379        1152 : rgb16_32_wrapper(AV_PIX_FMT_BGR32_1,  bgr321, 16, 0,  0, 8, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
     380        1152 : rgb16_32_wrapper(AV_PIX_FMT_RGB32,    rgb32,   0, 0, 16, 0,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
     381        1664 : rgb16_32_wrapper(AV_PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
     382         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
     383         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
     384         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
     385       90952 : rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
     386      267152 : rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
     387         576 : rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
     388         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
     389         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
     390         576 : rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
     391         576 : rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
     392         576 : rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
     393         576 : rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
     394             : 
     395           0 : static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
     396             :                          const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
     397             :                          int width, uint32_t *rgb2yuv)
     398             : {
     399           0 :     uint16_t *dstU = (uint16_t *)_dstU;
     400           0 :     uint16_t *dstV = (uint16_t *)_dstV;
     401           0 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     402           0 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     403             : 
     404             :     int i;
     405           0 :     for (i = 0; i < width; i++) {
     406           0 :         unsigned int g   = gsrc[2*i] + gsrc[2*i+1];
     407           0 :         unsigned int b   = bsrc[2*i] + bsrc[2*i+1];
     408           0 :         unsigned int r   = rsrc[2*i] + rsrc[2*i+1];
     409             : 
     410           0 :         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
     411           0 :         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
     412             :     }
     413           0 : }
     414             : 
     415         576 : static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
     416             :                           const uint8_t *unused2, int width, uint32_t *unused)
     417             : {
     418         576 :     int16_t *dst = (int16_t *)_dst;
     419         576 :     const uint16_t *src = (const uint16_t *)_src;
     420             :     int i;
     421      203328 :     for (i = 0; i < width; i++)
     422      202752 :         dst[i] = AV_RL16(src + 4 * i + 3);
     423         576 : }
     424             : 
     425         576 : static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
     426             :                           const uint8_t *unused2, int width, uint32_t *unused)
     427             : {
     428         576 :     int16_t *dst = (int16_t *)_dst;
     429         576 :     const uint16_t *src = (const uint16_t *)_src;
     430             :     int i;
     431      203328 :     for (i = 0; i < width; i++)
     432      202752 :         dst[i] = AV_RB16(src + 4 * i + 3);
     433         576 : }
     434             : 
     435        1408 : static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
     436             : {
     437        1408 :     int16_t *dst = (int16_t *)_dst;
     438             :     int i;
     439      472448 :     for (i=0; i<width; i++) {
     440      471040 :         dst[i]= src[4*i]<<6;
     441             :     }
     442        1408 : }
     443             : 
     444      154590 : static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
     445             : {
     446      154590 :     int16_t *dst = (int16_t *)_dst;
     447             :     int i;
     448   110600712 :     for (i=0; i<width; i++) {
     449   110446122 :         dst[i]= src[4*i+3]<<6;
     450             :     }
     451      154590 : }
     452             : 
     453           0 : static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
     454             : {
     455           0 :     int16_t *dst = (int16_t *)_dst;
     456             :     int i;
     457           0 :     for (i=0; i<width; i++) {
     458           0 :         int d= src[i];
     459             : 
     460           0 :         dst[i]= (pal[d] >> 24)<<6;
     461             :     }
     462           0 : }
     463             : 
     464       94340 : static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
     465             : {
     466       94340 :     int16_t *dst = (int16_t *)_dst;
     467             :     int i;
     468    32607820 :     for (i = 0; i < width; i++) {
     469    32513480 :         int d = src[i];
     470             : 
     471    32513480 :         dst[i] = (pal[d] & 0xFF)<<6;
     472             :     }
     473       94340 : }
     474             : 
     475       94340 : static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
     476             :                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
     477             :                       int width, uint32_t *pal)
     478             : {
     479       94340 :     uint16_t *dstU = (uint16_t *)_dstU;
     480       94340 :     int16_t *dstV = (int16_t *)_dstV;
     481             :     int i;
     482             :     av_assert1(src1 == src2);
     483    32607820 :     for (i = 0; i < width; i++) {
     484    32513480 :         int p = pal[src1[i]];
     485             : 
     486    32513480 :         dstU[i] = (uint8_t)(p>> 8)<<6;
     487    32513480 :         dstV[i] = (uint8_t)(p>>16)<<6;
     488             :     }
     489       94340 : }
     490             : 
     491       11926 : static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
     492             : {
     493       11926 :     int16_t *dst = (int16_t *)_dst;
     494             :     int i, j;
     495       11926 :     width = (width + 7) >> 3;
     496      105370 :     for (i = 0; i < width; i++) {
     497       93444 :         int d = ~src[i];
     498      840996 :         for (j = 0; j < 8; j++)
     499      747552 :             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
     500             :     }
     501       11926 :     if(width&7){
     502       11926 :         int d= ~src[i];
     503       82330 :         for (j = 0; j < (width&7); j++)
     504       70404 :             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
     505             :     }
     506       11926 : }
     507             : 
     508         576 : static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
     509             : {
     510         576 :     int16_t *dst = (int16_t *)_dst;
     511             :     int i, j;
     512         576 :     width = (width + 7) >> 3;
     513       25920 :     for (i = 0; i < width; i++) {
     514       25344 :         int d = src[i];
     515      228096 :         for (j = 0; j < 8; j++)
     516      202752 :             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
     517             :     }
     518         576 :     if(width&7){
     519         576 :         int d = src[i];
     520        2880 :         for (j = 0; j < (width&7); j++)
     521        2304 :             dst[8*i+j] = ((d>>(7-j))&1) * 16383;
     522             :     }
     523         576 : }
     524             : 
     525        1408 : static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
     526             :                       uint32_t *unused)
     527             : {
     528             :     int i;
     529      439680 :     for (i = 0; i < width; i++)
     530      438272 :         dst[i] = src[2 * i];
     531        1408 : }
     532             : 
     533         576 : static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
     534             :                        const uint8_t *src2, int width, uint32_t *unused)
     535             : {
     536             :     int i;
     537      101952 :     for (i = 0; i < width; i++) {
     538      101376 :         dstU[i] = src1[4 * i + 1];
     539      101376 :         dstV[i] = src1[4 * i + 3];
     540             :     }
     541             :     av_assert1(src1 == src2);
     542         576 : }
     543             : 
     544         288 : static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
     545             :                        const uint8_t *src2, int width, uint32_t *unused)
     546             : {
     547             :     int i;
     548       50976 :     for (i = 0; i < width; i++) {
     549       50688 :         dstV[i] = src1[4 * i + 1];
     550       50688 :         dstU[i] = src1[4 * i + 3];
     551             :     }
     552             :     av_assert1(src1 == src2);
     553         288 : }
     554             : 
     555       11200 : static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
     556             :                        uint32_t *unused)
     557             : {
     558             :     int i;
     559       11200 :     const uint16_t *src = (const uint16_t *)_src;
     560       11200 :     uint16_t *dst       = (uint16_t *)_dst;
     561     3896256 :     for (i = 0; i < width; i++)
     562     3885056 :         dst[i] = av_bswap16(src[i]);
     563       11200 : }
     564             : 
     565        6048 : static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
     566             :                         const uint8_t *_src2, int width, uint32_t *unused)
     567             : {
     568             :     int i;
     569        6048 :     const uint16_t *src1 = (const uint16_t *)_src1,
     570        6048 :     *src2                = (const uint16_t *)_src2;
     571        6048 :     uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
     572     1526688 :     for (i = 0; i < width; i++) {
     573     1520640 :         dstU[i] = av_bswap16(src1[i]);
     574     1520640 :         dstV[i] = av_bswap16(src2[i]);
     575             :     }
     576        6048 : }
     577             : 
     578           0 : static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
     579             :                                uint32_t *unused)
     580             : {
     581             :     int i;
     582           0 :     for (i = 0; i < width; i++)
     583           0 :         AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
     584           0 : }
     585             : 
     586           0 : static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
     587             :                                 uint32_t *unused)
     588             : {
     589             :     int i;
     590           0 :     for (i = 0; i < width; i++)
     591           0 :         AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
     592           0 : }
     593             : 
     594         256 : static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
     595             :                                uint32_t *unused)
     596             : {
     597             :     int i;
     598       33024 :     for (i = 0; i < width; i++)
     599       32768 :         AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
     600         256 : }
     601             : 
     602           0 : static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
     603             :                                 uint32_t *unused)
     604             : {
     605             :     int i;
     606           0 :     for (i = 0; i < width; i++)
     607           0 :         AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
     608           0 : }
     609             : 
     610         288 : static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
     611             :                                uint32_t *unused2)
     612             : {
     613             :     int i;
     614      101664 :     for (i = 0; i < width; i++)
     615      101376 :         AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
     616         288 : }
     617             : 
     618             : 
     619         288 : static void read_ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
     620             :                                const uint8_t *unused1, int width, uint32_t *unused2)
     621             : {
     622             :     int i;
     623      101664 :     for (i = 0; i < width; i++) {
     624      101376 :         AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 4));
     625      101376 :         AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6));
     626             :     }
     627         288 : }
     628             : 
     629         288 : static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
     630             :                                 uint32_t *unused2)
     631             : {
     632             :     int i;
     633      101664 :     for (i = 0; i < width; i++)
     634      101376 :         AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
     635         288 : }
     636             : 
     637             : /* This is almost identical to the previous, end exists only because
     638             :  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
     639         576 : static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
     640             :                       uint32_t *unused)
     641             : {
     642             :     int i;
     643      203328 :     for (i = 0; i < width; i++)
     644      202752 :         dst[i] = src[2 * i + 1];
     645         576 : }
     646             : 
     647         288 : static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
     648             :                        const uint8_t *src2, int width, uint32_t *unused)
     649             : {
     650             :     int i;
     651       50976 :     for (i = 0; i < width; i++) {
     652       50688 :         dstU[i] = src1[4 * i + 0];
     653       50688 :         dstV[i] = src1[4 * i + 2];
     654             :     }
     655             :     av_assert1(src1 == src2);
     656         288 : }
     657             : 
     658         288 : static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
     659             :                                         const uint8_t *src, int width)
     660             : {
     661             :     int i;
     662       50976 :     for (i = 0; i < width; i++) {
     663       50688 :         dst1[i] = src[2 * i + 0];
     664       50688 :         dst2[i] = src[2 * i + 1];
     665             :     }
     666         288 : }
     667             : 
     668         144 : static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
     669             :                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
     670             :                        int width, uint32_t *unused)
     671             : {
     672         144 :     nvXXtoUV_c(dstU, dstV, src1, width);
     673         144 : }
     674             : 
     675         144 : static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
     676             :                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
     677             :                        int width, uint32_t *unused)
     678             : {
     679         144 :     nvXXtoUV_c(dstV, dstU, src1, width);
     680         144 : }
     681             : 
     682         288 : static void p010LEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
     683             :                         const uint8_t *unused2, int width, uint32_t *unused)
     684             : {
     685             :     int i;
     686      101664 :     for (i = 0; i < width; i++) {
     687      101376 :         AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> 6);
     688             :     }
     689         288 : }
     690             : 
     691         288 : static void p010BEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
     692             :                         const uint8_t *unused2, int width, uint32_t *unused)
     693             : {
     694             :     int i;
     695      101664 :     for (i = 0; i < width; i++) {
     696      101376 :         AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> 6);
     697             :     }
     698         288 : }
     699             : 
     700         144 : static void p010LEToUV_c(uint8_t *dstU, uint8_t *dstV,
     701             :                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
     702             :                        int width, uint32_t *unused)
     703             : {
     704             :     int i;
     705       25488 :     for (i = 0; i < width; i++) {
     706       25344 :         AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> 6);
     707       25344 :         AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> 6);
     708             :     }
     709         144 : }
     710             : 
     711         144 : static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV,
     712             :                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
     713             :                        int width, uint32_t *unused)
     714             : {
     715             :     int i;
     716       25488 :     for (i = 0; i < width; i++) {
     717       25344 :         AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> 6);
     718       25344 :         AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> 6);
     719             :     }
     720         144 : }
     721             : 
     722             : #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
     723             : 
     724      225076 : static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
     725             :                        int width, uint32_t *rgb2yuv)
     726             : {
     727      225076 :     int16_t *dst = (int16_t *)_dst;
     728      225076 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
     729             :     int i;
     730    76748828 :     for (i = 0; i < width; i++) {
     731    76523752 :         int b = src[i * 3 + 0];
     732    76523752 :         int g = src[i * 3 + 1];
     733    76523752 :         int r = src[i * 3 + 2];
     734             : 
     735    76523752 :         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
     736             :     }
     737      225076 : }
     738             : 
     739         576 : static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
     740             :                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
     741             : {
     742         576 :     int16_t *dstU = (int16_t *)_dstU;
     743         576 :     int16_t *dstV = (int16_t *)_dstV;
     744         576 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     745         576 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     746             :     int i;
     747      203328 :     for (i = 0; i < width; i++) {
     748      202752 :         int b = src1[3 * i + 0];
     749      202752 :         int g = src1[3 * i + 1];
     750      202752 :         int r = src1[3 * i + 2];
     751             : 
     752      202752 :         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
     753      202752 :         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
     754             :     }
     755             :     av_assert1(src1 == src2);
     756         576 : }
     757             : 
     758      224500 : static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
     759             :                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
     760             : {
     761      224500 :     int16_t *dstU = (int16_t *)_dstU;
     762      224500 :     int16_t *dstV = (int16_t *)_dstV;
     763             :     int i;
     764      224500 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     765      224500 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     766    38385000 :     for (i = 0; i < width; i++) {
     767    38160500 :         int b = src1[6 * i + 0] + src1[6 * i + 3];
     768    38160500 :         int g = src1[6 * i + 1] + src1[6 * i + 4];
     769    38160500 :         int r = src1[6 * i + 2] + src1[6 * i + 5];
     770             : 
     771    38160500 :         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
     772    38160500 :         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
     773             :     }
     774             :     av_assert1(src1 == src2);
     775      224500 : }
     776             : 
     777      257540 : static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
     778             :                        uint32_t *rgb2yuv)
     779             : {
     780      257540 :     int16_t *dst = (int16_t *)_dst;
     781      257540 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
     782             :     int i;
     783    81084220 :     for (i = 0; i < width; i++) {
     784    80826680 :         int r = src[i * 3 + 0];
     785    80826680 :         int g = src[i * 3 + 1];
     786    80826680 :         int b = src[i * 3 + 2];
     787             : 
     788    80826680 :         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
     789             :     }
     790      257540 : }
     791             : 
     792         976 : static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
     793             :                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
     794             : {
     795         976 :     int16_t *dstU = (int16_t *)_dstU;
     796         976 :     int16_t *dstV = (int16_t *)_dstV;
     797             :     int i;
     798         976 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     799         976 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     800             :     av_assert1(src1 == src2);
     801      256928 :     for (i = 0; i < width; i++) {
     802      255952 :         int r = src1[3 * i + 0];
     803      255952 :         int g = src1[3 * i + 1];
     804      255952 :         int b = src1[3 * i + 2];
     805             : 
     806      255952 :         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
     807      255952 :         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
     808             :     }
     809         976 : }
     810             : 
     811      290164 : static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
     812             :                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
     813             : {
     814      290164 :     int16_t *dstU = (int16_t *)_dstU;
     815      290164 :     int16_t *dstV = (int16_t *)_dstV;
     816             :     int i;
     817      290164 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     818      290164 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     819             :     av_assert1(src1 == src2);
     820    45951528 :     for (i = 0; i < width; i++) {
     821    45661364 :         int r = src1[6 * i + 0] + src1[6 * i + 3];
     822    45661364 :         int g = src1[6 * i + 1] + src1[6 * i + 4];
     823    45661364 :         int b = src1[6 * i + 2] + src1[6 * i + 5];
     824             : 
     825    45661364 :         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
     826    45661364 :         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
     827             :     }
     828      290164 : }
     829             : 
     830         704 : static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
     831             : {
     832         704 :     uint16_t *dst = (uint16_t *)_dst;
     833         704 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
     834             :     int i;
     835      219840 :     for (i = 0; i < width; i++) {
     836      219136 :         int g = src[0][i];
     837      219136 :         int b = src[1][i];
     838      219136 :         int r = src[2][i];
     839             : 
     840      219136 :         dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
     841             :     }
     842         704 : }
     843             : 
     844         288 : static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
     845             : {
     846         288 :     uint16_t *dst = (uint16_t *)_dst;
     847             :     int i;
     848      101664 :     for (i = 0; i < width; i++)
     849      101376 :         dst[i] = src[3][i] << 6;
     850         288 : }
     851             : 
     852         704 : static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
     853             : {
     854         704 :     uint16_t *dstU = (uint16_t *)_dstU;
     855         704 :     uint16_t *dstV = (uint16_t *)_dstV;
     856         704 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     857         704 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     858             :     int i;
     859      219840 :     for (i = 0; i < width; i++) {
     860      219136 :         int g = src[0][i];
     861      219136 :         int b = src[1][i];
     862      219136 :         int r = src[2][i];
     863             : 
     864      219136 :         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
     865      219136 :         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
     866             :     }
     867         704 : }
     868             : 
     869             : #define rdpx(src) \
     870             :     is_be ? AV_RB16(src) : AV_RL16(src)
     871       49764 : static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
     872             :                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
     873             : {
     874             :     int i;
     875       49764 :     const uint16_t **src = (const uint16_t **)_src;
     876       49764 :     uint16_t *dst        = (uint16_t *)_dst;
     877       49764 :     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
     878       49764 :     int shift = bpc < 16 ? bpc : 14;
     879    16968748 :     for (i = 0; i < width; i++) {
     880    16918984 :         int g = rdpx(src[0] + i);
     881    16918984 :         int b = rdpx(src[1] + i);
     882    16918984 :         int r = rdpx(src[2] + i);
     883             : 
     884    16918984 :         dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
     885             :     }
     886       49764 : }
     887             : 
     888        1728 : static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
     889             :                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
     890             : {
     891             :     int i;
     892        1728 :     const uint16_t **src = (const uint16_t **)_src;
     893        1728 :     uint16_t *dst        = (uint16_t *)_dst;
     894        1728 :     int shift = bpc < 16 ? bpc : 14;
     895             : 
     896      609984 :     for (i = 0; i < width; i++) {
     897      608256 :         dst[i] = rdpx(src[3] + i) << (14 - shift);
     898             :     }
     899        1728 : }
     900             : 
     901       27314 : static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
     902             :                                                 const uint8_t *_src[4], int width,
     903             :                                                 int bpc, int is_be, int32_t *rgb2yuv)
     904             : {
     905             :     int i;
     906       27314 :     const uint16_t **src = (const uint16_t **)_src;
     907       27314 :     uint16_t *dstU       = (uint16_t *)_dstU;
     908       27314 :     uint16_t *dstV       = (uint16_t *)_dstV;
     909       27314 :     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
     910       27314 :     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
     911       27314 :     int shift = bpc < 16 ? bpc : 14;
     912     9314198 :     for (i = 0; i < width; i++) {
     913     9286884 :         int g = rdpx(src[0] + i);
     914     9286884 :         int b = rdpx(src[1] + i);
     915     9286884 :         int r = rdpx(src[2] + i);
     916             : 
     917     9286884 :         dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
     918     9286884 :         dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
     919             :     }
     920       27314 : }
     921             : #undef rdpx
     922             : 
     923             : #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
     924             : static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
     925             :                                                   int w, int32_t *rgb2yuv)                          \
     926             : {                                                                                                   \
     927             :     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
     928             : }                                                                                                   \
     929             : static void planar_rgb##nbits##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4],              \
     930             :                                                   int w, int32_t *rgb2yuv)                          \
     931             : {                                                                                                   \
     932             :     planar_rgb16_to_a(dst, src, w, nbits, endian, rgb2yuv);                                         \
     933             : }                                                                                                   \
     934             : static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
     935             :                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
     936             : {                                                                                                   \
     937             :     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
     938             : }                                                                                                   \
     939             : 
     940             : #define rgb9plus_planar_funcs(nbits)            \
     941             :     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
     942             :     rgb9plus_planar_funcs_endian(nbits, be, 1)
     943             : 
     944        1152 : rgb9plus_planar_funcs(9)
     945        2880 : rgb9plus_planar_funcs(10)
     946        2880 : rgb9plus_planar_funcs(12)
     947        1152 : rgb9plus_planar_funcs(14)
     948       70742 : rgb9plus_planar_funcs(16)
     949             : 
     950        2247 : av_cold void ff_sws_init_input_funcs(SwsContext *c)
     951             : {
     952        2247 :     enum AVPixelFormat srcFormat = c->srcFormat;
     953             : 
     954        2247 :     c->chrToYV12 = NULL;
     955        2247 :     switch (srcFormat) {
     956             :     case AV_PIX_FMT_YUYV422:
     957           2 :         c->chrToYV12 = yuy2ToUV_c;
     958           2 :         break;
     959             :     case AV_PIX_FMT_YVYU422:
     960           1 :         c->chrToYV12 = yvy2ToUV_c;
     961           1 :         break;
     962             :     case AV_PIX_FMT_UYVY422:
     963           1 :         c->chrToYV12 = uyvyToUV_c;
     964           1 :         break;
     965             :     case AV_PIX_FMT_NV12:
     966           1 :         c->chrToYV12 = nv12ToUV_c;
     967           1 :         break;
     968             :     case AV_PIX_FMT_NV21:
     969           1 :         c->chrToYV12 = nv21ToUV_c;
     970           1 :         break;
     971             :     case AV_PIX_FMT_RGB8:
     972             :     case AV_PIX_FMT_BGR8:
     973             :     case AV_PIX_FMT_PAL8:
     974             :     case AV_PIX_FMT_BGR4_BYTE:
     975             :     case AV_PIX_FMT_RGB4_BYTE:
     976          13 :         c->chrToYV12 = palToUV_c;
     977          13 :         break;
     978             :     case AV_PIX_FMT_GBRP9LE:
     979           1 :         c->readChrPlanar = planar_rgb9le_to_uv;
     980           1 :         break;
     981             :     case AV_PIX_FMT_GBRAP10LE:
     982             :     case AV_PIX_FMT_GBRP10LE:
     983           2 :         c->readChrPlanar = planar_rgb10le_to_uv;
     984           2 :         break;
     985             :     case AV_PIX_FMT_GBRAP12LE:
     986             :     case AV_PIX_FMT_GBRP12LE:
     987           2 :         c->readChrPlanar = planar_rgb12le_to_uv;
     988           2 :         break;
     989             :     case AV_PIX_FMT_GBRP14LE:
     990           1 :         c->readChrPlanar = planar_rgb14le_to_uv;
     991           1 :         break;
     992             :     case AV_PIX_FMT_GBRAP16LE:
     993             :     case AV_PIX_FMT_GBRP16LE:
     994           6 :         c->readChrPlanar = planar_rgb16le_to_uv;
     995           6 :         break;
     996             :     case AV_PIX_FMT_GBRP9BE:
     997           1 :         c->readChrPlanar = planar_rgb9be_to_uv;
     998           1 :         break;
     999             :     case AV_PIX_FMT_GBRAP10BE:
    1000             :     case AV_PIX_FMT_GBRP10BE:
    1001           2 :         c->readChrPlanar = planar_rgb10be_to_uv;
    1002           2 :         break;
    1003             :     case AV_PIX_FMT_GBRAP12BE:
    1004             :     case AV_PIX_FMT_GBRP12BE:
    1005           2 :         c->readChrPlanar = planar_rgb12be_to_uv;
    1006           2 :         break;
    1007             :     case AV_PIX_FMT_GBRP14BE:
    1008           1 :         c->readChrPlanar = planar_rgb14be_to_uv;
    1009           1 :         break;
    1010             :     case AV_PIX_FMT_GBRAP16BE:
    1011             :     case AV_PIX_FMT_GBRP16BE:
    1012           4 :         c->readChrPlanar = planar_rgb16be_to_uv;
    1013           4 :         break;
    1014             :     case AV_PIX_FMT_GBRAP:
    1015             :     case AV_PIX_FMT_GBRP:
    1016           3 :         c->readChrPlanar = planar_rgb_to_uv;
    1017           3 :         break;
    1018             : #if HAVE_BIGENDIAN
    1019             :     case AV_PIX_FMT_YUV444P9LE:
    1020             :     case AV_PIX_FMT_YUV422P9LE:
    1021             :     case AV_PIX_FMT_YUV420P9LE:
    1022             :     case AV_PIX_FMT_YUV422P10LE:
    1023             :     case AV_PIX_FMT_YUV440P10LE:
    1024             :     case AV_PIX_FMT_YUV444P10LE:
    1025             :     case AV_PIX_FMT_YUV420P10LE:
    1026             :     case AV_PIX_FMT_YUV422P12LE:
    1027             :     case AV_PIX_FMT_YUV440P12LE:
    1028             :     case AV_PIX_FMT_YUV444P12LE:
    1029             :     case AV_PIX_FMT_YUV420P12LE:
    1030             :     case AV_PIX_FMT_YUV422P14LE:
    1031             :     case AV_PIX_FMT_YUV444P14LE:
    1032             :     case AV_PIX_FMT_YUV420P14LE:
    1033             :     case AV_PIX_FMT_YUV420P16LE:
    1034             :     case AV_PIX_FMT_YUV422P16LE:
    1035             :     case AV_PIX_FMT_YUV444P16LE:
    1036             : 
    1037             :     case AV_PIX_FMT_YUVA444P9LE:
    1038             :     case AV_PIX_FMT_YUVA422P9LE:
    1039             :     case AV_PIX_FMT_YUVA420P9LE:
    1040             :     case AV_PIX_FMT_YUVA444P10LE:
    1041             :     case AV_PIX_FMT_YUVA422P10LE:
    1042             :     case AV_PIX_FMT_YUVA420P10LE:
    1043             :     case AV_PIX_FMT_YUVA420P16LE:
    1044             :     case AV_PIX_FMT_YUVA422P16LE:
    1045             :     case AV_PIX_FMT_YUVA444P16LE:
    1046             :         c->chrToYV12 = bswap16UV_c;
    1047             :         break;
    1048             : #else
    1049             :     case AV_PIX_FMT_YUV444P9BE:
    1050             :     case AV_PIX_FMT_YUV422P9BE:
    1051             :     case AV_PIX_FMT_YUV420P9BE:
    1052             :     case AV_PIX_FMT_YUV440P10BE:
    1053             :     case AV_PIX_FMT_YUV444P10BE:
    1054             :     case AV_PIX_FMT_YUV422P10BE:
    1055             :     case AV_PIX_FMT_YUV420P10BE:
    1056             :     case AV_PIX_FMT_YUV440P12BE:
    1057             :     case AV_PIX_FMT_YUV444P12BE:
    1058             :     case AV_PIX_FMT_YUV422P12BE:
    1059             :     case AV_PIX_FMT_YUV420P12BE:
    1060             :     case AV_PIX_FMT_YUV444P14BE:
    1061             :     case AV_PIX_FMT_YUV422P14BE:
    1062             :     case AV_PIX_FMT_YUV420P14BE:
    1063             :     case AV_PIX_FMT_YUV420P16BE:
    1064             :     case AV_PIX_FMT_YUV422P16BE:
    1065             :     case AV_PIX_FMT_YUV444P16BE:
    1066             : 
    1067             :     case AV_PIX_FMT_YUVA444P9BE:
    1068             :     case AV_PIX_FMT_YUVA422P9BE:
    1069             :     case AV_PIX_FMT_YUVA420P9BE:
    1070             :     case AV_PIX_FMT_YUVA444P10BE:
    1071             :     case AV_PIX_FMT_YUVA422P10BE:
    1072             :     case AV_PIX_FMT_YUVA420P10BE:
    1073             :     case AV_PIX_FMT_YUVA420P16BE:
    1074             :     case AV_PIX_FMT_YUVA422P16BE:
    1075             :     case AV_PIX_FMT_YUVA444P16BE:
    1076          26 :         c->chrToYV12 = bswap16UV_c;
    1077          26 :         break;
    1078             : #endif
    1079             :     case AV_PIX_FMT_AYUV64LE:
    1080           1 :         c->chrToYV12 = read_ayuv64le_UV_c;
    1081           1 :         break;
    1082             :     case AV_PIX_FMT_P010LE:
    1083           1 :         c->chrToYV12 = p010LEToUV_c;
    1084           1 :         break;
    1085             :     case AV_PIX_FMT_P010BE:
    1086           1 :         c->chrToYV12 = p010BEToUV_c;
    1087           1 :         break;
    1088             :     }
    1089        2247 :     if (c->chrSrcHSubSample) {
    1090        2067 :         switch (srcFormat) {
    1091             :         case AV_PIX_FMT_RGBA64BE:
    1092           0 :             c->chrToYV12 = rgb64BEToUV_half_c;
    1093           0 :             break;
    1094             :         case AV_PIX_FMT_RGBA64LE:
    1095           0 :             c->chrToYV12 = rgb64LEToUV_half_c;
    1096           0 :             break;
    1097             :         case AV_PIX_FMT_BGRA64BE:
    1098           0 :             c->chrToYV12 = bgr64BEToUV_half_c;
    1099           0 :             break;
    1100             :         case AV_PIX_FMT_BGRA64LE:
    1101           0 :             c->chrToYV12 = bgr64LEToUV_half_c;
    1102           0 :             break;
    1103             :         case AV_PIX_FMT_RGB48BE:
    1104           0 :             c->chrToYV12 = rgb48BEToUV_half_c;
    1105           0 :             break;
    1106             :         case AV_PIX_FMT_RGB48LE:
    1107           4 :             c->chrToYV12 = rgb48LEToUV_half_c;
    1108           4 :             break;
    1109             :         case AV_PIX_FMT_BGR48BE:
    1110           0 :             c->chrToYV12 = bgr48BEToUV_half_c;
    1111           0 :             break;
    1112             :         case AV_PIX_FMT_BGR48LE:
    1113           0 :             c->chrToYV12 = bgr48LEToUV_half_c;
    1114           0 :             break;
    1115             :         case AV_PIX_FMT_RGB32:
    1116          14 :             c->chrToYV12 = bgr32ToUV_half_c;
    1117          14 :             break;
    1118             :         case AV_PIX_FMT_RGB32_1:
    1119           0 :             c->chrToYV12 = bgr321ToUV_half_c;
    1120           0 :             break;
    1121             :         case AV_PIX_FMT_BGR24:
    1122          20 :             c->chrToYV12 = bgr24ToUV_half_c;
    1123          20 :             break;
    1124             :         case AV_PIX_FMT_BGR565LE:
    1125           1 :             c->chrToYV12 = bgr16leToUV_half_c;
    1126           1 :             break;
    1127             :         case AV_PIX_FMT_BGR565BE:
    1128           1 :             c->chrToYV12 = bgr16beToUV_half_c;
    1129           1 :             break;
    1130             :         case AV_PIX_FMT_BGR555LE:
    1131           1 :             c->chrToYV12 = bgr15leToUV_half_c;
    1132           1 :             break;
    1133             :         case AV_PIX_FMT_BGR555BE:
    1134           1 :             c->chrToYV12 = bgr15beToUV_half_c;
    1135           1 :             break;
    1136             :         case AV_PIX_FMT_GBRAP:
    1137             :         case AV_PIX_FMT_GBRP:
    1138           0 :             c->chrToYV12 = gbr24pToUV_half_c;
    1139           0 :             break;
    1140             :         case AV_PIX_FMT_BGR444LE:
    1141           1 :             c->chrToYV12 = bgr12leToUV_half_c;
    1142           1 :             break;
    1143             :         case AV_PIX_FMT_BGR444BE:
    1144           1 :             c->chrToYV12 = bgr12beToUV_half_c;
    1145           1 :             break;
    1146             :         case AV_PIX_FMT_BGR32:
    1147           0 :             c->chrToYV12 = rgb32ToUV_half_c;
    1148           0 :             break;
    1149             :         case AV_PIX_FMT_BGR32_1:
    1150           1 :             c->chrToYV12 = rgb321ToUV_half_c;
    1151           1 :             break;
    1152             :         case AV_PIX_FMT_RGB24:
    1153          29 :             c->chrToYV12 = rgb24ToUV_half_c;
    1154          29 :             break;
    1155             :         case AV_PIX_FMT_RGB565LE:
    1156           5 :             c->chrToYV12 = rgb16leToUV_half_c;
    1157           5 :             break;
    1158             :         case AV_PIX_FMT_RGB565BE:
    1159           1 :             c->chrToYV12 = rgb16beToUV_half_c;
    1160           1 :             break;
    1161             :         case AV_PIX_FMT_RGB555LE:
    1162          12 :             c->chrToYV12 = rgb15leToUV_half_c;
    1163          12 :             break;
    1164             :         case AV_PIX_FMT_RGB555BE:
    1165           1 :             c->chrToYV12 = rgb15beToUV_half_c;
    1166           1 :             break;
    1167             :         case AV_PIX_FMT_RGB444LE:
    1168           1 :             c->chrToYV12 = rgb12leToUV_half_c;
    1169           1 :             break;
    1170             :         case AV_PIX_FMT_RGB444BE:
    1171           1 :             c->chrToYV12 = rgb12beToUV_half_c;
    1172           1 :             break;
    1173             :         }
    1174             :     } else {
    1175         180 :         switch (srcFormat) {
    1176             :         case AV_PIX_FMT_RGBA64BE:
    1177           2 :             c->chrToYV12 = rgb64BEToUV_c;
    1178           2 :             break;
    1179             :         case AV_PIX_FMT_RGBA64LE:
    1180           1 :             c->chrToYV12 = rgb64LEToUV_c;
    1181           1 :             break;
    1182             :         case AV_PIX_FMT_BGRA64BE:
    1183           1 :             c->chrToYV12 = bgr64BEToUV_c;
    1184           1 :             break;
    1185             :         case AV_PIX_FMT_BGRA64LE:
    1186           1 :             c->chrToYV12 = bgr64LEToUV_c;
    1187           1 :             break;
    1188             :         case AV_PIX_FMT_RGB48BE:
    1189           3 :             c->chrToYV12 = rgb48BEToUV_c;
    1190           3 :             break;
    1191             :         case AV_PIX_FMT_RGB48LE:
    1192           4 :             c->chrToYV12 = rgb48LEToUV_c;
    1193           4 :             break;
    1194             :         case AV_PIX_FMT_BGR48BE:
    1195           1 :             c->chrToYV12 = bgr48BEToUV_c;
    1196           1 :             break;
    1197             :         case AV_PIX_FMT_BGR48LE:
    1198           1 :             c->chrToYV12 = bgr48LEToUV_c;
    1199           1 :             break;
    1200             :         case AV_PIX_FMT_RGB32:
    1201          16 :             c->chrToYV12 = bgr32ToUV_c;
    1202          16 :             break;
    1203             :         case AV_PIX_FMT_RGB32_1:
    1204           2 :             c->chrToYV12 = bgr321ToUV_c;
    1205           2 :             break;
    1206             :         case AV_PIX_FMT_BGR24:
    1207           2 :             c->chrToYV12 = bgr24ToUV_c;
    1208           2 :             break;
    1209             :         case AV_PIX_FMT_BGR565LE:
    1210           0 :             c->chrToYV12 = bgr16leToUV_c;
    1211           0 :             break;
    1212             :         case AV_PIX_FMT_BGR565BE:
    1213           0 :             c->chrToYV12 = bgr16beToUV_c;
    1214           0 :             break;
    1215             :         case AV_PIX_FMT_BGR555LE:
    1216           0 :             c->chrToYV12 = bgr15leToUV_c;
    1217           0 :             break;
    1218             :         case AV_PIX_FMT_BGR555BE:
    1219           0 :             c->chrToYV12 = bgr15beToUV_c;
    1220           0 :             break;
    1221             :         case AV_PIX_FMT_BGR444LE:
    1222           0 :             c->chrToYV12 = bgr12leToUV_c;
    1223           0 :             break;
    1224             :         case AV_PIX_FMT_BGR444BE:
    1225           0 :             c->chrToYV12 = bgr12beToUV_c;
    1226           0 :             break;
    1227             :         case AV_PIX_FMT_BGR32:
    1228           2 :             c->chrToYV12 = rgb32ToUV_c;
    1229           2 :             break;
    1230             :         case AV_PIX_FMT_BGR32_1:
    1231           2 :             c->chrToYV12 = rgb321ToUV_c;
    1232           2 :             break;
    1233             :         case AV_PIX_FMT_RGB24:
    1234           5 :             c->chrToYV12 = rgb24ToUV_c;
    1235           5 :             break;
    1236             :         case AV_PIX_FMT_RGB565LE:
    1237           1 :             c->chrToYV12 = rgb16leToUV_c;
    1238           1 :             break;
    1239             :         case AV_PIX_FMT_RGB565BE:
    1240           0 :             c->chrToYV12 = rgb16beToUV_c;
    1241           0 :             break;
    1242             :         case AV_PIX_FMT_RGB555LE:
    1243           1 :             c->chrToYV12 = rgb15leToUV_c;
    1244           1 :             break;
    1245             :         case AV_PIX_FMT_RGB555BE:
    1246           0 :             c->chrToYV12 = rgb15beToUV_c;
    1247           0 :             break;
    1248             :         case AV_PIX_FMT_RGB444LE:
    1249           0 :             c->chrToYV12 = rgb12leToUV_c;
    1250           0 :             break;
    1251             :         case AV_PIX_FMT_RGB444BE:
    1252           0 :             c->chrToYV12 = rgb12beToUV_c;
    1253           0 :             break;
    1254             :         }
    1255             :     }
    1256             : 
    1257        2247 :     c->lumToYV12 = NULL;
    1258        2247 :     c->alpToYV12 = NULL;
    1259        2247 :     switch (srcFormat) {
    1260             :     case AV_PIX_FMT_GBRP9LE:
    1261           1 :         c->readLumPlanar = planar_rgb9le_to_y;
    1262           1 :         break;
    1263             :     case AV_PIX_FMT_GBRAP10LE:
    1264           1 :         c->readAlpPlanar = planar_rgb10le_to_a;
    1265             :     case AV_PIX_FMT_GBRP10LE:
    1266           2 :         c->readLumPlanar = planar_rgb10le_to_y;
    1267           2 :         break;
    1268             :     case AV_PIX_FMT_GBRAP12LE:
    1269           1 :         c->readAlpPlanar = planar_rgb12le_to_a;
    1270             :     case AV_PIX_FMT_GBRP12LE:
    1271           2 :         c->readLumPlanar = planar_rgb12le_to_y;
    1272           2 :         break;
    1273             :     case AV_PIX_FMT_GBRP14LE:
    1274           1 :         c->readLumPlanar = planar_rgb14le_to_y;
    1275           1 :         break;
    1276             :     case AV_PIX_FMT_GBRAP16LE:
    1277           1 :         c->readAlpPlanar = planar_rgb16le_to_a;
    1278             :     case AV_PIX_FMT_GBRP16LE:
    1279           6 :         c->readLumPlanar = planar_rgb16le_to_y;
    1280           6 :         break;
    1281             :     case AV_PIX_FMT_GBRP9BE:
    1282           1 :         c->readLumPlanar = planar_rgb9be_to_y;
    1283           1 :         break;
    1284             :     case AV_PIX_FMT_GBRAP10BE:
    1285           1 :         c->readAlpPlanar = planar_rgb10be_to_a;
    1286             :     case AV_PIX_FMT_GBRP10BE:
    1287           2 :         c->readLumPlanar = planar_rgb10be_to_y;
    1288           2 :         break;
    1289             :     case AV_PIX_FMT_GBRAP12BE:
    1290           1 :         c->readAlpPlanar = planar_rgb12be_to_a;
    1291             :     case AV_PIX_FMT_GBRP12BE:
    1292           2 :         c->readLumPlanar = planar_rgb12be_to_y;
    1293           2 :         break;
    1294             :     case AV_PIX_FMT_GBRP14BE:
    1295           1 :         c->readLumPlanar = planar_rgb14be_to_y;
    1296           1 :         break;
    1297             :     case AV_PIX_FMT_GBRAP16BE:
    1298           2 :         c->readAlpPlanar = planar_rgb16be_to_a;
    1299             :     case AV_PIX_FMT_GBRP16BE:
    1300           4 :         c->readLumPlanar = planar_rgb16be_to_y;
    1301           4 :         break;
    1302             :     case AV_PIX_FMT_GBRAP:
    1303           2 :         c->readAlpPlanar = planar_rgb_to_a;
    1304             :     case AV_PIX_FMT_GBRP:
    1305           3 :         c->readLumPlanar = planar_rgb_to_y;
    1306           3 :         break;
    1307             : #if HAVE_BIGENDIAN
    1308             :     case AV_PIX_FMT_YUV444P9LE:
    1309             :     case AV_PIX_FMT_YUV422P9LE:
    1310             :     case AV_PIX_FMT_YUV420P9LE:
    1311             :     case AV_PIX_FMT_YUV444P10LE:
    1312             :     case AV_PIX_FMT_YUV440P10LE:
    1313             :     case AV_PIX_FMT_YUV422P10LE:
    1314             :     case AV_PIX_FMT_YUV420P10LE:
    1315             :     case AV_PIX_FMT_YUV444P12LE:
    1316             :     case AV_PIX_FMT_YUV440P12LE:
    1317             :     case AV_PIX_FMT_YUV422P12LE:
    1318             :     case AV_PIX_FMT_YUV420P12LE:
    1319             :     case AV_PIX_FMT_YUV444P14LE:
    1320             :     case AV_PIX_FMT_YUV422P14LE:
    1321             :     case AV_PIX_FMT_YUV420P14LE:
    1322             :     case AV_PIX_FMT_YUV420P16LE:
    1323             :     case AV_PIX_FMT_YUV422P16LE:
    1324             :     case AV_PIX_FMT_YUV444P16LE:
    1325             : 
    1326             :     case AV_PIX_FMT_GRAY10LE:
    1327             :     case AV_PIX_FMT_GRAY12LE:
    1328             :     case AV_PIX_FMT_GRAY16LE:
    1329             :         c->lumToYV12 = bswap16Y_c;
    1330             :         break;
    1331             :     case AV_PIX_FMT_YUVA444P9LE:
    1332             :     case AV_PIX_FMT_YUVA422P9LE:
    1333             :     case AV_PIX_FMT_YUVA420P9LE:
    1334             :     case AV_PIX_FMT_YUVA444P10LE:
    1335             :     case AV_PIX_FMT_YUVA422P10LE:
    1336             :     case AV_PIX_FMT_YUVA420P10LE:
    1337             :     case AV_PIX_FMT_YUVA420P16LE:
    1338             :     case AV_PIX_FMT_YUVA422P16LE:
    1339             :     case AV_PIX_FMT_YUVA444P16LE:
    1340             :         c->lumToYV12 = bswap16Y_c;
    1341             :         c->alpToYV12 = bswap16Y_c;
    1342             :         break;
    1343             : #else
    1344             :     case AV_PIX_FMT_YUV444P9BE:
    1345             :     case AV_PIX_FMT_YUV422P9BE:
    1346             :     case AV_PIX_FMT_YUV420P9BE:
    1347             :     case AV_PIX_FMT_YUV444P10BE:
    1348             :     case AV_PIX_FMT_YUV440P10BE:
    1349             :     case AV_PIX_FMT_YUV422P10BE:
    1350             :     case AV_PIX_FMT_YUV420P10BE:
    1351             :     case AV_PIX_FMT_YUV444P12BE:
    1352             :     case AV_PIX_FMT_YUV440P12BE:
    1353             :     case AV_PIX_FMT_YUV422P12BE:
    1354             :     case AV_PIX_FMT_YUV420P12BE:
    1355             :     case AV_PIX_FMT_YUV444P14BE:
    1356             :     case AV_PIX_FMT_YUV422P14BE:
    1357             :     case AV_PIX_FMT_YUV420P14BE:
    1358             :     case AV_PIX_FMT_YUV420P16BE:
    1359             :     case AV_PIX_FMT_YUV422P16BE:
    1360             :     case AV_PIX_FMT_YUV444P16BE:
    1361             : 
    1362             :     case AV_PIX_FMT_GRAY10BE:
    1363             :     case AV_PIX_FMT_GRAY12BE:
    1364             :     case AV_PIX_FMT_GRAY16BE:
    1365          22 :         c->lumToYV12 = bswap16Y_c;
    1366          22 :         break;
    1367             :     case AV_PIX_FMT_YUVA444P9BE:
    1368             :     case AV_PIX_FMT_YUVA422P9BE:
    1369             :     case AV_PIX_FMT_YUVA420P9BE:
    1370             :     case AV_PIX_FMT_YUVA444P10BE:
    1371             :     case AV_PIX_FMT_YUVA422P10BE:
    1372             :     case AV_PIX_FMT_YUVA420P10BE:
    1373             :     case AV_PIX_FMT_YUVA420P16BE:
    1374             :     case AV_PIX_FMT_YUVA422P16BE:
    1375             :     case AV_PIX_FMT_YUVA444P16BE:
    1376           9 :         c->lumToYV12 = bswap16Y_c;
    1377           9 :         c->alpToYV12 = bswap16Y_c;
    1378           9 :         break;
    1379             : #endif
    1380             :     case AV_PIX_FMT_YA16LE:
    1381           0 :         c->lumToYV12 = read_ya16le_gray_c;
    1382           0 :         break;
    1383             :     case AV_PIX_FMT_YA16BE:
    1384           2 :         c->lumToYV12 = read_ya16be_gray_c;
    1385           2 :         break;
    1386             :     case AV_PIX_FMT_AYUV64LE:
    1387           1 :         c->lumToYV12 = read_ayuv64le_Y_c;
    1388           1 :         break;
    1389             :     case AV_PIX_FMT_YUYV422:
    1390             :     case AV_PIX_FMT_YVYU422:
    1391             :     case AV_PIX_FMT_YA8:
    1392           6 :         c->lumToYV12 = yuy2ToY_c;
    1393           6 :         break;
    1394             :     case AV_PIX_FMT_UYVY422:
    1395           1 :         c->lumToYV12 = uyvyToY_c;
    1396           1 :         break;
    1397             :     case AV_PIX_FMT_BGR24:
    1398          22 :         c->lumToYV12 = bgr24ToY_c;
    1399          22 :         break;
    1400             :     case AV_PIX_FMT_BGR565LE:
    1401           1 :         c->lumToYV12 = bgr16leToY_c;
    1402           1 :         break;
    1403             :     case AV_PIX_FMT_BGR565BE:
    1404           1 :         c->lumToYV12 = bgr16beToY_c;
    1405           1 :         break;
    1406             :     case AV_PIX_FMT_BGR555LE:
    1407           1 :         c->lumToYV12 = bgr15leToY_c;
    1408           1 :         break;
    1409             :     case AV_PIX_FMT_BGR555BE:
    1410           1 :         c->lumToYV12 = bgr15beToY_c;
    1411           1 :         break;
    1412             :     case AV_PIX_FMT_BGR444LE:
    1413           1 :         c->lumToYV12 = bgr12leToY_c;
    1414           1 :         break;
    1415             :     case AV_PIX_FMT_BGR444BE:
    1416           1 :         c->lumToYV12 = bgr12beToY_c;
    1417           1 :         break;
    1418             :     case AV_PIX_FMT_RGB24:
    1419          34 :         c->lumToYV12 = rgb24ToY_c;
    1420          34 :         break;
    1421             :     case AV_PIX_FMT_RGB565LE:
    1422           6 :         c->lumToYV12 = rgb16leToY_c;
    1423           6 :         break;
    1424             :     case AV_PIX_FMT_RGB565BE:
    1425           1 :         c->lumToYV12 = rgb16beToY_c;
    1426           1 :         break;
    1427             :     case AV_PIX_FMT_RGB555LE:
    1428          13 :         c->lumToYV12 = rgb15leToY_c;
    1429          13 :         break;
    1430             :     case AV_PIX_FMT_RGB555BE:
    1431           1 :         c->lumToYV12 = rgb15beToY_c;
    1432           1 :         break;
    1433             :     case AV_PIX_FMT_RGB444LE:
    1434           1 :         c->lumToYV12 = rgb12leToY_c;
    1435           1 :         break;
    1436             :     case AV_PIX_FMT_RGB444BE:
    1437           1 :         c->lumToYV12 = rgb12beToY_c;
    1438           1 :         break;
    1439             :     case AV_PIX_FMT_RGB8:
    1440             :     case AV_PIX_FMT_BGR8:
    1441             :     case AV_PIX_FMT_PAL8:
    1442             :     case AV_PIX_FMT_BGR4_BYTE:
    1443             :     case AV_PIX_FMT_RGB4_BYTE:
    1444          13 :         c->lumToYV12 = palToY_c;
    1445          13 :         break;
    1446             :     case AV_PIX_FMT_MONOBLACK:
    1447           2 :         c->lumToYV12 = monoblack2Y_c;
    1448           2 :         break;
    1449             :     case AV_PIX_FMT_MONOWHITE:
    1450           6 :         c->lumToYV12 = monowhite2Y_c;
    1451           6 :         break;
    1452             :     case AV_PIX_FMT_RGB32:
    1453          30 :         c->lumToYV12 = bgr32ToY_c;
    1454          30 :         break;
    1455             :     case AV_PIX_FMT_RGB32_1:
    1456           2 :         c->lumToYV12 = bgr321ToY_c;
    1457           2 :         break;
    1458             :     case AV_PIX_FMT_BGR32:
    1459           2 :         c->lumToYV12 = rgb32ToY_c;
    1460           2 :         break;
    1461             :     case AV_PIX_FMT_BGR32_1:
    1462           3 :         c->lumToYV12 = rgb321ToY_c;
    1463           3 :         break;
    1464             :     case AV_PIX_FMT_RGB48BE:
    1465           3 :         c->lumToYV12 = rgb48BEToY_c;
    1466           3 :         break;
    1467             :     case AV_PIX_FMT_RGB48LE:
    1468           8 :         c->lumToYV12 = rgb48LEToY_c;
    1469           8 :         break;
    1470             :     case AV_PIX_FMT_BGR48BE:
    1471           1 :         c->lumToYV12 = bgr48BEToY_c;
    1472           1 :         break;
    1473             :     case AV_PIX_FMT_BGR48LE:
    1474           1 :         c->lumToYV12 = bgr48LEToY_c;
    1475           1 :         break;
    1476             :     case AV_PIX_FMT_RGBA64BE:
    1477           2 :         c->lumToYV12 = rgb64BEToY_c;
    1478           2 :         break;
    1479             :     case AV_PIX_FMT_RGBA64LE:
    1480           1 :         c->lumToYV12 = rgb64LEToY_c;
    1481           1 :         break;
    1482             :     case AV_PIX_FMT_BGRA64BE:
    1483           1 :         c->lumToYV12 = bgr64BEToY_c;
    1484           1 :         break;
    1485             :     case AV_PIX_FMT_BGRA64LE:
    1486           1 :         c->lumToYV12 = bgr64LEToY_c;
    1487           1 :         break;
    1488             :     case AV_PIX_FMT_P010LE:
    1489           1 :         c->lumToYV12 = p010LEToY_c;
    1490           1 :         break;
    1491             :     case AV_PIX_FMT_P010BE:
    1492           1 :         c->lumToYV12 = p010BEToY_c;
    1493           1 :         break;
    1494             :     }
    1495        2247 :     if (c->needAlpha) {
    1496          51 :         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
    1497          29 :             if (HAVE_BIGENDIAN == !isBE(srcFormat) && !c->readAlpPlanar)
    1498          11 :                 c->alpToYV12 = bswap16Y_c;
    1499             :         }
    1500          51 :         switch (srcFormat) {
    1501             :         case AV_PIX_FMT_BGRA64LE:
    1502           2 :         case AV_PIX_FMT_RGBA64LE:  c->alpToYV12 = rgba64leToA_c; break;
    1503             :         case AV_PIX_FMT_BGRA64BE:
    1504           2 :         case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64beToA_c; break;
    1505             :         case AV_PIX_FMT_BGRA:
    1506             :         case AV_PIX_FMT_RGBA:
    1507          12 :             c->alpToYV12 = rgbaToA_c;
    1508          12 :             break;
    1509             :         case AV_PIX_FMT_ABGR:
    1510             :         case AV_PIX_FMT_ARGB:
    1511           5 :             c->alpToYV12 = abgrToA_c;
    1512           5 :             break;
    1513             :         case AV_PIX_FMT_YA8:
    1514           1 :             c->alpToYV12 = uyvyToY_c;
    1515           1 :             break;
    1516             :         case AV_PIX_FMT_YA16LE:
    1517           0 :             c->alpToYV12 = read_ya16le_alpha_c;
    1518           0 :             break;
    1519             :         case AV_PIX_FMT_YA16BE:
    1520           0 :             c->alpToYV12 = read_ya16be_alpha_c;
    1521           0 :             break;
    1522             :         case AV_PIX_FMT_AYUV64LE:
    1523           1 :             c->alpToYV12 = read_ayuv64le_A_c;
    1524           1 :             break;
    1525             :         case AV_PIX_FMT_PAL8 :
    1526           0 :             c->alpToYV12 = palToA_c;
    1527           0 :             break;
    1528             :         }
    1529             :     }
    1530        2247 : }

Generated by: LCOV version 1.12