libmpcodecs/img_format.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include "config.h"
  20 #include "img_format.h"
  21 #include "stdio.h"
  22 #include "mpbswap.h"
  23
  24 // Used by option parsing and codecs.conf parsing
  25 const struct imgfmt_name mp_imgfmt_list[] = {
  26     {"444p16le", IMGFMT_444P16_LE},
  27     {"444p16be", IMGFMT_444P16_BE},
  28     {"444p10le", IMGFMT_444P10_LE},
  29     {"444p10be", IMGFMT_444P10_BE},
  30     {"444p9le", IMGFMT_444P9_LE},
  31     {"444p9be", IMGFMT_444P9_BE},
  32     {"422p16le", IMGFMT_422P16_LE},
  33     {"422p16be", IMGFMT_422P16_BE},
  34     {"422p10le", IMGFMT_422P10_LE},
  35     {"422p10be", IMGFMT_422P10_BE},
  36     {"422p9le", IMGFMT_422P9_LE},
  37     {"422p9be", IMGFMT_422P9_BE},
  38     {"420p16le", IMGFMT_420P16_LE},
  39     {"420p16be", IMGFMT_420P16_BE},
  40     {"420p10le", IMGFMT_420P10_LE},
  41     {"420p10be", IMGFMT_420P10_BE},
  42     {"420p9le", IMGFMT_420P9_LE},
  43     {"420p9be", IMGFMT_420P9_BE},
  44     {"444p16", IMGFMT_444P16},
  45     {"444p10", IMGFMT_444P10},
  46     {"444p9", IMGFMT_444P9},
  47     {"422p16", IMGFMT_422P16},
  48     {"422p10", IMGFMT_422P10},
  49     {"422p9", IMGFMT_422P9},
  50     {"420p10", IMGFMT_420P10},
  51     {"420p9", IMGFMT_420P9},
  52     {"420p16", IMGFMT_420P16},
  53     {"420a", IMGFMT_420A},
  54     {"444p", IMGFMT_444P},
  55     {"422p", IMGFMT_422P},
  56     {"411p", IMGFMT_411P},
  57     {"440p", IMGFMT_440P},
  58     {"yuy2", IMGFMT_YUY2},
  59     {"yvyu", IMGFMT_YVYU},
  60     {"uyvy", IMGFMT_UYVY},
  61     {"yvu9", IMGFMT_YVU9},
  62     {"if09", IMGFMT_IF09},
  63     {"yv12", IMGFMT_YV12},
  64     {"i420", IMGFMT_I420},
  65     {"iyuv", IMGFMT_IYUV},
  66     {"clpl", IMGFMT_CLPL},
  67     {"hm12", IMGFMT_HM12},
  68     {"y800", IMGFMT_Y800},
  69     {"y8", IMGFMT_Y8},
  70     {"nv12", IMGFMT_NV12},
  71     {"nv21", IMGFMT_NV21},
  72     {"bgr24", IMGFMT_BGR24},
  73     {"bgr32", IMGFMT_BGR32},
  74     {"bgr16", IMGFMT_BGR16},
  75     {"Bgr15", IMGFMT_BGR15},
  76     {"bgr12", IMGFMT_BGR12},
  77     {"bgr8", IMGFMT_BGR8},
  78     {"bgr4", IMGFMT_BGR4},
  79     {"bg4b", IMGFMT_BG4B},
  80     {"bgr1", IMGFMT_BGR1},
  81     {"rgb48be", IMGFMT_RGB48BE},
  82     {"rgb48le", IMGFMT_RGB48LE},
  83     {"rgb48ne", IMGFMT_RGB48NE},
  84     {"rgb24", IMGFMT_RGB24},
  85     {"rgb32", IMGFMT_RGB32},
  86     {"rgb16", IMGFMT_RGB16},
  87     {"rgb15", IMGFMT_RGB15},
  88     {"rgb12", IMGFMT_RGB12},
  89     {"rgb8", IMGFMT_RGB8},
  90     {"rgb4", IMGFMT_RGB4},
  91     {"rg4b", IMGFMT_RG4B},
  92     {"rgb1", IMGFMT_RGB1},
  93     {"rgba", IMGFMT_RGBA},
  94     {"argb", IMGFMT_ARGB},
  95     {"bgra", IMGFMT_BGRA},
  96     {"abgr", IMGFMT_ABGR},
  97     {"gbrp", IMGFMT_GBRP},
  98     {"gbrp9", IMGFMT_GBRP9},
  99     {"gbrp9le", IMGFMT_GBRP9LE},
 100     {"gbrp9be", IMGFMT_GBRP9BE},
 101     {"gbrp10", IMGFMT_GBRP10},
 102     {"gbrp10le", IMGFMT_GBRP10LE},
 103     {"gbrp10be", IMGFMT_GBRP10BE},
 104     {"mjpeg", IMGFMT_MJPEG},
 105     {"mjpg", IMGFMT_MJPEG},
 106     { NULL, 0 }
 107 };
 108
 109 // used in codecs.conf only
 110 static const struct imgfmt_name special_imgfmts[] = {
 111     {"mpes", IMGFMT_MPEGPES},
 112     {"vdpau_h264", IMGFMT_VDPAU_H264},
 113     {"vdpau_mpeg1", IMGFMT_VDPAU_MPEG1},
 114     {"vdpau_mpeg2", IMGFMT_VDPAU_MPEG2},
 115     {"vdpau_mpeg4", IMGFMT_VDPAU_MPEG4},
 116     {"vdpau_wmv3", IMGFMT_VDPAU_WMV3},
 117     {"vdpau_vc1", IMGFMT_VDPAU_VC1},
 118     { NULL, 0 }
 119 };
 120
 121 unsigned int imgfmt_parse(struct bstr name, bool special_fmts)
 122 {
 123     for (int i = 0; mp_imgfmt_list[i].name; i++)
 124         if (!bstrcasecmp0(name, mp_imgfmt_list[i].name))
 125             return mp_imgfmt_list[i].fmt;
 126     if (!special_fmts)
 127         return 0;
 128     for (int i = 0; special_imgfmts[i].name; i++)
 129         if (!bstrcasecmp0(name, special_imgfmts[i].name))
 130             return special_imgfmts[i].fmt;
 131     return 0;
 132 }
 133
 134 const char *vo_format_name(int format)
 135 {
 136     static char unknown_format[20];
 137     switch (format) {
 138     case IMGFMT_RGB1: return "RGB 1-bit";
 139     case IMGFMT_RGB4: return "RGB 4-bit";
 140     case IMGFMT_RG4B: return "RGB 4-bit per byte";
 141     case IMGFMT_RGB8: return "RGB 8-bit";
 142     case IMGFMT_RGB12: return "RGB 12-bit";
 143     case IMGFMT_RGB15: return "RGB 15-bit";
 144     case IMGFMT_RGB16: return "RGB 16-bit";
 145     case IMGFMT_RGB24: return "RGB 24-bit";
 146 //  case IMGFMT_RGB32: return "RGB 32-bit";      // equals either RGBA or ABGR
 147     case IMGFMT_RGB48LE: return "RGB 48-bit LE";
 148     case IMGFMT_RGB48BE: return "RGB 48-bit BE";
 149     case IMGFMT_BGR1: return "BGR 1-bit";
 150     case IMGFMT_BGR4: return "BGR 4-bit";
 151     case IMGFMT_BG4B: return "BGR 4-bit per byte";
 152     case IMGFMT_BGR8: return "BGR 8-bit";
 153     case IMGFMT_BGR12: return "BGR 12-bit";
 154     case IMGFMT_BGR15: return "BGR 15-bit";
 155     case IMGFMT_BGR16: return "BGR 16-bit";
 156     case IMGFMT_BGR24: return "BGR 24-bit";
 157 //  case IMGFMT_BGR32: return "BGR 32-bit";      // equals either BGRA or ARGB
 158     case IMGFMT_ABGR: return "ABGR";
 159     case IMGFMT_BGRA: return "BGRA";
 160     case IMGFMT_ARGB: return "ARGB";
 161     case IMGFMT_RGBA: return "RGBA";
 162     case IMGFMT_GBRP: return "Planar GBR 24-bit";
 163     case IMGFMT_GBRP9LE: return "Planar GBR 27-bit little-endian";
 164     case IMGFMT_GBRP9BE: return "Planar GBR 27-bit big-endian";
 165     case IMGFMT_GBRP10LE: return "Planar GBR 30-bit little-endian";
 166     case IMGFMT_GBRP10BE: return "Planar GBR 30-bit big-endian";
 167     case IMGFMT_YVU9: return "Planar YVU9";
 168     case IMGFMT_IF09: return "Planar IF09";
 169     case IMGFMT_YV12: return "Planar YV12";
 170     case IMGFMT_I420: return "Planar I420";
 171     case IMGFMT_IYUV: return "Planar IYUV";
 172     case IMGFMT_CLPL: return "Planar CLPL";
 173     case IMGFMT_Y800: return "Planar Y800";
 174     case IMGFMT_Y8: return "Planar Y8";
 175     case IMGFMT_420P16_LE: return "Planar 420P 16-bit little-endian";
 176     case IMGFMT_420P16_BE: return "Planar 420P 16-bit big-endian";
 177     case IMGFMT_420P10_LE: return "Planar 420P 10-bit little-endian";
 178     case IMGFMT_420P10_BE: return "Planar 420P 10-bit big-endian";
 179     case IMGFMT_420P9_LE: return "Planar 420P 9-bit little-endian";
 180     case IMGFMT_420P9_BE: return "Planar 420P 9-bit big-endian";
 181     case IMGFMT_422P16_LE: return "Planar 422P 16-bit little-endian";
 182     case IMGFMT_422P16_BE: return "Planar 422P 16-bit big-endian";
 183     case IMGFMT_422P10_LE: return "Planar 422P 10-bit little-endian";
 184     case IMGFMT_422P10_BE: return "Planar 422P 10-bit big-endian";
 185     case IMGFMT_422P9_LE:  return "Planar 422P 9-bit little-endian";
 186     case IMGFMT_422P9_BE:  return "Planar 422P 9-bit big-endian";
 187     case IMGFMT_444P16_LE: return "Planar 444P 16-bit little-endian";
 188     case IMGFMT_444P16_BE: return "Planar 444P 16-bit big-endian";
 189     case IMGFMT_444P10_LE: return "Planar 444P 10-bit little-endian";
 190     case IMGFMT_444P10_BE: return "Planar 444P 10-bit big-endian";
 191     case IMGFMT_444P9_LE: return "Planar 444P 9-bit little-endian";
 192     case IMGFMT_444P9_BE: return "Planar 444P 9-bit big-endian";
 193     case IMGFMT_420A: return "Planar 420P with alpha";
 194     case IMGFMT_444P: return "Planar 444P";
 195     case IMGFMT_422P: return "Planar 422P";
 196     case IMGFMT_411P: return "Planar 411P";
 197     case IMGFMT_NV12: return "Planar NV12";
 198     case IMGFMT_NV21: return "Planar NV21";
 199     case IMGFMT_HM12: return "Planar NV12 Macroblock";
 200     case IMGFMT_IUYV: return "Packed IUYV";
 201     case IMGFMT_IY41: return "Packed IY41";
 202     case IMGFMT_IYU1: return "Packed IYU1";
 203     case IMGFMT_IYU2: return "Packed IYU2";
 204     case IMGFMT_UYVY: return "Packed UYVY";
 205     case IMGFMT_UYNV: return "Packed UYNV";
 206     case IMGFMT_cyuv: return "Packed CYUV";
 207     case IMGFMT_Y422: return "Packed Y422";
 208     case IMGFMT_YUY2: return "Packed YUY2";
 209     case IMGFMT_YUNV: return "Packed YUNV";
 210     case IMGFMT_YVYU: return "Packed YVYU";
 211     case IMGFMT_Y41P: return "Packed Y41P";
 212     case IMGFMT_Y211: return "Packed Y211";
 213     case IMGFMT_Y41T: return "Packed Y41T";
 214     case IMGFMT_Y42T: return "Packed Y42T";
 215     case IMGFMT_V422: return "Packed V422";
 216     case IMGFMT_V655: return "Packed V655";
 217     case IMGFMT_CLJR: return "Packed CLJR";
 218     case IMGFMT_YUVP: return "Packed YUVP";
 219     case IMGFMT_UYVP: return "Packed UYVP";
 220     case IMGFMT_MPEGPES: return "Mpeg PES";
 221     case IMGFMT_VDPAU_MPEG1: return "MPEG1 VDPAU acceleration";
 222     case IMGFMT_VDPAU_MPEG2: return "MPEG2 VDPAU acceleration";
 223     case IMGFMT_VDPAU_H264: return "H.264 VDPAU acceleration";
 224     case IMGFMT_VDPAU_MPEG4: return "MPEG-4 Part 2 VDPAU acceleration";
 225     case IMGFMT_VDPAU_WMV3: return "WMV3 VDPAU acceleration";
 226     case IMGFMT_VDPAU_VC1: return "VC1 VDPAU acceleration";
 227     }
 228     snprintf(unknown_format, 20, "Unknown 0x%04x", format);
 229     return unknown_format;
 230 }
 231
 232 int mp_get_chroma_shift(int format, int *x_shift, int *y_shift,
 233                         int *component_bits)
 234 {
 235     int xs = 0, ys = 0;
 236     int bpp;
 237     int err = 0;
 238     int bits = 8;
 239     if ((format & 0xff0000f0) == 0x34000050)
 240         format = bswap_32(format);
 241     if ((format & 0xf00000ff) == 0x50000034) {
 242         switch (format >> 24) {
 243         case 0x50:
 244             break;
 245         case 0x51:
 246             bits = 16;
 247             break;
 248         case 0x52:
 249             bits = 10;
 250             break;
 251         case 0x53:
 252             bits = 9;
 253             break;
 254         default:
 255             err = 1;
 256             break;
 257         }
 258         switch (format & 0x00ffffff) {
 259         case 0x00343434: // 444
 260             xs = 0;
 261             ys = 0;
 262             break;
 263         case 0x00323234: // 422
 264             xs = 1;
 265             ys = 0;
 266             break;
 267         case 0x00303234: // 420
 268             xs = 1;
 269             ys = 1;
 270             break;
 271         case 0x00313134: // 411
 272             xs = 2;
 273             ys = 0;
 274             break;
 275         case 0x00303434: // 440
 276             xs = 0;
 277             ys = 1;
 278             break;
 279         default:
 280             err = 1;
 281             break;
 282         }
 283     } else
 284         switch (format) {
 285         case IMGFMT_420A:
 286         case IMGFMT_I420:
 287         case IMGFMT_IYUV:
 288         case IMGFMT_YV12:
 289             xs = 1;
 290             ys = 1;
 291             break;
 292         case IMGFMT_IF09:
 293         case IMGFMT_YVU9:
 294             xs = 2;
 295             ys = 2;
 296             break;
 297         case IMGFMT_Y8:
 298         case IMGFMT_Y800:
 299             xs = 31;
 300             ys = 31;
 301             break;
 302         default:
 303             err = 1;
 304             break;
 305         }
 306     if (x_shift)
 307         *x_shift = xs;
 308     if (y_shift)
 309         *y_shift = ys;
 310     if (component_bits)
 311         *component_bits = bits;
 312     bpp = 8 + ((16 >> xs) >> ys);
 313     if (format == IMGFMT_420A)
 314         bpp += 8;
 315     bpp *= (bits + 7) >> 3;
 316     return err ? 0 : bpp;
 317 }