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_picture.h>
  30 #include <vlc_cpu.h>
  31 #include "arm_neon/chroma_neon.h"
  32
  33 static int Open (filter_t *);
  34
  35 vlc_module_begin ()
  36     set_description (N_("ARM NEON video chroma YUV->RGBA"))
  37     set_callback_video_converter(Open, 250)
  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 (filter_t *filter)
 134 {
 135     if (!vlc_CPU_ARM_NEON())
 136         return VLC_EGENERIC;
 137
 138     if (((filter->fmt_in.video.i_width | filter->fmt_in.video.i_height) & 1)
 139      || (filter->fmt_in.video.i_width != filter->fmt_out.video.i_width)
 140      || (filter->fmt_in.video.i_height != filter->fmt_out.video.i_height)
 141      || (filter->fmt_in.video.orientation != filter->fmt_out.video.orientation))
 142         return VLC_EGENERIC;
 143
 144     switch (filter->fmt_out.video.i_chroma)
 145     {
 146         case VLC_CODEC_RGB16:
 147             switch (filter->fmt_in.video.i_chroma)
 148             {
 149                 case VLC_CODEC_I420:
 150                     filter->ops = &I420_RV16_ops;
 151                     break;
 152                 default:
 153                     return VLC_EGENERIC;
 154             }
 155             break;
 156
 157         case VLC_CODEC_RGB32:
 158             if(        filter->fmt_out.video.i_rmask != 0x000000ff
 159                     || filter->fmt_out.video.i_gmask != 0x0000ff00
 160                     || filter->fmt_out.video.i_bmask != 0x00ff0000 )
 161                 return VLC_EGENERIC;
 162
 163             switch (filter->fmt_in.video.i_chroma)
 164             {
 165                 case VLC_CODEC_I420:
 166                     filter->ops = &I420_RGBA_ops;
 167                     break;
 168                 case VLC_CODEC_YV12:
 169                     filter->ops = &YV12_RGBA_ops;
 170                     break;
 171                 case VLC_CODEC_NV21:
 172                     filter->ops = &NV21_RGBA_ops;
 173                     break;
 174                 case VLC_CODEC_NV12:
 175                     filter->ops = &NV12_RGBA_ops;
 176                     break;
 177                 default:
 178                     return VLC_EGENERIC;
 179             }
 180             break;
 181
 182         default:
 183             return VLC_EGENERIC;
 184     }
 185
 186     //precompute some values for the C version
 187     /*const int coefY  = (int)(1.164 * 32768 + 0.5);
 188     const int coefRV = (int)(1.793 * 32768 + 0.5);
 189     const int coefGU = (int)(0.213 * 32768 + 0.5);
 190     const int coefGV = (int)(0.533 * 32768 + 0.5);
 191     const int coefBU = (int)(2.113 * 32768 + 0.5);
 192     for (int i=0; i<256; ++i)
 193     {
 194         CoefY[i] = coefY * (i-16) + 16384;
 195         CoefRV[i] = coefRV*(i-128);
 196         CoefGU[i] = -coefGU*(i-128);
 197         CoefGV[i] = -coefGV*(i-128);
 198         CoefBU[i] = coefBU*(i-128);
 199     }*/
 200
 201     msg_Dbg(filter, "%4.4s(%dx%d) to %4.4s(%dx%d)",
 202             (char*)&filter->fmt_in.video.i_chroma, filter->fmt_in.video.i_visible_width, filter->fmt_in.video.i_visible_height,
 203             (char*)&filter->fmt_out.video.i_chroma, filter->fmt_out.video.i_visible_width, filter->fmt_out.video.i_visible_height);
 204
 205     return VLC_SUCCESS;
 206 }