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.orientation != filter->fmt_out.video.orientation)
 253         return VLC_EGENERIC;
 254
 255     if ((filter->fmt_in.video.i_width != filter->fmt_out.video.i_width)
 256      || (filter->fmt_in.video.i_height != filter->fmt_out.video.i_height))
 257         return OpenScaler (obj);
 258
 259     switch (filter->fmt_in.video.i_chroma)
 260     {
 261         case VLC_CODEC_I420:
 262             switch (filter->fmt_out.video.i_chroma)
 263             {
 264                 case VLC_CODEC_RGB16:
 265                     if (FixRV16 (&filter->fmt_out.video))
 266                         return VLC_EGENERIC;
 267                     filter->pf_video_filter = I420_RV16_Filter;
 268                     return VLC_SUCCESS;
 269             }
 270             break;
 271
 272         case VLC_CODEC_YV12:
 273             switch (filter->fmt_out.video.i_chroma)
 274             {
 275                 case VLC_CODEC_RGB16:
 276                     if (FixRV16 (&filter->fmt_out.video))
 277                         return VLC_EGENERIC;
 278                     filter->pf_video_filter = YV12_RV16_Filter;
 279                     return VLC_SUCCESS;
 280             }
 281             break;
 282
 283         case VLC_CODEC_I422:
 284             switch (filter->fmt_out.video.i_chroma)
 285             {
 286                 case VLC_CODEC_I420:
 287                     filter->pf_video_filter = I422_I420_Filter;
 288                     return VLC_SUCCESS;
 289                 case VLC_CODEC_YV12:
 290                     filter->pf_video_filter = I422_YV12_Filter;
 291                     return VLC_SUCCESS;
 292             }
 293             break;
 294
 295         case VLC_CODEC_I444:
 296             switch (filter->fmt_out.video.i_chroma)
 297             {
 298                 case VLC_CODEC_RGB16:
 299                     if (FixRV16 (&filter->fmt_out.video))
 300                         return VLC_EGENERIC;
 301                     filter->pf_video_filter = I444_RV16_Filter;
 302                     return VLC_SUCCESS;
 303             }
 304             return VLC_EGENERIC;
 305
 306         case VLC_CODEC_YUYV:
 307             switch (filter->fmt_out.video.i_chroma)
 308             {
 309                 case VLC_CODEC_RGB24:
 310                     if (FixRV24 (&filter->fmt_out.video))
 311                         return VLC_EGENERIC;
 312                     filter->pf_video_filter = YUYV_RV24_Filter;
 313                     return VLC_SUCCESS;
 314                 case VLC_CODEC_RGB16:
 315                     if (FixRV16 (&filter->fmt_out.video))
 316                         return VLC_EGENERIC;
 317                     filter->pf_video_filter = YUYV_RV16_Filter;
 318                     return VLC_SUCCESS;
 319             }
 320             return VLC_EGENERIC;
 321
 322         case VLC_CODEC_UYVY:
 323             switch (filter->fmt_out.video.i_chroma)
 324             {
 325                 case VLC_CODEC_I420:
 326                     filter->pf_video_filter = UYVY_I420_Filter;
 327                     return VLC_SUCCESS;
 328                 case VLC_CODEC_YV12:
 329                     filter->pf_video_filter = UYVY_YV12_Filter;
 330                     return VLC_SUCCESS;
 331             }
 332             return VLC_EGENERIC;
 333     }
 334     /* fallback to scaler (conversion with 1:1 scale) */
 335     return OpenScaler (obj);
 336 }
 337
 338 /* TODO: configurable interpolation */
 339
 340 #define XRR_MAX \
 341     (OMX_INT)(((float)((SRC_WIDTH  & ~1) - 1)) / ((DST_WIDTH  & ~1) - 1) * (1 << 16) + .5)
 342 #define YRR_MAX \
 343   (OMX_INT)(((float)((SRC_HEIGHT & ~1) - 1)) / ((DST_HEIGHT & ~1) - 1) * (1 << 16) + .5)
 344 #define CNV ((intptr_t)(filter->p_sys))
 345
 346 /*** Scaling from I420 ***/
 347 static void I420_I420_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 348 {
 349     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 350     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 351     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 352     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 353     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 354     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 355
 356     omxIPCS_YCbCr420RszRot_U8_P3R (
 357         in, instep, insize, out, outstep, outsize,
 358         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 359 }
 360 VIDEO_FILTER_WRAPPER (I420_I420_Scale)
 361
 362 static void I420_YV12_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 363 {
 364     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 365     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 366     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 367     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
 368     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
 369     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 370
 371     omxIPCS_YCbCr420RszRot_U8_P3R (
 372         in, instep, insize, out, outstep, outsize,
 373         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 374 }
 375 VIDEO_FILTER_WRAPPER (I420_YV12_Scale)
 376
 377 static void I420_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 378 {
 379     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 380     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 381     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 382     OMX_U8 *out = dst->p->p_pixels;
 383     OMX_INT outstep = dst->p->i_pitch;
 384     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 385
 386     omxIPCS_YCbCr420RszCscRotBGR_U8_P3C3R (
 387         in, instep, insize, out, outstep, outsize,
 388         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 389 }
 390 VIDEO_FILTER_WRAPPER (I420_RGB_Scale)
 391
 392 /*** Scaling from YV12 ***/
 393 static void YV12_I420_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 394 {
 395     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 396     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 397     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 398     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 399     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 400     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 401
 402     omxIPCS_YCbCr420RszRot_U8_P3R (
 403         in, instep, insize, out, outstep, outsize,
 404         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 405 }
 406 VIDEO_FILTER_WRAPPER (YV12_I420_Scale)
 407
 408 static void YV12_YV12_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 409 {
 410     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 411     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 412     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 413     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->V_PIXELS, dst->U_PIXELS };
 414     OMX_INT outstep[3] = { dst->Y_PITCH, dst->V_PITCH, dst->U_PITCH };
 415     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 416
 417     omxIPCS_YCbCr420RszRot_U8_P3R (
 418         in, instep, insize, out, outstep, outsize,
 419         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 420 }
 421 VIDEO_FILTER_WRAPPER (YV12_YV12_Scale)
 422
 423 static void YV12_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 424 {
 425     const OMX_U8 *in[3] = { src->Y_PIXELS, src->V_PIXELS, src->U_PIXELS };
 426     OMX_INT instep[3] = { src->Y_PITCH, src->V_PITCH, src->U_PITCH };
 427     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 428     OMX_U8 *out = dst->p->p_pixels;
 429     OMX_INT outstep = dst->p->i_pitch;
 430     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 431
 432     omxIPCS_YCbCr420RszCscRotBGR_U8_P3C3R (
 433         in, instep, insize, out, outstep, outsize,
 434         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 435 }
 436 VIDEO_FILTER_WRAPPER (YV12_RGB_Scale)
 437
 438 /*** Scaling from I422 ***/
 439 static void I422_I422_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 440 {
 441     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 442     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 443     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 444     OMX_U8 *out[3] = { dst->Y_PIXELS, dst->U_PIXELS, dst->V_PIXELS };
 445     OMX_INT outstep[3] = { dst->Y_PITCH, dst->U_PITCH, dst->V_PITCH };
 446     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 447
 448     omxIPCS_YCbCr422RszRot_U8_P3R (
 449         in, instep, insize, out, outstep, outsize,
 450         OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 451 }
 452 VIDEO_FILTER_WRAPPER (I422_I422_Scale)
 453
 454 static void I422_RGB_Scale (filter_t *filter, picture_t *src, picture_t *dst)
 455 {
 456     const OMX_U8 *in[3] = { src->Y_PIXELS, src->U_PIXELS, src->V_PIXELS };
 457     OMX_INT instep[3] = { src->Y_PITCH, src->U_PITCH, src->V_PITCH };
 458     OMXSize insize = { SRC_WIDTH, SRC_HEIGHT };
 459     OMX_U8 *out = dst->p->p_pixels;
 460     OMX_INT outstep = dst->p->i_pitch;
 461     OMXSize outsize = { DST_WIDTH, DST_HEIGHT };
 462
 463     omxIPCS_YCbCr422RszCscRotBGR_U8_P3C3R (
 464         in, instep, insize, out, outstep, outsize,
 465         CNV, OMX_IP_NEAREST, OMX_IP_DISABLE, XRR_MAX, YRR_MAX);
 466 }
 467 VIDEO_FILTER_WRAPPER (I422_RGB_Scale)
 468
 469 /*** Scaling initialization ***/
 470 static int OpenScaler (vlc_object_t *obj)
 471 {
 472     filter_t *filter = (filter_t *)obj;
 473
 474     switch (filter->fmt_in.video.i_chroma)
 475     {
 476         case VLC_CODEC_I420:
 477             switch (filter->fmt_out.video.i_chroma)
 478             {
 479                 case VLC_CODEC_I420:
 480                     filter->pf_video_filter = I420_I420_Scale_Filter;
 481                     return VLC_SUCCESS;
 482                 case VLC_CODEC_YV12:
 483                     filter->pf_video_filter = I420_YV12_Scale_Filter;
 484                     return VLC_SUCCESS;
 485                 case VLC_CODEC_RGB16:
 486                     if (FixRV16 (&filter->fmt_out.video))
 487                         return VLC_EGENERIC;
 488                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 489                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 490                     return VLC_SUCCESS;
 491                 case VLC_CODEC_RGB15:
 492                     if (FixRV15 (&filter->fmt_out.video))
 493                         break;
 494                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 495                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 496                     return VLC_SUCCESS;
 497                 case VLC_CODEC_RGB12:
 498                     if (FixRV12 (&filter->fmt_out.video))
 499                         break;
 500                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 501                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 502                     return VLC_SUCCESS;
 503                 case VLC_CODEC_RGB24:
 504                     if (FixRV24 (&filter->fmt_out.video))
 505                         break;
 506                     filter->pf_video_filter = I420_RGB_Scale_Filter;
 507                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 508                     return VLC_SUCCESS;
 509             }
 510             break;
 511
 512         case VLC_CODEC_YV12:
 513             switch (filter->fmt_out.video.i_chroma)
 514             {
 515                 case VLC_CODEC_I420:
 516                     filter->pf_video_filter = YV12_I420_Scale_Filter;
 517                     return VLC_SUCCESS;
 518                 case VLC_CODEC_YV12:
 519                     filter->pf_video_filter = YV12_YV12_Scale_Filter;
 520                     return VLC_SUCCESS;
 521                 case VLC_CODEC_RGB16:
 522                     if (FixRV16 (&filter->fmt_out.video))
 523                         break;
 524                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 525                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 526                     return VLC_SUCCESS;
 527                 case VLC_CODEC_RGB15:
 528                     if (FixRV15 (&filter->fmt_out.video))
 529                         break;
 530                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 531                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 532                     return VLC_SUCCESS;
 533                 case VLC_CODEC_RGB12:
 534                     if (FixRV12 (&filter->fmt_out.video))
 535                         break;
 536                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 537                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 538                     return VLC_SUCCESS;
 539                 case VLC_CODEC_RGB24:
 540                     if (FixRV24 (&filter->fmt_out.video))
 541                         break;
 542                     filter->pf_video_filter = YV12_RGB_Scale_Filter;
 543                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 544                     return VLC_SUCCESS;
 545             }
 546             break;
 547
 548         case VLC_CODEC_I422:
 549             switch (filter->fmt_out.video.i_chroma)
 550             {
 551                 case VLC_CODEC_I422:
 552                     filter->pf_video_filter = I422_I422_Scale_Filter;
 553                     return VLC_SUCCESS;
 554                 case VLC_CODEC_RGB16:
 555                     if (FixRV16 (&filter->fmt_out.video))
 556                         break;
 557                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 558                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR565;
 559                     return VLC_SUCCESS;
 560                 case VLC_CODEC_RGB15:
 561                     if (FixRV15 (&filter->fmt_out.video))
 562                         break;
 563                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 564                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR555;
 565                     return VLC_SUCCESS;
 566                 case VLC_CODEC_RGB12:
 567                     if (FixRV12 (&filter->fmt_out.video))
 568                         break;
 569                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 570                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR444;
 571                     return VLC_SUCCESS;
 572                 case VLC_CODEC_RGB24:
 573                     if (FixRV24 (&filter->fmt_out.video))
 574                         break;
 575                     filter->pf_video_filter = I422_RGB_Scale_Filter;
 576                     filter->p_sys = (void *)(intptr_t)OMX_IP_BGR888;
 577                     return VLC_SUCCESS;
 578             }
 579             break;
 580     }
 581     return VLC_EGENERIC;
 582 }