modules/arm_neon/yuv_rgb.c

   1 /*****************************************************************************
   2  * yuv_rgb.c : ARM NEONv1 YUV to RGB32 chroma conversion for VLC
   3  *****************************************************************************
   4  * Copyright (C) 2011 Sébastien Toque
   5  *                    Rémi Denis-Courmont
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU Lesser General Public License as published by
   9  * the Free Software Foundation; either version 2.1 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  20  *****************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include <vlc_common.h>
  27 #include <vlc_plugin.h>
  28 #include <vlc_filter.h>
  29 #include <vlc_cpu.h>
  30 #include "arm_neon/chroma_neon.h"
  31
  32 static int Open (vlc_object_t *);
  33
  34 vlc_module_begin ()
  35     set_description (N_("ARM NEON video chroma YUV->RGBA"))
  36     set_capability ("video filter2", 250)
  37     set_callbacks (Open, NULL)
  38 vlc_module_end ()
  39
  40 /*
  41 static int CoefY[256];
  42 static int CoefRV[256];
  43 static int CoefGU[256];
  44 static int CoefGV[256];
  45 static int CoefBU[256];
  46
  47 // C reference version of the converter
  48 static void I420_RGBA_C (filter_t *filter, picture_t *src, picture_t *dst)
  49 {
  50     const uint8_t *const out = dst->p->p_pixels;
  51     const size_t width = src->p[Y_PLANE].i_visible_pitch;
  52     const size_t height = src->p[Y_PLANE].i_visible_lines;
  53
  54     const int ypitch = src->p[Y_PLANE].i_pitch;
  55     const int uvpitch = src->p[U_PLANE].i_pitch;
  56     const int dpitch = dst->p->i_pitch / dst->p->i_pixel_pitch;
  57
  58     for (size_t j = 0; j <  height; ++j)
  59     {
  60         const int y = j * ypitch;
  61         const int u = (j>>1) * uvpitch;
  62         const int d = j * dpitch;
  63
  64         for (size_t i = 0; i < width; ++i)
  65         {
  66             uint8_t Y = src->Y_PIXELS[y + i];
  67             uint8_t U = src->U_PIXELS[u + (i>>1)];
  68             uint8_t V = src->V_PIXELS[u + (i>>1)];
  69
  70             //coef = float * Precision + .5 (Precision=32768)
  71             int R = CoefY[Y] + CoefRV[V];
  72             int G = CoefY[Y] + CoefGU[U] + CoefGV[V];
  73             int B = CoefY[Y] + CoefBU[U];
  74
  75             //rgb = (rgb+Precision/2) / Precision (Precision=32768)
  76             R = R >> 15;
  77             G = G >> 15;
  78             B = B >> 15;
  79
  80             if (unlikely(R < 0)) R = 0;
  81             if (unlikely(G < 0)) G = 0;
  82             if (unlikely(B < 0)) B = 0;
  83             if (unlikely(R > 255)) R = 255;
  84             if (unlikely(G > 255)) G = 255;
  85             if (unlikely(B > 255)) B = 255;
  86
  87             ((uint32_t*)out)[d + i] = R | (G<<8) | (B<<16) | (0xff<<24);
  88         }
  89     }
  90 }*/
  91
  92 static void I420_RGBA (filter_t *filter, picture_t *src, picture_t *dst)
  93 {
  94     struct yuv_pack out = { dst->p->p_pixels, dst->p->i_pitch };
  95     struct yuv_planes in = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS, src->Y_PITCH };
  96     i420_rgb_neon (&out, &in, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height);
  97 }
  98
  99 static void I420_RV16 (filter_t *filter, picture_t *src, picture_t *dst)
 100 {
 101     struct yuv_pack out = { dst->p->p_pixels, dst->p->i_pitch };
 102     struct yuv_planes in = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS, src->Y_PITCH };
 103     i420_rv16_neon (&out, &in, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height);
 104 }
 105
 106 static void YV12_RGBA (filter_t *filter, picture_t *src, picture_t *dst)
 107 {
 108     struct yuv_pack out = { dst->p->p_pixels, dst->p->i_pitch };
 109     struct yuv_planes in = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS, src->Y_PITCH };
 110     i420_rgb_neon (&out, &in, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height);
 111 }
 112
 113 static void NV21_RGBA (filter_t *filter, picture_t *src, picture_t *dst)
 114 {
 115     struct yuv_pack out = { dst->p->p_pixels, dst->p->i_pitch };
 116     struct yuv_planes in = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS, src->Y_PITCH };
 117     nv21_rgb_neon (&out, &in, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height);
 118 }
 119
 120 static void NV12_RGBA (filter_t *filter, picture_t *src, picture_t *dst)
 121 {
 122     struct yuv_pack out = { dst->p->p_pixels, dst->p->i_pitch };
 123     struct yuv_planes in = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS, src->Y_PITCH };
 124     nv12_rgb_neon (&out, &in, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height);
 125 }
 126
 127 VIDEO_FILTER_WRAPPER (I420_RGBA)
 128 VIDEO_FILTER_WRAPPER (I420_RV16)
 129 VIDEO_FILTER_WRAPPER (YV12_RGBA)
 130 VIDEO_FILTER_WRAPPER (NV21_RGBA)
 131 VIDEO_FILTER_WRAPPER (NV12_RGBA)
 132
 133 static int Open (vlc_object_t *obj)
 134 {
 135     filter_t *filter = (filter_t *)obj;
 136
 137     if (!vlc_CPU_ARM_NEON())
 138         return VLC_EGENERIC;
 139
 140     if (((filter->fmt_in.video.i_width | filter->fmt_in.video.i_height) & 1)
 141      || (filter->fmt_in.video.i_width != filter->fmt_out.video.i_width)
 142      || (filter->fmt_in.video.i_height != filter->fmt_out.video.i_height))
 143         return VLC_EGENERIC;
 144
 145     switch (filter->fmt_out.video.i_chroma)
 146     {
 147         case VLC_CODEC_RGB16:
 148             switch (filter->fmt_in.video.i_chroma)
 149             {
 150                 case VLC_CODEC_I420:
 151                     filter->pf_video_filter = I420_RV16_Filter;
 152                     break;
 153                 default:
 154                     return VLC_EGENERIC;
 155             }
 156             break;
 157
 158         case VLC_CODEC_RGB32:
 159             if(        filter->fmt_out.video.i_rmask != 0x000000ff
 160                     || filter->fmt_out.video.i_gmask != 0x0000ff00
 161                     || filter->fmt_out.video.i_bmask != 0x00ff0000 )
 162                 return VLC_EGENERIC;
 163
 164             switch (filter->fmt_in.video.i_chroma)
 165             {
 166                 case VLC_CODEC_I420:
 167                     filter->pf_video_filter = I420_RGBA_Filter;
 168                     break;
 169                 case VLC_CODEC_YV12:
 170                     filter->pf_video_filter = YV12_RGBA_Filter;
 171                     break;
 172                 case VLC_CODEC_NV21:
 173                     filter->pf_video_filter = NV21_RGBA_Filter;
 174                     break;
 175                 case VLC_CODEC_NV12:
 176                     filter->pf_video_filter = NV12_RGBA_Filter;
 177                     break;
 178                 default:
 179                     return VLC_EGENERIC;
 180             }
 181             break;
 182
 183         default:
 184             return VLC_EGENERIC;
 185     }
 186
 187     //precompute some values for the C version
 188     /*const int coefY  = (int)(1.164 * 32768 + 0.5);
 189     const int coefRV = (int)(1.793 * 32768 + 0.5);
 190     const int coefGU = (int)(0.213 * 32768 + 0.5);
 191     const int coefGV = (int)(0.533 * 32768 + 0.5);
 192     const int coefBU = (int)(2.113 * 32768 + 0.5);
 193     for (int i=0; i<256; ++i)
 194     {
 195         CoefY[i] = coefY * (i-16) + 16384;
 196         CoefRV[i] = coefRV*(i-128);
 197         CoefGU[i] = -coefGU*(i-128);
 198         CoefGV[i] = -coefGV*(i-128);
 199         CoefBU[i] = coefBU*(i-128);
 200     }*/
 201
 202     msg_Dbg(filter, "%4.4s(%dx%d) to %4.4s(%dx%d)",
 203             (char*)&filter->fmt_in.video.i_chroma, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height,
 204             (char*)&filter->fmt_out.video.i_chroma, filter->fmt_out.video.i_visible_width, filter->fmt_out.video.i_visible_height);
 205
 206     return VLC_SUCCESS;
 207 }