git.sesse.net Git - vlc/blob - modules/video_chroma/omxdl.c

   1 /*****************************************************************************
   2  * omxdl.c : OpenMAX DL chroma conversions for VLC
   3  *****************************************************************************
   4  * Copyright (C) 2011 Rémi Denis-Courmont
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program 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
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include <vlc_common.h>
  26 #include <vlc_plugin.h>
  27 #include <vlc_filter.h>
  28 #include <omxtypes.h>
  29 #include <omxIP.h>
  30
  31 static int Open (vlc_object_t *);
  32 static int OpenScaler (vlc_object_t *);
  33
  34 vlc_module_begin ()
  35     set_description (N_("OpenMAX DL image processing"))
  36     set_capability ("video filter2", 90)
  37     set_callbacks (Open, NULL)
  38 vlc_module_end ()
  39
  40 #define SRC_WIDTH  (filter->fmt_in.video.i_width)
  41 #define SRC_HEIGHT (filter->fmt_in.video.i_height)
  42 #define DST_WIDTH  (filter->fmt_out.video.i_width)
  43 #define DST_HEIGHT (filter->fmt_out.video.i_height)
  44
  45 /*** Conversions from I420 ***/
  46 static void I420_RV16 (filter_t *filter, picture_t *src, picture_t *dst)
  47 {
  48     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
  49     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
  50     OMX_U16 *out = (void *)dst->p->p_pixels;
  51     OMX_INT outstep = dst->p->i_pitch;
  52     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
  53
  54     omxIPCS_YCbCr420ToBGR565_U8_U16_P3C3R (in, instep, out, outstep, size);
  55 }
  56 VIDEO_FILTER_WRAPPER (I420_RV16)
  57
  58 /*** Conversions from YV12 ***/
  59 static void YV12_RV16 (filter_t *filter, picture_t *src, picture_t *dst)
  60 {
  61     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
  62     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
  63     OMX_U16 *out = (void *)dst->p->p_pixels;
  64     OMX_INT outstep = dst->p->i_pitch;
  65     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
  66
  67     omxIPCS_YCbCr420ToBGR565_U8_U16_P3C3R (in, instep, out, outstep, size);
  68 }
  69 VIDEO_FILTER_WRAPPER (YV12_RV16)
  70
  71 /*** Conversions from I422 ***/
  72 static void I422_I420 (filter_t *filter, picture_t *src, picture_t *dst)
  73 {
  74     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
  75     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
  76     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
  77     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
  78     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
  79
  80     omxIPCS_YCbCr422ToYCbCr420Rotate_U8_P3R (
  81         in, instep, out, outstep, size, OMX_IP_DISABLE);
  82 }
  83 VIDEO_FILTER_WRAPPER (I422_I420)
  84
  85 static void I422_YV12 (filter_t *filter, picture_t *src, picture_t *dst)
  86 {
  87     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
  88     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
  89     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
  90     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
  91     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
  92
  93     omxIPCS_YCbCr422ToYCbCr420Rotate_U8_P3R (
  94         in, instep, out, outstep, size, OMX_IP_DISABLE);
  95 }
  96 VIDEO_FILTER_WRAPPER (I422_YV12)
  97
  98 /*** Conversions from I444 ***/
  99 static void I444_RV16 (filter_t *filter, picture_t *src, picture_t *dst)
 100 {
 101     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 102     OMX_INT instep = src->p->i_pitch;
 103     OMX_U16 *out = (void *)dst->p->p_pixels;
 104     OMX_INT outstep = dst->p->i_pitch;
 105     OMXSize size = {
 106         filter->fmt_in.video.i_width,
 107         filter->fmt_in.video.i_height,
 108     };
 109
 110     omxIPCS_YCbCr444ToBGR565_U8_U16_P3C3R (in, instep, out, outstep, size);
 111 }
 112 VIDEO_FILTER_WRAPPER (I444_RV16)
 113
 114 /*** Conversions from YUY2 ***/
 115 static void YUYV_RV24 (filter_t *filter, picture_t *src, picture_t *dst)
 116 {
 117     const OMX_U8 *in = src->p->p_pixels;
 118     OMX_INT instep = src->p->i_pitch;
 119     OMX_U8 *out = dst->p->p_pixels;
 120     OMX_INT outstep = dst->p->i_pitch;
 121     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
 122
 123     omxIPCS_YCbYCr422ToBGR888_U8_C2C3R (in, instep, out, outstep, size);
 124 }
 125 VIDEO_FILTER_WRAPPER (YUYV_RV24)
 126
 127 static void YUYV_RV16 (filter_t *filter, picture_t *src, picture_t *dst)
 128 {
 129     const OMX_U8 *in = src->p->p_pixels;
 130     OMX_INT instep = src->p->i_pitch;
 131     OMX_U16 *out = (void *)dst->p->p_pixels;
 132     OMX_INT outstep = dst->p->i_pitch;
 133     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
 134
 135     omxIPCS_YCbYCr422ToBGR565_U8_U16_C2C3R (in, instep, out, outstep, size);
 136 }
 137 VIDEO_FILTER_WRAPPER (YUYV_RV16)
 138
 139 /*** Conversions from UYVY ***/
 140 static void UYVY_I420 (filter_t *filter, picture_t *src, picture_t *dst)
 141 {
 142     const OMX_U8 *in = src->p->p_pixels;
 143     OMX_INT instep = src->p->i_pitch;
 144     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 145     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 146     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
 147
 148     omxIPCS_CbYCrY422ToYCbCr420Rotate_U8_C2P3R (
 149         in, instep, out, outstep, size, OMX_IP_DISABLE);
 150 }
 151 VIDEO_FILTER_WRAPPER (UYVY_I420)
 152
 153 static void UYVY_YV12 (filter_t *filter, picture_t *src, picture_t *dst)
 154 {
 155     const OMX_U8 *in = src->p->p_pixels;
 156     OMX_INT instep = src->p->i_pitch;
 157     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
 158     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
 159     OMXSize size = { SRC_WIDTH, SRC_HEIGHT };
 160
 161     omxIPCS_CbYCrY422ToYCbCr420Rotate_U8_C2P3R (
 162         in, instep, out, outstep, size, OMX_IP_DISABLE);
 163 }
 164 VIDEO_FILTER_WRAPPER (UYVY_YV12)
 165
 166 /*** Helpers ***/
 167 static int FixRV24 (video_format_t *fmt)
 168 {
 169 #ifndef WORDS_BIGENDIAN
 170     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 171     {
 172         fmt->i_rmask = 0xff0000;
 173         fmt->i_gmask = 0x00ff00;
 174         fmt->i_bmask = 0x0000ff;
 175     }
 176     return (fmt->i_rmask == 0xff0000 && fmt->i_gmask == 0x00ff00
 177          && fmt->i_bmask == 0x0000ff) ? 0 : -1;
 178 #else
 179     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 180     {
 181         fmt->i_rmask = 0x0000ff;
 182         fmt->i_gmask = 0x00ff00;
 183         fmt->i_bmask = 0xff0000;
 184     }
 185     return (fmt->i_rmask == 0x0000ff && fmt->i_gmask == 0x00ff00
 186          && fmt->i_bmask == 0xff0000) ? 0 : -1;
 187 #endif
 188 }
 189
 190 static int FixRV16 (video_format_t *fmt)
 191 {
 192 #ifndef WORDS_BIGENDIAN
 193     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 194     {
 195         fmt->i_rmask = 0xf800;
 196         fmt->i_gmask = 0x07e0;
 197         fmt->i_bmask = 0x001f;
 198     }
 199     return (fmt->i_rmask == 0xf800 && fmt->i_gmask == 0x07e0
 200          && fmt->i_bmask == 0x001f) ? 0 : -1;
 201 #else
 202     (void) fmt;
 203     return -1;
 204 #endif
 205 }
 206
 207 static int FixRV15 (video_format_t *fmt)
 208 {
 209 #ifndef WORDS_BIGENDIAN
 210     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 211     {
 212         fmt->i_rmask = 0x7c00;
 213         fmt->i_gmask = 0x03e0;
 214         fmt->i_bmask = 0x001f;
 215     }
 216     return (fmt->i_rmask == 0x7c00 && fmt->i_gmask == 0x03e0
 217          && fmt->i_bmask == 0x001f) ? 0 : -1;
 218 #else
 219     (void) fmt;
 220     return -1;
 221 #endif
 222 }
 223
 224 static int FixRV12 (video_format_t *fmt)
 225 {
 226 #ifndef WORDS_BIGENDIAN
 227     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 228     {
 229         fmt->i_rmask = 0x0f00;
 230         fmt->i_gmask = 0x00f0;
 231         fmt->i_bmask = 0x000f;
 232     }
 233     return (fmt->i_rmask == 0x0f00 && fmt->i_gmask == 0x00f0
 234          && fmt->i_bmask == 0x000f) ? 0 : -1;
 235 #else
 236     if (fmt->i_rmask == 0 && fmt->i_gmask == 0 && fmt->i_bmask == 0)
 237     {
 238         fmt->i_rmask = 0x000f;
 239         fmt->i_gmask = 0xf000;
 240         fmt->i_bmask = 0x0f00;
 241     }
 242     return (fmt->i_rmask == 0x000f && fmt->i_gmask == 0xf000
 243          && fmt->i_bmask == 0x0f00) ? 0 : -1;
 244 #endif
 245 }
 246
 247 /*** Initialization ***/
 248 static int Open (vlc_object_t *obj)
 249 {
 250     filter_t *filter = (filter_t *)obj;
 251
 252     if ((filter->fmt_in.video.i_width != filter->fmt_out.video.i_width)
 253      || (filter->fmt_in.video.i_height != filter->fmt_out.video.i_height))
 254         return OpenScaler (obj);
 255
 256     switch (filter->fmt_in.video.i_chroma)
 257     {
 258         case VLC_CODEC_I420:
 259             switch (filter->fmt_out.video.i_chroma)
 260             {
 261                 case VLC_CODEC_RGB16:
 262                     if (FixRV16 (&filter->fmt_out.video))
 263                         return VLC_EGENERIC;
 264                     filter->pf_video_filter = I420_RV16_Filter;
 265                     return VLC_SUCCESS;
 266             }
 267             break;
 268
 269         case VLC_CODEC_YV12:
 270             switch (filter->fmt_out.video.i_chroma)
 271             {
 272                 case VLC_CODEC_RGB16:
 273                     if (FixRV16 (&filter->fmt_out.video))
 274                         return VLC_EGENERIC;
 275                     filter->pf_video_filter = YV12_RV16_Filter;
 276                     return VLC_SUCCESS;
 277             }
 278             break;
 279
 280         case VLC_CODEC_I422:
 281             switch (filter->fmt_out.video.i_chroma)
 282             {
 283                 case VLC_CODEC_I420:
 284                     filter->pf_video_filter = I422_I420_Filter;
 285                     return VLC_SUCCESS;
 286                 case VLC_CODEC_YV12:
 287                     filter->pf_video_filter = I422_YV12_Filter;
 288                     return VLC_SUCCESS;
 289             }
 290             break;
 291
 292         case VLC_CODEC_I444:
 293             switch (filter->fmt_out.video.i_chroma)
 294             {
 295                 case VLC_CODEC_RGB16:
 296                     if (FixRV16 (&filter->fmt_out.video))
 297                         return VLC_EGENERIC;
 298                     filter->pf_video_filter = I444_RV16_Filter;
 299                     return VLC_SUCCESS;
 300             }
 301             return VLC_EGENERIC;
 302
 303         case VLC_CODEC_YUYV:
 304             switch (filter->fmt_out.video.i_chroma)
 305             {
 306                 case VLC_CODEC_RGB24:
 307                     if (FixRV24 (&filter->fmt_out.video))
 308                         return VLC_EGENERIC;
 309                     filter->pf_video_filter = YUYV_RV24_Filter;
 310                     return VLC_SUCCESS;
 311                 case VLC_CODEC_RGB16:
 312                     if (FixRV16 (&filter->fmt_out.video))
 313                         return VLC_EGENERIC;
 314                     filter->pf_video_filter = YUYV_RV16_Filter;
 315                     return VLC_SUCCESS;
 316             }
 317             return VLC_EGENERIC;
 318
 319         case VLC_CODEC_UYVY:
 320             switch (filter->fmt_out.video.i_chroma)
 321             {
 322                 case VLC_CODEC_I420:
 323                     filter->pf_video_filter = UYVY_I420_Filter;
 324                     return VLC_SUCCESS;
 325                 case VLC_CODEC_YV12:
 326                     filter->pf_video_filter = UYVY_YV12_Filter;
 327                     return VLC_SUCCESS;
 328             }
 329             return VLC_EGENERIC;
 330     }
 331     /* fallback to scaler (conversion with 1:1 scale) */
 332     return OpenScaler (obj);
 333 }
 334
 335 /* TODO: configurable interpolation */
 336
 337 #define XRR_MAX \
 338     (OMX_INT)(((float)((SRC_WIDTH  & ~1) - 1)) / ((DST_WIDTH  & ~1) - 1) * (1 << 16) + .5)
 339 #define YRR_MAX \
 340   (OMX_INT)(((float)((SRC_HEIGHT & ~1) - 1)) / ((DST_HEIGHT & ~1) - 1) * (1 << 16) + .5)
 341 #define CNV ((intptr_t)(filter->p_sys))
 342
 343 /*** Scaling from I420 ***/
 344 static void I420_I420_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 345 {
 346     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 347     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 348     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 349     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 350     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 351     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 352
 353     omxIPCS_YCbCr420RszRot_U8_P3R (
 354         in, instep, insize, out, outstep, outsize,
 355         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 356 }
 357 VIDEO_FILTER_WRAPPER (I420_I420_Scale)
 358
 359 static void I420_YV12_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 360 {
 361     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 362     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 363     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 364     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
 365     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
 366     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 367
 368     omxIPCS_YCbCr420RszRot_U8_P3R (
 369         in, instep, insize, out, outstep, outsize,
 370         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 371 }
 372 VIDEO_FILTER_WRAPPER (I420_YV12_Scale)
 373
 374 static void I420_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 375 {
 376     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 377     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 378     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 379     OMX_U8 *out = dst->p->p_pixels;
 380     OMX_INT outstep = dst->p->i_pitch;
 381     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 382
 383     omxIPCS_YCbCr420RszCscRotBGR_U8_P3C3R (
 384         in, instep, insize, out, outstep, outsize,
 385         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 386 }
 387 VIDEO_FILTER_WRAPPER (I420_RGB_Scale)
 388
 389 /*** Scaling from YV12 ***/
 390 static void YV12_I420_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 391 {
 392     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 393     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 394     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 395     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 396     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 397     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 398
 399     omxIPCS_YCbCr420RszRot_U8_P3R (
 400         in, instep, insize, out, outstep, outsize,
 401         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 402 }
 403 VIDEO_FILTER_WRAPPER (YV12_I420_Scale)
 404
 405 static void YV12_YV12_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 406 {
 407     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 408     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 409     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 410     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
 411     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
 412     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 413
 414     omxIPCS_YCbCr420RszRot_U8_P3R (
 415         in, instep, insize, out, outstep, outsize,
 416         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 417 }
 418 VIDEO_FILTER_WRAPPER (YV12_YV12_Scale)
 419
 420 static void YV12_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 421 {
 422     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 423     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 424     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 425     OMX_U8 *out = dst->p->p_pixels;
 426     OMX_INT outstep = dst->p->i_pitch;
 427     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 428
 429     omxIPCS_YCbCr420RszCscRotBGR_U8_P3C3R (
 430         in, instep, insize, out, outstep, outsize,
 431         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 432 }
 433 VIDEO_FILTER_WRAPPER (YV12_RGB_Scale)
 434
 435 /*** Scaling from I422 ***/
 436 static void I422_I422_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 437 {
 438     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 439     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 440     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 441     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 442     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 443     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 444
 445     omxIPCS_YCbCr422RszRot_U8_P3R (
 446         in, instep, insize, out, outstep, outsize,
 447         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 448 }
 449 VIDEO_FILTER_WRAPPER (I422_I422_Scale)
 450
 451 static void I422_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 452 {
 453     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 454     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 455     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 456     OMX_U8 *out = dst->p->p_pixels;
 457     OMX_INT outstep = dst->p->i_pitch;
 458     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 459
 460     omxIPCS_YCbCr422RszCscRotBGR_U8_P3C3R (
 461         in, instep, insize, out, outstep, outsize,
 462         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 463 }
 464 VIDEO_FILTER_WRAPPER (I422_RGB_Scale)
 465
 466 /*** Scaling initialization ***/
 467 static int OpenScaler (vlc_object_t *obj)
 468 {
 469     filter_t *filter = (filter_t *)obj;
 470
 471     switch (filter->fmt_in.video.i_chroma)
 472     {
 473         case VLC_CODEC_I420:
 474             switch (filter->fmt_out.video.i_chroma)
 475             {
 476                 case VLC_CODEC_I420:
 477                     filter->pf_video_filter = I420_I420_Scale_Filter;
 478                     return VLC_SUCCESS;
 479                 case VLC_CODEC_YV12:
 480                     filter->pf_video_filter = I420_YV12_Scale_Filter;
 481                     return VLC_SUCCESS;
 482                 case VLC_CODEC_RGB16:
 483                     if (FixRV16 (&filter->fmt_out.video))
 484                         return VLC_EGENERIC;
 485                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 486                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 487                     return VLC_SUCCESS;
 488                 case VLC_CODEC_RGB15:
 489                     if (FixRV15 (&filter->fmt_out.video))
 490                         break;
 491                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 492                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 493                     return VLC_SUCCESS;
 494                 case VLC_CODEC_RGB12:
 495                     if (FixRV12 (&filter->fmt_out.video))
 496                         break;
 497                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 498                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 499                     return VLC_SUCCESS;
 500                 case VLC_CODEC_RGB24:
 501                     if (FixRV24 (&filter->fmt_out.video))
 502                         break;
 503                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 504                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 505                     return VLC_SUCCESS;
 506             }
 507             break;
 508
 509         case VLC_CODEC_YV12:
 510             switch (filter->fmt_out.video.i_chroma)
 511             {
 512                 case VLC_CODEC_I420:
 513                     filter->pf_video_filter = YV12_I420_Scale_Filter;
 514                     return VLC_SUCCESS;
 515                 case VLC_CODEC_YV12:
 516                     filter->pf_video_filter = YV12_YV12_Scale_Filter;
 517                     return VLC_SUCCESS;
 518                 case VLC_CODEC_RGB16:
 519                     if (FixRV16 (&filter->fmt_out.video))
 520                         break;
 521                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 522                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 523                     return VLC_SUCCESS;
 524                 case VLC_CODEC_RGB15:
 525                     if (FixRV15 (&filter->fmt_out.video))
 526                         break;
 527                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 528                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 529                     return VLC_SUCCESS;
 530                 case VLC_CODEC_RGB12:
 531                     if (FixRV12 (&filter->fmt_out.video))
 532                         break;
 533                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 534                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 535                     return VLC_SUCCESS;
 536                 case VLC_CODEC_RGB24:
 537                     if (FixRV24 (&filter->fmt_out.video))
 538                         break;
 539                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 540                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 541                     return VLC_SUCCESS;
 542             }
 543             break;
 544
 545         case VLC_CODEC_I422:
 546             switch (filter->fmt_out.video.i_chroma)
 547             {
 548                 case VLC_CODEC_I422:
 549                     filter->pf_video_filter = I422_I422_Scale_Filter;
 550                     return VLC_SUCCESS;
 551                 case VLC_CODEC_RGB16:
 552                     if (FixRV16 (&filter->fmt_out.video))
 553                         break;
 554                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 555                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 556                     return VLC_SUCCESS;
 557                 case VLC_CODEC_RGB15:
 558                     if (FixRV15 (&filter->fmt_out.video))
 559                         break;
 560                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 561                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 562                     return VLC_SUCCESS;
 563                 case VLC_CODEC_RGB12:
 564                     if (FixRV12 (&filter->fmt_out.video))
 565                         break;
 566                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 567                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 568                     return VLC_SUCCESS;
 569                 case VLC_CODEC_RGB24:
 570                     if (FixRV24 (&filter->fmt_out.video))
 571                         break;
 572                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 573                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 574                     return VLC_SUCCESS;
 575             }
 576             break;
 577     }
 578     return VLC_EGENERIC;
 579 }