cinelerra-5.1/guicast/bccmdl.py

   1 #!/bin/python
   2
   3 # Retain python2 compatibility
   4 from __future__ import print_function
   5
   6 base = {
   7   "rgb8": {
   8     "i8": {
   9       "r": " uint32_t in = *inp; int r = ((in>>6)&3)*0x55u, g = ((in>>3)&7)*0x24u, b = (in&7)*0x24u;",
  10       "w": " uint32_t ot = (r&0xc0u) | ((g>>2)&0x38u) | ((b>>5)&0x07u);\n" +
  11            " *out++ = ot;",
  12     },
  13     "i16": {
  14       "r": " uint32_t in = *inp; int r = ((in>>6)&3)*0x5555u, g = ((in>>3)&7)*0x2492u, b = (in&7)*0x2492u;",
  15       "w": " uint32_t ot = ((r>>8)&0xc0u) | ((g>>10) & 0x38u) >> 2) | ((b>>13)&0x07u);\n" +
  16            " *out++ = ot;",
  17     },
  18     "fp": {
  19       "r": " int in = *inp; float r = (in>>6)/3.f, g = ((in>>3)&0x07u)/7.f, b = (in&0x07u)/7.f;",
  20       "w": " int vr = clp(4,r), vg = clp(8,g), vb = clp(8,b);\n" +
  21            " *out++ = ((vr<<6)&0xc0u) | ((vg<<3)&0x38u) | (vb&0x7u);",
  22     },
  23   },
  24   "rgb565": {
  25     "i8": {
  26       "r": " uint32_t in = *(uint16_t*)inp;\n" +
  27            " int r = (in>>8)&0xf8u, g = (in>>3)&0xfcu, b = (in&0x1fu)<<3;",
  28       "w": " uint32_t ot = ((r<<8) & 0xf800u) | ((g<<3) & 0x07e0u) | ((b>>3) & 0x001fu);\n" +
  29            " *(uint16_t*)out = ot; out += sizeof(uint16_t);",
  30     },
  31     "i16": {
  32       "r": " uint32_t in = *(uint16_t*)inp;\n" +
  33            " int r = in&0xf800u, g = (in<<5)&0xfc00u, b = (in<<11)&0xf800u;",
  34       "w": " uint32_t ot = (r&0xf800u) | ((g>>5) & 0x07e0u) | ((b>>11) & 0x001fu);\n" +
  35            " *out++ = ot;",
  36     },
  37     "fp": {
  38       "r": " uint32_t in = *(uint16_t*)inp;\n" +
  39            " float r = (in>>11)/31.f, g = ((in>>5)&0x3fu)/63.f, b = (in&0x1fu)/31.f;",
  40       "w": " uint32_t vr = clp(32,r), vg = clp(64,g), vb = clp(32,b);\n" +
  41            " *out++ = ((vr<<11)&0xf800u) | ((vg<<6)&0x07e0u) | (vb&0x001fu);",
  42     },
  43   },
  44   "rgb888": {
  45     "i8": {
  46       "r": " int r = *inp++, g = *inp++, b = *inp++;",
  47       "w": " *out++ = r; *out++ = g; *out++ = b;",
  48     },
  49     "i16": {
  50       "r": " int r = *inp++, g = *inp++, b = *inp++;\n" +
  51            " r = (r<<8) | r;  g = (g<<8) | g;  b = (b<<8) | b;",
  52       "w": " *out++ = r>>8; *out++ = g>>8; *out++ = b>>8;",
  53     },
  54     "fp": {
  55       "r": " float r = fclp(*inp++,256), g=fclp(*inp++,256), b = fclp(*inp++,256);",
  56       "w": " *out++ = clp(256,r); *out++ = clp(256,g); *out++ = clp(256,b);",
  57     },
  58   },
  59   "rgb161616": {
  60     "i8": {
  61       "r": " int r = *inp++>>8, g = *inp++>>8, b = *inp++>>8;",
  62       "w": " *out++ = (r<<8) | r;  *out++ = (g<<8) | g;  *out++ = (b<<8) | b;"
  63     },
  64     "i16": {
  65       "r": " int r = *inp++, g = *inp++, b = *inp++;",
  66       "w": " *out++ = r; *out++ = g; *out++ = b;",
  67     },
  68     "fp": {
  69       "r": " float r = fclp(*inp++,65536), g=fclp(*inp++,65536), b = fclp(*inp++,65536);",
  70       "w": " *out++ = clp(65536,r); *out++ = clp(65536,g); *out++ = clp(65536,b);",
  71     },
  72   },
  73   "rgbfloat": {
  74     "i8": {
  75       "r": " int r = clp(256,*inp++), g = clp(256,*inp++), b = clp(256,*inp++);",
  76       "w": " *out++ = fclp(r,256); *out++ = fclp(g,256); *out++ = fclp(b,256);",
  77     },
  78     "i16": {
  79       "r": " int r = clp(65536,*inp++), g = clp(65536,*inp++), b = clp(65536,*inp++);",
  80       "w": " *out++ = fclp(r,65536); *out++ = fclp(g,65536); *out++ = fclp(b,65536);",
  81     },
  82     "fp": {
  83       "r": " float r = *inp++, g=*inp++, b = *inp++;",
  84       "w": " *out++ = r; *out++ = g; *out++ = b;",
  85     },
  86   },
  87
  88   "bgr565": {
  89     "i8": {
  90       "r": " uint32_t in = *(uint16_t*)inp;\n" +
  91            " int b = (in>>8)&0xf8u, g = (in>>3)&0xfcu, r = (in&0x1fu)<<3;",
  92       "w": " uint32_t ot = ((b&0xf8u)<<8) | ((g&0xfcu)<<3) | ((r&0xf8u)>>3);\n" +
  93            " *(uint16_t*)out = ot; out += sizeof(uint16_t)/sizeof(*out);",
  94     },
  95     "i16": {
  96       "r": " uint32_t in = *(uint16_t*)inp;\n" +
  97            " int b = in&0xf800u, g = (in<<5)&0xfc00u, r = (in<<11)&0xf800u;",
  98       "w": " uint32_t ot = (b&0xf800u) | ((g>>5) & 0x07e0u) << 3) | (r>>11);\n" +
  99            " *out++ = ot;",
 100     },
 101     "fp": {
 102       "r": " uint32_t in = *(uint16_t*)inp;\n" +
 103            " float b = (in>>11)/31.f, g = ((in>>5)&0x3fu)/63.f, r = (in&0x1fu)/31.f;",
 104       "w": " uint32_t vb = clp(32,b), vg = clp(64,g), vr = clp(32,r);\n" +
 105            " *out++ = ((vb<<11)&0xf800u) | ((vg<<6)&0x03e0u) | (vr&0x001fu);",
 106     },
 107   },
 108   "bgr888": {
 109     "i8": {
 110       "r": " int b = *inp++, g = *inp++, r = *inp++;",
 111       "w": " *out++ = b; *out++ = g; *out++ = r;",
 112     },
 113     "i16": {
 114       "r": " int b = *inp++, g = *inp++, r = *inp++;\n" +
 115            " b = (b<<8) | b;  g = (g<<8) | g;  r = (r<<8) | r;",
 116       "w": " *out++ = b>>8; *out++ = g>>8; *out++ = r>>8;",
 117     },
 118     "fp": {
 119       "r": " float b = fclp(*inp++,256), g=fclp(*inp++,256), r = fclp(*inp++,256);",
 120       "w": " *out++ = clp(256,b); *out++ = clp(256,g); *out++ = clp(256,r);",
 121     },
 122   },
 123   "bgr8888": {
 124     "i8": {
 125       "r": " int b = *inp++, g = *inp++, r = *inp++;",
 126       "w": " *out++ = b; *out++ = g; *out++ = r; ++out;",
 127     },
 128     "i16": {
 129       "r": " int b = *inp++, g = *inp++, r = *inp++;\n" +
 130            " b = (b<<8) | b;  g = (g<<8) | g;  r = (r<<8) | r;",
 131       "w": " *out++ = b>>8; *out++ = g>>8; *out++ = r>>8; ++out;",
 132     },
 133     "fp": {
 134       "r": " float b = fclp(*inp++,256), g=fclp(*inp++,256), r = fclp(*inp++,256);",
 135       "w": " *out++ = clp(256,b); *out++ = clp(256,g); *out++ = clp(256,r); ++out;",
 136     },
 137   },
 138   "bgr161616": {
 139     "i8": {
 140       "r": " int b = *inp++>>8, g = *inp++>>8, r = *inp++>>8;",
 141       "w": " *out++ = (r<<8) | r;  *out++ = (g<<8) | g;  *out++ = (b<<8) | b;"
 142     },
 143     "i16": {
 144       "r": " int b = *inp++, g = *inp++, r = *inp++;",
 145       "w": " *out++ = b; *out++ = g; *out++ = r;",
 146     },
 147     "fp": {
 148       "r": " float b = fclp(*inp++,65536), g=fclp(*inp++,65536), r = fclp(*inp++,65536);",
 149       "w": " *out++ = clp(65536,b); *out++ = clp(65536,g); *out++ = clp(65536,r);",
 150     },
 151   },
 152   "bgrfloat": {
 153     "i8": {
 154       "r": " int b = clp(256,*inp++), g = clp(256,*inp++), r = clp(256,*inp++);",
 155       "w": " *out++ = fclp(b,256); *out++ = fclp(g,256); *out++ = fclp(r,256);",
 156     },
 157     "i16": {
 158       "r": " int b = clp(65536,*inp++), g = clp(65536,*inp++), r = clp(65536,*inp++);",
 159       "w": " *out++ = fclp(b,65536); *out++ = fclp(g,65536); *out++ = fclp(r,65536);",
 160     },
 161     "fp": {
 162       "r": " float b = *inp++, g=*inp++, r = *inp++;",
 163       "w": " *out++ = b; *out++ = g; *out++ = r;",
 164     },
 165   },
 166
 167   "yuv888": {
 168     "i8": {
 169       "r": " int32_t y = *inp++, u = *inp++, v = *inp++;",
 170       "w": " *out++ = y; *out++ = u; *out++ = v;",
 171     },
 172     "i16": {
 173       "r": " int32_t iy = *inp++, y = (iy<<8) | iy, u = *inp++<<8, v = *inp++<<8;",
 174       "w": " *out++ = y>>8; *out++ = u>>8; *out++ = v>>8;",
 175     },
 176   },
 177   "yuv161616": {
 178     "i8": {
 179       "r": " int32_t y = *inp++>>8, u = *inp++>>8, v = *inp++>>8;",
 180       "w": " *out++ = (y<<8) | y; *out++ = u<<8; *out++ = v<<8;",
 181     },
 182     "i16": {
 183       "r": " int32_t y = *inp++, u = *inp++, v = *inp++;",
 184       "w": " *out++ = y; *out++ = u; *out++ = v;",
 185     },
 186   },
 187
 188   "yuyv8888": {
 189     "i8": {
 190       "r": " int32_t y = inp[(j&1)<<1], u = inp[1], v = inp[3];",
 191       "w": " if( !(j&1) ) { *out++ = y; *out = u; out[2] = v; }\n" +
 192            " else { *out++ = u; *out++= y; *out++ = v; }",
 193     },
 194     "i16": {
 195       "r": " int32_t iy = inp[(j&1)<<1], y = (iy<<8) | iy, u = inp[1]<<8, v = inp[3]<<8;",
 196       "w": " if( !(j&1) ) { *out++ = y>>8; *out = u>>8; out[2] = v>>8; }\n" +
 197            " else { *out++ = u>>8; *out++= y>>8; *out++ = v>>8; }",
 198     },
 199   },
 200
 201   "uyvy8888": {
 202     "i8": {
 203       "r": " int32_t u = inp[0], y = inp[((j&1)<<1)+1], v = inp[2];",
 204       "w": " if( !(j&1) ) { *out++ = u; *out++ = y; *out++ = v; *out = y; }\n" +
 205            " else { *out++= y; }",
 206     },
 207     "i16": {
 208       "r": " int32_t u = inp[0]<<8, iy = inp[((j&1)<<1)+1], y = (iy<<8) | iy, v = inp[2]<<8;",
 209       "w": " if( !(j&1) ) { *out++ = u>>8; *out++ = y>>8; *out++ = v>>8; *out = y>>8; }\n" +
 210            " else { *out++= y>>8; }",
 211     },
 212   },
 213
 214   "yuv10101010": {
 215     "i8": {
 216       "r": " uint32_t it = *(uint32_t*)inp;\n" +
 217            " int32_t y = (it>>24)&0xffu, u = (it>>14)&0xffu, v = (it>>4)&0xffu;",
 218       "w": " uint32_t ot = (y<<24) | (u<<14) | (v<<4);\n" +
 219            " *(uint32_t*)out = ot; out += sizeof(uint32_t)/sizeof(*out);",
 220     },
 221     "i16": {
 222       "r": " uint32_t it = *(uint32_t*)inp;\n" +
 223            " int32_t y = (it>>16)&0xffc0u, u = (it>>6)&0xffc0u, v = (it<<4)&0xffc0u;",
 224       "w": " uint32_t ot = ((y&0xffc0u)<<16) | ((u&0xffc0u)<<6) | ((v&0xffc0u)>>4);\n" +
 225            " *(uint32_t*)out = ot; out += sizeof(uint32_t)/sizeof(*out);",
 226     },
 227   },
 228
 229   "vyu888": {
 230     "i8": {
 231       "r": " int32_t v = *inp++, y = *inp++, u = *inp++;",
 232       "w": " *out++ = v; *out++ = y; *out++ = u;",
 233     },
 234     "i16": {
 235       "r": " int32_t v = *inp++<<8, iy = *inp++, y = (iy<<8) | iy, u = *inp++<<8;",
 236       "w": " *out++ = v>>8; *out++ = y>>8; *out++ = u>>8;",
 237     },
 238   },
 239
 240   "uyv888": {
 241     "i8": {
 242       "r": " int32_t u = *inp++, y = *inp++, v = *inp++;",
 243       "w": " *out++ = u; *out++ = y; *out++ = v;",
 244     },
 245     "i16": {
 246       "r": " int32_t u = *inp++<<8, iy = *inp++, y = (iy<<8) | iy, v = *inp++<<8;",
 247       "w": " *out++ = u>>8; *out++ = y>>8; *out++ = v>>8;",
 248     },
 249   },
 250
 251   "yuv420p": {
 252     "i8": {
 253       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 254       "w": " yop[j] = y;  uop[j/2] = u;  vop[j/2] = v;",
 255     },
 256     "i16": {
 257       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 258       "w": " yop[j] = y>>8;  uop[j/2] = u>>8;  vop[j/2] = v>>8;",
 259     },
 260   },
 261   "yuv420pi": {
 262     "i8": {
 263       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 264       "w": " yop[j] = y;  uop[j/2] = u;  vop[j/2] = v;",
 265     },
 266     "i16": {
 267       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 268       "w": " yop[j] = y>>8;  uop[j/2] = u>>8;  vop[j/2] = v>>8;",
 269     },
 270   },
 271
 272   "yuv422p": {
 273     "i8": {
 274       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 275       "w": " yop[j] = y;  uop[j/2] = u;  vop[j/2] = v;",
 276     },
 277     "i16": {
 278       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 279       "w": " yop[j] = y>>8;  uop[j/2] = u>>8;  vop[j/2] = v>>8;",
 280     },
 281   },
 282
 283   "yuv444p": {
 284     "i8": {
 285       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 286       "w": " yop[j] = y;  uop[j] = u;  vop[j] = v;",
 287     },
 288     "i16": {
 289       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 290       "w": " yop[j] = y>>8;  uop[j] = u>>8;  vop[j] = v>>8;",
 291     },
 292   },
 293
 294   "yuv411p": {
 295     "i8": {
 296       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 297       "w": " yop[j] = y;  uop[j/4] = u;  vop[j/4] = v;",
 298     },
 299     "i16": {
 300       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 301       "w": " yop[j] = y>>8;  uop[j/4] = u>>8;  vop[j/4] = v>>8;",
 302     },
 303   },
 304
 305   "yuv410p": {
 306     "i8": {
 307       "r": " int32_t y = *yip, u = *uip, v = *vip;",
 308       "w": " yop[j] = y;  uop[j/4] = u;  vop[j/4] = v;",
 309     },
 310     "i16": {
 311       "r": " int32_t iy = *yip, y = (iy<<8) | iy, u = *uip<<8, v = *vip<<8;",
 312       "w": " yop[j] = y>>8;  uop[j/4] = u>>8;  vop[j/4] = v>>8;",
 313     },
 314   },
 315
 316   "rgbfltp": {
 317     "i8": {
 318       "r": " int r = clp(256,*rip++), g = clp(256,*gip++), b = clp(256,*bip++);",
 319       "w": " *rop++ = fclp(r,256); *gop++ = fclp(g,256); *bop++ = fclp(b,256);",
 320     },
 321     "i16": {
 322       "r": " int r = clp(65536,*rip++), g = clp(65536,*gip++), b = clp(65536,*bip++);",
 323       "w": " *rop++ = fclp(r,65536); *gop++ = fclp(g,65536); *bop++ = fclp(b,65536);",
 324     },
 325     "fp": {
 326       "r": " float r = *rip++, g = *gip++, b = *bip++;",
 327       "w": " *rop++ = r; *gop++ = g; *bop++ = b;",
 328     },
 329   },
 330
 331   "gbrp": {
 332     "i8": {
 333       "r": " int g = *rip++, b = *gip++, r = *bip++;",
 334       "w": " *rop++ = g; *gop++ = b; *bop++ = r;",
 335     },
 336     "i16": {
 337       "r": " int ig = *rip++, g = (ig<<8) | ig, ib = *gip++, b = (ib<<8) | ib," +
 338            " ir = *bip++, r = (ir<<8) | ir;",
 339       "w": " *rop++ = g >> 8; *gop++ = b >> 8; *bop++ = r >> 8;",
 340     },
 341     "fp": {
 342       "r": " float g = *rip++/255.f, b = *gip++/255.f, r = *bip++/255.f;",
 343       "w": " *rop++ = clp(256,g); *gop++ = clp(256,b); *bop++ = clp(256,r);",
 344     },
 345   },
 346
 347   "grey8": {
 348     "i8": {
 349       "r": " int32_t y = *inp++, u = 0x80, v = 0x80;",
 350       "w": " *out++ = y; (void)u; (void)v;",
 351     },
 352     "i16": {
 353       "r": " int32_t iy = *inp++, y = (iy<<8) | iy, u = 0x8000, v = 0x8000;",
 354       "w": " *out++ = y>>8; (void)u; (void)v;",
 355     },
 356   },
 357
 358   "grey16": {
 359     "i8": {
 360       "r": " int32_t y = *inp++>>8, u = 0x80, v = 0x80;",
 361       "w": " *out++ = (y<<8) | y; (void)u; (void)v;",
 362     },
 363     "i16": {
 364       "r": " int32_t y = *inp++, u = 0x8000, v = 0x8000;",
 365       "w": " *out++ = y; (void)u; (void)v;",
 366     },
 367   },
 368
 369   # alpha component
 370   "a8": {
 371     "i8": {
 372       "r": " z_int a = *inp++;",
 373       "w": " *out++ = a;",
 374     },
 375     "i16": {
 376       "r": " z_int a = *inp++; a = (a<<8) | a;",
 377       "w": " *out++ = a>>8;",
 378     },
 379     "fp": {
 380       "r": " z_float fa = fclp(*inp++,256);",
 381       "w": " *out++ = clp(256,a)",
 382     },
 383   },
 384   "a16": {
 385     "i8": {
 386       "r": " z_int a = *inp++>>8;",
 387       "w": " *out++ = (a<<8) | a;",
 388     },
 389     "i16": {
 390       "r": " z_int a = *inp++;",
 391       "w": " *out++ = a;",
 392     },
 393     "fp": {
 394       "r": " z_float fa = fclp(*inp++,65536);",
 395       "w": " *out++ = clp(65536,a);",
 396     },
 397   },
 398   "afp": {
 399     "i8": {
 400       "r": " z_int a = clp(256,*inp++);",
 401       "w": " *out++ = fclp(a,256);",
 402     },
 403     "i16": {
 404       "r": " z_int a = clp(65536,*inp++);",
 405       "w": " *out++ = fclp(a,65536);",
 406     },
 407     "fp": {
 408       "r": " z_float fa = *inp++;",
 409       "w": " *out++ = fa;",
 410     },
 411   },
 412   "afpp": {
 413     "i8": {
 414       "r": " z_int a = clp(256,*aip++);",
 415       "w": " *aop++ = fclp(a,256);",
 416     },
 417     "i16": {
 418       "r": " z_int a = clp(65536,*aip++);",
 419       "w": " *aop++ = fclp(a,65536);",
 420     },
 421     "fp": {
 422       "r": " z_float fa = *aip++;",
 423       "w": " *aop++ = fa;",
 424     },
 425   },
 426   # no src alpha blend
 427   "x8": {
 428     "i8": {
 429       "r": " ++inp;",
 430       "w": " *out++ = 0xff;",
 431     },
 432     "i16": {
 433       "r": " ++inp;",
 434       "w": " *out++ = 0xff;",
 435     },
 436     "fp": {
 437       "r": " ++inp;",
 438       "w": " *out++ = 0xff;",
 439     },
 440   },
 441   "x16": {
 442     "i8": {
 443       "r": " ++inp;",
 444       "w": " *out++ = 0xffff;",
 445     },
 446     "i16": {
 447       "r": " ++inp;",
 448       "w": " *out++ = 0xffff;",
 449     },
 450     "fp": {
 451       "r": " ++inp;",
 452       "w": " *out++ = 0xffff;",
 453     },
 454   },
 455   "xfp": {
 456     "i8": {
 457       "r": " ++inp;",
 458       "w": " *out++ = 1.f;",
 459     },
 460     "i16": {
 461       "r": " ++inp;",
 462       "w": " *out++ = 1.f;",
 463     },
 464     "fp": {
 465       "r": " ++inp;",
 466       "w": " *out++ = 1.f;",
 467     },
 468   },
 469   # alpha blend rgb/black, yuv/black, rgb/bg_color
 470   "brgb": {
 471     "i8": " r = r*a/0xffu; g = g*a/0xffu; b = b*a/0xffu;",
 472     "i16": " r = r*a/0xffffu; g = g*a/0xffffu; b = b*a/0xffffu;",
 473     "fp": " r *= fa; g *= fa; b *= fa;",
 474   },
 475   "byuv": {
 476     "i8": " z_int a1 = 0xffu-a;\n" +
 477           " y = y*a/0xffu; u = (u*a + 0x80u*a1)/0xffu; v = (v*a + 0x80u*a1)/0xffu;",
 478     "i16": " z_int a1 = 0xffffu-a;\n" +
 479            " y = y*a/0xffffu; u = (u*a + 0x8000u*a1)/0xffffu; v = (v*a + 0x8000u*a1)/0xffffu;",
 480   },
 481   "bbg": {
 482     "i8": " int a1 = 0xffu-a;\n" +
 483         " r = (r*a + bg_r*a1)/0xffu; g = (g*a + bg_g*a1)/0xffu; b = (b*a + bg_b*a1)/0xffu;",
 484     "i16": "int a1 = 0xffffu-a;\n" +
 485         " r = (r*a + bg_r*a1)/0xffffu; g = (g*a + bg_g*a1)/0xffffu; b = (b*a + bg_b*a1)/0xffffu;",
 486     "fp": " float a1 = 1-fa;\n" +
 487         " r = (r*fa + bg_r*a1); g = (g*fa + bg_g*a1); b = (b*fa + bg_b*a1);",
 488   },
 489 }
 490
 491 cmodels = []
 492 bcmodels = {}
 493 layout = {}
 494 dtype = { None: None }
 495 special = {}
 496 mx_bcmdl = -1
 497
 498 def add_cmodel(n, nm, typ=None, *args):
 499   global cmodels, bcmodels, layout, dtype, mx_bcmdl
 500   cmodels += [nm,]
 501   bcmodels[n] = nm
 502   if( n > mx_bcmdl ): mx_bcmdl = n
 503   dtype[nm] = typ
 504   layout[nm] = args
 505
 506 def specialize(fr_cmdl, to_cmdl, fn):
 507   global special
 508   special[(fr_cmdl, to_cmdl)] = fn
 509
 510 add_cmodel( 0, "bc_transparency")
 511 add_cmodel( 1, "bc_compressed")
 512
 513 add_cmodel( 2, "bc_rgb8", "i8", "rgb8")
 514 add_cmodel( 3, "bc_rgb565", "i8", "rgb565")
 515 add_cmodel( 4, "bc_bgr565", "i8", "bgr565")
 516 add_cmodel( 5, "bc_bgr888", "i8", "bgr888")
 517 add_cmodel( 6, "bc_bgr8888", "i8", "bgr8888")
 518
 519 add_cmodel( 9, "bc_rgb888", "i8", "rgb888")
 520 add_cmodel(10, "bc_rgba8888", "i8", "rgb888", "a8")
 521 add_cmodel(20, "bc_argb8888", "i8", "a8", "rgb888")
 522 add_cmodel(21, "bc_abgr8888", "i8", "a8", "bgr888")
 523 add_cmodel(11, "bc_rgb161616", "i16", "rgb161616")
 524 add_cmodel(12, "bc_rgba16161616", "i16", "rgb161616", "a16")
 525 add_cmodel(13, "bc_yuv888", "i8", "yuv888")
 526 add_cmodel(14, "bc_yuva8888", "i8", "yuv888", "a8")
 527 add_cmodel(15, "bc_yuv161616", "i16", "yuv161616")
 528 add_cmodel(16, "bc_yuva16161616", "i16", "yuv161616", "a16")
 529 add_cmodel(35, "bc_ayuv16161616", "i16", "a16", "yuv161616")
 530
 531 add_cmodel(18, "bc_uvy422", "i8", "uyvy8888")
 532 add_cmodel(19, "bc_yuv422", "i8", "yuyv8888")
 533 add_cmodel(22, "bc_a8")
 534 add_cmodel(23, "bc_a16")
 535 add_cmodel(31, "bc_a_float")
 536 add_cmodel(24, "bc_yuv101010", "i16", "yuv10101010")
 537 add_cmodel(25, "bc_vyu888", "i8", "vyu888")
 538 add_cmodel(26, "bc_uyva8888", "i8", "uyv888", "a8")
 539 add_cmodel(29, "bc_rgb_float", "fp", "rgbfloat")
 540 add_cmodel(30, "bc_rgba_float", "fp", "rgbfloat", "afp")
 541
 542 add_cmodel( 7, "bc_yuv420p", "i8", "yuv420p")
 543 add_cmodel( 8, "bc_yuv422p", "i8", "yuv422p")
 544 add_cmodel(27, "bc_yuv444p", "i8", "yuv444p")
 545 add_cmodel(17, "bc_yuv411p", "i8", "yuv411p")
 546 add_cmodel(28, "bc_yuv410p", "i8", "yuv410p")
 547 add_cmodel(32, "bc_rgb_floatp", "fp", "rgbfltp")
 548 add_cmodel(33, "bc_rgba_floatp", "fp", "rgbfltp", "afpp")
 549 add_cmodel(34, "bc_yuv420pi", "i8", "yuv420pi")
 550
 551 add_cmodel(36, "bc_grey8", "i8", "grey8")
 552 add_cmodel(37, "bc_grey16", "i16", "grey16")
 553 add_cmodel(38, "bc_gbrp", "i8", "gbrp")
 554
 555 add_cmodel(39, "bc_rgbx8888", "i8", "rgb888", "x8")
 556 add_cmodel(40, "bc_rgbx16161616", "i16", "rgb161616", "x16")
 557 add_cmodel(41, "bc_yuvx8888", "i8", "yuv888", "x8")
 558 add_cmodel(42, "bc_yuvx16161616", "i16", "yuv161616", "x16")
 559 add_cmodel(43, "bc_rgbx_float", "fp", "rgbfloat", "xfp")
 560
 561 specialize("bc_rgba8888", "bc_transparency", "XFER_rgba8888_to_transparency")
 562
 563 ctype = {
 564   "i8": "uint8_t",
 565   "i16": "uint16_t",
 566   "fp": "float",
 567 }
 568
 569 adata = {
 570   "i8": " z_int a=0xff;",
 571   "i16": " z_int a=0xffff;",
 572   "fp": " z_float fa=1;",
 573 }
 574
 575 def has_alpha(nm):
 576   return nm in ["bc_rgba8888", "bc_argb8888", "bc_abgr8888", \
 577     "bc_rgba16161616", "bc_yuva8888", "bc_yuva16161616", "bc_ayuv16161616", \
 578     "bc_uyva8888", "bc_rgba_float", "bc_rgba_floatp",]
 579
 580 def has_bgcolor(fr_cmdl,to_cmdl):
 581   return fr_cmdl in ["bc_rgba8888"] and \
 582     to_cmdl in ["bc_rgba888", "bc_bgr565", "bc_rgb565", \
 583      "bc_bgr888", "bc_rgb888", "bc_bgr8888"]
 584
 585 def is_specialized(fr_cmdl,to_cmdl):
 586   global special
 587   return special.get((fr_cmdl, to_cmdl)) is not None
 588
 589 def is_rgb(nm):
 590   return nm in [ "bc_rgb8", "bc_rgb565", "bc_bgr565", \
 591     "bc_bgr888", "bc_bgr8888", "bc_rgb888", "bc_rgba8888", \
 592     "bc_argb8888", "bc_abgr8888", "bc_rgb", "bc_rgb161616", \
 593     "bc_rgba16161616", "bc_rgb_float", "bc_rgba_float", \
 594     "bc_rgb_floatp", "bc_rgba_floatp", "bc_gbrp", \
 595     "bc_rgbx8888", "bc_rgbx16161616", "bc_rgbx_float", ]
 596
 597 def is_yuv(nm):
 598   return nm in [ "bc_yuv888", "bc_yuva8888", "bc_yuv161616", \
 599     "bc_yuva16161616", "bc_ayuv16161616", "bc_yuv422", "bc_uvy422", "bc_yuv101010", \
 600     "bc_vyu888", "bc_uyva8888", "bc_yuv420p", "bc_yuv420pi", "bc_yuv422p", \
 601     "bc_yuv444p", "bc_yuv411p", "bc_yuv410p", "bc_grey8", "bc_grey16", \
 602     "bc_yuvx8888", "bc_yuvx16161616", ]
 603
 604 def is_planar(nm):
 605   return nm in [ "bc_yuv420p", "bc_yuv420pi", "bc_yuv422p", "bc_yuv444p", \
 606     "bc_yuv411p", "bc_yuv410p", "bc_rgb_floatp", "bc_rgba_floatp", "bc_gbrp", ]
 607
 608 def is_float(nm):
 609   return nm in [ "bc_rgb_float", "bc_rgba_float", "bc_rgbx_float", \
 610     "bc_rgb_floatp", "bc_rgba_floatp", ]
 611
 612 def gen_xfer_proto(fd, pfx, cls, fr_cmdl, to_cmdl):
 613   global dtype, ctype
 614   print("%svoid %sxfer_%s_to_%s" % (pfx, cls, fr_cmdl[3:], to_cmdl[3:]), end=' ', file=fd)
 615   ityp = dtype[fr_cmdl];  fr_typ = ctype[ityp];
 616   otyp = dtype[to_cmdl];  to_typ = ctype[otyp];
 617   print("(unsigned y0, unsigned y1)", end=' ', file=fd)
 618
 619 def gen_xfer_fn(fd, fr_cmdl, to_cmdl):
 620   global layout, dtype, adata
 621   ityp = dtype[fr_cmdl];  otyp = dtype[to_cmdl]
 622   if( ityp is None or otyp is None ): return
 623   # xfr fn header
 624   gen_xfer_proto(fd, "", class_qual, fr_cmdl, to_cmdl);
 625   # xfr fn body
 626   print("{", file=fd)
 627   # loops / pointer preload
 628   in_xfer = "flat" if not is_planar(fr_cmdl) else \
 629     fr_cmdl[3:] if is_yuv(fr_cmdl) else \
 630     "rgbp" if not has_alpha(fr_cmdl) else "rgbap"
 631   out_xfer = "flat" if not is_planar(to_cmdl) else \
 632     to_cmdl[3:] if is_yuv(to_cmdl) else \
 633     "rgbp" if not has_alpha(to_cmdl) else "rgbap"
 634   print(" xfer_%s_row_out(%s) xfer_%s_row_in(%s)" % (out_xfer, ctype[otyp], in_xfer, ctype[ityp]), file=fd)
 635
 636   # load inp
 637   if( is_float(to_cmdl) and is_yuv(fr_cmdl) ):
 638     for ic in layout[fr_cmdl]: print("%s" % (base[ic][ityp]['r']), end=' ', file=fd)
 639     if( ityp == "i8" ):
 640       print("\n float r, g, b; YUV::yuv.yuv_to_rgb_8(r, g, b, y, u, v);", end=' ', file=fd)
 641     elif( ityp == "i16" ):
 642       print("\n float r, g, b; YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);", end=' ', file=fd)
 643     if( has_alpha(fr_cmdl) or has_alpha(to_cmdl) ):
 644       if( not has_alpha(fr_cmdl) ):
 645         print(" z_float fa = 1;", end=' ', file=fd)
 646       elif( ityp == "i8" ):
 647         print(" float fa = fclp(a,256);", end=' ', file=fd)
 648       elif( ityp == "i16" ):
 649         print(" float fa = fclp(a,65536);", end=' ', file=fd)
 650   else:
 651     for ic in layout[fr_cmdl]: print("%s" % (base[ic][otyp]['r']), end=' ', file=fd)
 652     if( has_alpha(to_cmdl) and not has_alpha(fr_cmdl) ):
 653       print("%s" % (adata[otyp]), end=' ', file=fd)
 654   print("", file=fd)
 655   # xfer
 656   if( is_rgb(fr_cmdl) and is_yuv(to_cmdl) ):
 657     if( otyp == "i8" ):
 658       print(" int32_t y, u, v;  YUV::yuv.rgb_to_yuv_8(r, g, b, y, u, v);", file=fd)
 659     elif( otyp == "i16" ):
 660       print(" int32_t y, u, v;  YUV::yuv.rgb_to_yuv_16(r, g, b, y, u, v);", file=fd)
 661   elif( is_yuv(fr_cmdl) and is_rgb(to_cmdl)):
 662     if( otyp == "i8" ):
 663       print(" int32_t r, g, b;  YUV::yuv.yuv_to_rgb_8(r, g, b, y, u, v);", file=fd)
 664     elif( otyp == "i16" ):
 665       print(" int32_t r, g, b;  YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v);", file=fd)
 666   # blend
 667   if( has_bgcolor(fr_cmdl,to_cmdl) ):
 668     print("%s" % (base["bbg"][otyp]), file=fd)
 669   elif( has_alpha(fr_cmdl) and not has_alpha(to_cmdl) ):
 670     if( is_rgb(to_cmdl) ):
 671       print("%s" % (base["brgb"][otyp]), file=fd)
 672     elif( is_yuv(to_cmdl) ):
 673       print("%s" % (base["byuv"][otyp]), file=fd)
 674   # store out
 675   for oc in layout[to_cmdl]:
 676     print("%s" % (base[oc][otyp]['w']), end=' ', file=fd)
 677   print("xfer_end", file=fd)
 678   print("}", file=fd)
 679   print("", file=fd)
 680
 681 # output code file
 682 class_qual = "BC_Xfer::"
 683 xfn = "xfer/xfer.h"
 684 fd = open(xfn, "w")
 685 xid = "".join([chr(x) if chr(x).isalnum() else '_' for x in range(256)])
 686 xid = "__" + xfn.upper()[xfn.rfind("/")+1:].translate(xid) + "__"
 687 print("#ifndef %s" % xid, file=fd)
 688 print("#define %s" % xid, file=fd)
 689 print("", file=fd)
 690 xfd = open("bcxfer.h")
 691 fd.write(xfd.read())
 692 xfd.close()
 693
 694 for fr_cmdl in cmodels:
 695   ityp = dtype[fr_cmdl]
 696   for to_cmdl in cmodels:
 697     otyp = dtype[to_cmdl]
 698     if( is_specialized(fr_cmdl, to_cmdl) ):
 699       print("  void %s(unsigned y0, unsigned y1);" % (special[(fr_cmdl, to_cmdl)]), file=fd)
 700       continue
 701     if( ityp is None or otyp is None ): continue
 702     gen_xfer_proto(fd, "  ", "", fr_cmdl, to_cmdl);
 703     print(";", file=fd)
 704 # end of class definition
 705 print("};", file=fd)
 706 print("", file=fd)
 707 print("#endif", file=fd)
 708 fd.close()
 709 xfn = xfn[:xfn.rfind(".h")]
 710
 711 # xfer functions
 712 for fr_cmdl in cmodels:
 713   fd = open(xfn + "_" + fr_cmdl + ".C", "w")
 714   print("#include \"xfer.h\"", file=fd)
 715   print("", file=fd)
 716   for to_cmdl in cmodels:
 717     gen_xfer_fn(fd, fr_cmdl, to_cmdl)
 718   fd.close()
 719
 720 fd = open(xfn + ".C", "w")
 721 # transfer switch
 722 print("#include \"xfer.h\"", file=fd)
 723 print("", file=fd)
 724 print("void %sxfer()" % class_qual, file=fd)
 725 print("{", file=fd)
 726 mx_no = mx_bcmdl + 1
 727 print("  static xfer_fn xfns[%d][%d] = {" % (mx_no, mx_no), file=fd)
 728 for fr_no in range(mx_no):
 729   fr_cmdl = bcmodels.get(fr_no)
 730   ityp = dtype[fr_cmdl]
 731   print("  { // %s" % (fr_cmdl.upper() if ityp else "None"), file=fd)
 732   n = 0
 733   for to_no in range(mx_no):
 734     to_cmdl = bcmodels.get(to_no)
 735     otyp = dtype[to_cmdl]
 736     xfn = special[(fr_cmdl, to_cmdl)] if( is_specialized(fr_cmdl, to_cmdl) ) else \
 737       "xfer_%s_to_%s" % (fr_cmdl[3:], to_cmdl[3:]) if ( ityp and otyp ) else None
 738     if( n > 72 ): print("", file=fd); n = 0
 739     if( n == 0 ): print("   ", end=' ', file=fd); n += 4
 740     fn = "&%s%s" % (class_qual, xfn) if( xfn ) else "0"
 741     print("%s, " % (fn), end=' ', file=fd)
 742     n += len(fn) + 3
 743   print("}, ", file=fd)
 744 print("  }; ", file=fd)
 745 print("  xfn = xfns[in_colormodel][out_colormodel];", file=fd)
 746 print("  xfer_slices(out_w*out_h/0x80000+1);", file=fd)
 747 print("}", file=fd)
 748 print("", file=fd)
 749 print("#include \"bcxfer.C\"", file=fd)
 750 print("", file=fd)
 751 fd.close()