src/mesa/state_tracker/st_tgsi_lower_yuv.c

   1 /*
   2  * Copyright © 2016 Red Hat
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #include <stdbool.h>
  25
  26 #include "st_tgsi_lower_yuv.h"
  27 #include "tgsi/tgsi_transform.h"
  28 #include "tgsi/tgsi_scan.h"
  29 #include "tgsi/tgsi_dump.h"
  30 #include "util/u_debug.h"
  31
  32 #include "util/bitscan.h"
  33
  34 struct tgsi_yuv_transform {
  35    struct tgsi_transform_context base;
  36    struct tgsi_shader_info info;
  37    struct tgsi_full_src_register imm[4];
  38    struct {
  39       struct tgsi_full_src_register src;
  40       struct tgsi_full_dst_register dst;
  41    } tmp[2];
  42 #define A 0
  43 #define B 1
  44
  45    /* Maps a primary sampler (used for Y) to the U or UV sampler.  In
  46     * case of 3-plane YUV format, the V plane is next sampler after U.
  47     */
  48    unsigned char sampler_map[PIPE_MAX_SAMPLERS][2];
  49
  50    bool first_instruction_emitted;
  51    unsigned free_slots;
  52    unsigned lower_nv12;
  53    unsigned lower_iyuv;
  54 };
  55
  56 static inline struct tgsi_yuv_transform *
  57 tgsi_yuv_transform(struct tgsi_transform_context *tctx)
  58 {
  59    return (struct tgsi_yuv_transform *)tctx;
  60 }
  61
  62 static void
  63 reg_dst(struct tgsi_full_dst_register *dst,
  64         const struct tgsi_full_dst_register *orig_dst, unsigned wrmask)
  65 {
  66    *dst = *orig_dst;
  67    dst->Register.WriteMask &= wrmask;
  68    assert(dst->Register.WriteMask);
  69 }
  70
  71 static inline void
  72 get_swiz(unsigned *swiz, const struct tgsi_src_register *src)
  73 {
  74    swiz[0] = src->SwizzleX;
  75    swiz[1] = src->SwizzleY;
  76    swiz[2] = src->SwizzleZ;
  77    swiz[3] = src->SwizzleW;
  78 }
  79
  80 static void
  81 reg_src(struct tgsi_full_src_register *src,
  82         const struct tgsi_full_src_register *orig_src,
  83         unsigned sx, unsigned sy, unsigned sz, unsigned sw)
  84 {
  85    unsigned swiz[4];
  86    get_swiz(swiz, &orig_src->Register);
  87    *src = *orig_src;
  88    src->Register.SwizzleX = swiz[sx];
  89    src->Register.SwizzleY = swiz[sy];
  90    src->Register.SwizzleZ = swiz[sz];
  91    src->Register.SwizzleW = swiz[sw];
  92 }
  93
  94 #define TGSI_SWIZZLE__ TGSI_SWIZZLE_X  /* don't-care value! */
  95 #define SWIZ(x,y,z,w) TGSI_SWIZZLE_ ## x, TGSI_SWIZZLE_ ## y,   \
  96       TGSI_SWIZZLE_ ## z, TGSI_SWIZZLE_ ## w
  97
  98 static inline struct tgsi_full_instruction
  99 tex_instruction(unsigned samp)
 100 {
 101    struct tgsi_full_instruction inst;
 102
 103    inst = tgsi_default_full_instruction();
 104    inst.Instruction.Opcode = TGSI_OPCODE_TEX;
 105    inst.Instruction.Texture = 1;
 106    inst.Texture.Texture = TGSI_TEXTURE_2D;
 107    inst.Instruction.NumDstRegs = 1;
 108    inst.Instruction.NumSrcRegs = 2;
 109    inst.Src[1].Register.File  = TGSI_FILE_SAMPLER;
 110    inst.Src[1].Register.Index = samp;
 111
 112    return inst;
 113 }
 114
 115 static inline struct tgsi_full_instruction
 116 mov_instruction(void)
 117 {
 118    struct tgsi_full_instruction inst;
 119
 120    inst = tgsi_default_full_instruction();
 121    inst.Instruction.Opcode = TGSI_OPCODE_MOV;
 122    inst.Instruction.Saturate = 0;
 123    inst.Instruction.NumDstRegs = 1;
 124    inst.Instruction.NumSrcRegs = 1;
 125
 126    return inst;
 127 }
 128
 129 static inline struct tgsi_full_instruction
 130 dp3_instruction(void)
 131 {
 132    struct tgsi_full_instruction inst;
 133
 134    inst = tgsi_default_full_instruction();
 135    inst.Instruction.Opcode = TGSI_OPCODE_DP3;
 136    inst.Instruction.NumDstRegs = 1;
 137    inst.Instruction.NumSrcRegs = 2;
 138
 139    return inst;
 140 }
 141
 142
 143
 144 static void
 145 emit_immed(struct tgsi_transform_context *tctx, int idx,
 146            float x, float y, float z, float w)
 147 {
 148    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 149    struct tgsi_shader_info *info = &ctx->info;
 150    struct tgsi_full_immediate immed;
 151
 152    immed = tgsi_default_full_immediate();
 153    immed.Immediate.NrTokens = 1 + 4; /* one for the token itself */
 154    immed.u[0].Float = x;
 155    immed.u[1].Float = y;
 156    immed.u[2].Float = z;
 157    immed.u[3].Float = w;
 158    tctx->emit_immediate(tctx, &immed);
 159
 160    ctx->imm[idx].Register.File = TGSI_FILE_IMMEDIATE;
 161    ctx->imm[idx].Register.Index = info->immediate_count + idx;
 162    ctx->imm[idx].Register.SwizzleX = TGSI_SWIZZLE_X;
 163    ctx->imm[idx].Register.SwizzleY = TGSI_SWIZZLE_Y;
 164    ctx->imm[idx].Register.SwizzleZ = TGSI_SWIZZLE_Z;
 165    ctx->imm[idx].Register.SwizzleW = TGSI_SWIZZLE_W;
 166 }
 167
 168 static void
 169 emit_samp(struct tgsi_transform_context *tctx, unsigned samp)
 170 {
 171    tgsi_transform_sampler_decl(tctx, samp);
 172    tgsi_transform_sampler_view_decl(tctx, samp, PIPE_TEXTURE_2D,
 173                                     TGSI_RETURN_TYPE_FLOAT);
 174 }
 175
 176 /* Emit extra declarations we need:
 177  *  + 2 TEMP to hold intermediate results
 178  *  + 1 (for 2-plane YUV) or 2 (for 3-plane YUV) extra samplers per
 179  *    lowered YUV sampler
 180  *  + extra immediates for doing CSC
 181  */
 182 static void
 183 emit_decls(struct tgsi_transform_context *tctx)
 184 {
 185    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 186    struct tgsi_shader_info *info = &ctx->info;
 187    unsigned mask, tempbase, i;
 188    struct tgsi_full_declaration decl;
 189
 190    /*
 191     * Declare immediates for CSC conversion:
 192     */
 193
 194    /* ITU-R BT.601 conversion */
 195    emit_immed(tctx, 0, 1.164,  0.000,  1.596,  0.0);
 196    emit_immed(tctx, 1, 1.164, -0.392, -0.813,  0.0);
 197    emit_immed(tctx, 2, 1.164,  2.017,  0.000,  0.0);
 198    emit_immed(tctx, 3, 0.0625, 0.500,  0.500,  1.0);
 199
 200    /*
 201     * Declare extra samplers / sampler-views:
 202     */
 203
 204    mask = ctx->lower_nv12 | ctx->lower_iyuv;
 205    while (mask) {
 206       unsigned extra, y_samp = u_bit_scan(&mask);
 207
 208       extra = u_bit_scan(&ctx->free_slots);
 209       ctx->sampler_map[y_samp][0] = extra;
 210       emit_samp(tctx, extra);
 211
 212       if (ctx->lower_iyuv & (1 << y_samp)) {
 213          extra = u_bit_scan(&ctx->free_slots);
 214          ctx->sampler_map[y_samp][1] = extra;
 215          emit_samp(tctx, extra);
 216       }
 217    }
 218
 219    /*
 220     * Declare extra temp:
 221     */
 222
 223    tempbase = info->file_max[TGSI_FILE_TEMPORARY] + 1;
 224
 225    for (i = 0; i < 2; i++) {
 226       decl = tgsi_default_full_declaration();
 227       decl.Declaration.File = TGSI_FILE_TEMPORARY;
 228       decl.Range.First = decl.Range.Last = tempbase + i;
 229       tctx->emit_declaration(tctx, &decl);
 230
 231       ctx->tmp[i].src.Register.File  = TGSI_FILE_TEMPORARY;
 232       ctx->tmp[i].src.Register.Index = tempbase + i;
 233       ctx->tmp[i].src.Register.SwizzleX = TGSI_SWIZZLE_X;
 234       ctx->tmp[i].src.Register.SwizzleY = TGSI_SWIZZLE_Y;
 235       ctx->tmp[i].src.Register.SwizzleZ = TGSI_SWIZZLE_Z;
 236       ctx->tmp[i].src.Register.SwizzleW = TGSI_SWIZZLE_W;
 237
 238       ctx->tmp[i].dst.Register.File  = TGSI_FILE_TEMPORARY;
 239       ctx->tmp[i].dst.Register.Index = tempbase + i;
 240       ctx->tmp[i].dst.Register.WriteMask = TGSI_WRITEMASK_XYZW;
 241    }
 242 }
 243
 244 /* call with YUV in tmpA.xyz */
 245 static void
 246 yuv_to_rgb(struct tgsi_transform_context *tctx,
 247            struct tgsi_full_dst_register *dst)
 248 {
 249    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 250    struct tgsi_full_instruction inst;
 251
 252    /*
 253     * IMM[0] FLT32 { 1.164,  0.000,  1.596,  0.0 }
 254     * IMM[1] FLT32 { 1.164, -0.392, -0.813,  0.0 }
 255     * IMM[2] FLT32 { 1.164,  2.017,  0.000,  0.0 }
 256     * IMM[3] FLT32 { 0.0625, 0.500,  0.500,  1.0 }
 257     */
 258
 259    /* SUB tmpA.xyz, tmpA, imm[3] */
 260    inst = tgsi_default_full_instruction();
 261    inst.Instruction.Opcode = TGSI_OPCODE_SUB;
 262    inst.Instruction.Saturate = 0;
 263    inst.Instruction.NumDstRegs = 1;
 264    inst.Instruction.NumSrcRegs = 2;
 265    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_XYZ);
 266    reg_src(&inst.Src[0], &ctx->tmp[A].src, SWIZ(X, Y, Z, _));
 267    reg_src(&inst.Src[1], &ctx->imm[3], SWIZ(X, Y, Z, _));
 268    tctx->emit_instruction(tctx, &inst);
 269
 270    /* DP3 dst.x, tmpA, imm[0] */
 271    inst = dp3_instruction();
 272    reg_dst(&inst.Dst[0], dst, TGSI_WRITEMASK_X);
 273    reg_src(&inst.Src[0], &ctx->tmp[A].src, SWIZ(X, Y, Z, W));
 274    reg_src(&inst.Src[1], &ctx->imm[0], SWIZ(X, Y, Z, W));
 275    tctx->emit_instruction(tctx, &inst);
 276
 277    /* DP3 dst.y, tmpA, imm[1] */
 278    inst = dp3_instruction();
 279    reg_dst(&inst.Dst[0], dst, TGSI_WRITEMASK_Y);
 280    reg_src(&inst.Src[0], &ctx->tmp[A].src, SWIZ(X, Y, Z, W));
 281    reg_src(&inst.Src[1], &ctx->imm[1], SWIZ(X, Y, Z, W));
 282    tctx->emit_instruction(tctx, &inst);
 283
 284    /* DP3 dst.z, tmpA, imm[2] */
 285    inst = dp3_instruction();
 286    reg_dst(&inst.Dst[0], dst, TGSI_WRITEMASK_Z);
 287    reg_src(&inst.Src[0], &ctx->tmp[A].src, SWIZ(X, Y, Z, W));
 288    reg_src(&inst.Src[1], &ctx->imm[2], SWIZ(X, Y, Z, W));
 289    tctx->emit_instruction(tctx, &inst);
 290
 291    /* MOV dst.w, imm[0].x */
 292    inst = mov_instruction();
 293    reg_dst(&inst.Dst[0], dst, TGSI_WRITEMASK_W);
 294    reg_src(&inst.Src[0], &ctx->imm[3], SWIZ(_, _, _, W));
 295    tctx->emit_instruction(tctx, &inst);
 296 }
 297
 298 static void
 299 lower_nv12(struct tgsi_transform_context *tctx,
 300            struct tgsi_full_instruction *originst)
 301 {
 302    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 303    struct tgsi_full_instruction inst;
 304    struct tgsi_full_src_register *coord = &originst->Src[0];
 305    unsigned samp = originst->Src[1].Register.Index;
 306
 307    /* sample Y:
 308     *    TEX tempA.x, coord, texture[samp], 2D;
 309     */
 310    inst = tex_instruction(samp);
 311    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_X);
 312    reg_src(&inst.Src[0], coord, SWIZ(X, Y, Z, W));
 313    tctx->emit_instruction(tctx, &inst);
 314
 315    /* sample UV:
 316     *    TEX tempB.xy, coord, texture[sampler_map[samp][0]], 2D;
 317     *    MOV tempA.yz, tempB._xy_
 318     */
 319    inst = tex_instruction(ctx->sampler_map[samp][0]);
 320    reg_dst(&inst.Dst[0], &ctx->tmp[B].dst, TGSI_WRITEMASK_XY);
 321    reg_src(&inst.Src[0], coord, SWIZ(X, Y, Z, W));
 322    tctx->emit_instruction(tctx, &inst);
 323
 324    inst = mov_instruction();
 325    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_YZ);
 326    reg_src(&inst.Src[0], &ctx->tmp[B].src, SWIZ(_, X, Y, _));
 327    tctx->emit_instruction(tctx, &inst);
 328
 329    /* At this point, we have YUV in tempA.xyz, rest is common: */
 330    yuv_to_rgb(tctx, &originst->Dst[0]);
 331 }
 332
 333 static void
 334 lower_iyuv(struct tgsi_transform_context *tctx,
 335            struct tgsi_full_instruction *originst)
 336 {
 337    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 338    struct tgsi_full_instruction inst;
 339    struct tgsi_full_src_register *coord = &originst->Src[0];
 340    unsigned samp = originst->Src[1].Register.Index;
 341
 342    /* sample Y:
 343     *    TEX tempA.x, coord, texture[samp], 2D;
 344     */
 345    inst = tex_instruction(samp);
 346    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_X);
 347    reg_src(&inst.Src[0], coord, SWIZ(X, Y, Z, W));
 348    tctx->emit_instruction(tctx, &inst);
 349
 350    /* sample U:
 351     *    TEX tempB.x, coord, texture[sampler_map[samp][0]], 2D;
 352     *    MOV tempA.y, tempB._x__
 353     */
 354    inst = tex_instruction(ctx->sampler_map[samp][0]);
 355    reg_dst(&inst.Dst[0], &ctx->tmp[B].dst, TGSI_WRITEMASK_X);
 356    reg_src(&inst.Src[0], coord, SWIZ(X, Y, Z, W));
 357    tctx->emit_instruction(tctx, &inst);
 358
 359    inst = mov_instruction();
 360    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_Y);
 361    reg_src(&inst.Src[0], &ctx->tmp[B].src, SWIZ(_, X, _, _));
 362    tctx->emit_instruction(tctx, &inst);
 363
 364    /* sample V:
 365     *    TEX tempB.x, coord, texture[sampler_map[samp][1]], 2D;
 366     *    MOV tempA.z, tempB.__x_
 367     */
 368    inst = tex_instruction(ctx->sampler_map[samp][1]);
 369    reg_dst(&inst.Dst[0], &ctx->tmp[B].dst, TGSI_WRITEMASK_X);
 370    reg_src(&inst.Src[0], coord, SWIZ(X, Y, Z, W));
 371    tctx->emit_instruction(tctx, &inst);
 372
 373    inst = mov_instruction();
 374    reg_dst(&inst.Dst[0], &ctx->tmp[A].dst, TGSI_WRITEMASK_Z);
 375    reg_src(&inst.Src[0], &ctx->tmp[B].src, SWIZ(_, _, X, _));
 376    tctx->emit_instruction(tctx, &inst);
 377
 378    /* At this point, we have YUV in tempA.xyz, rest is common: */
 379    yuv_to_rgb(tctx, &originst->Dst[0]);
 380 }
 381
 382 static void
 383 transform_instr(struct tgsi_transform_context *tctx,
 384                 struct tgsi_full_instruction *inst)
 385 {
 386    struct tgsi_yuv_transform *ctx = tgsi_yuv_transform(tctx);
 387
 388    if (!ctx->first_instruction_emitted) {
 389       emit_decls(tctx);
 390       ctx->first_instruction_emitted = true;
 391    }
 392
 393    switch (inst->Instruction.Opcode) {
 394    /* TODO what other tex opcode's can be used w/ external eglimgs? */
 395    case TGSI_OPCODE_TEX: {
 396       unsigned samp = inst->Src[1].Register.Index;
 397       if (ctx->lower_nv12 & (1 << samp)) {
 398          lower_nv12(tctx, inst);
 399       } else if (ctx->lower_iyuv & (1 << samp)) {
 400          lower_iyuv(tctx, inst);
 401       } else {
 402          goto skip;
 403       }
 404       break;
 405    }
 406    default:
 407    skip:
 408       tctx->emit_instruction(tctx, inst);
 409       return;
 410    }
 411 }
 412
 413 extern const struct tgsi_token *
 414 st_tgsi_lower_yuv(const struct tgsi_token *tokens, unsigned free_slots,
 415                   unsigned lower_nv12, unsigned lower_iyuv)
 416 {
 417    struct tgsi_yuv_transform ctx;
 418    struct tgsi_token *newtoks;
 419    int newlen;
 420
 421    assert(!(lower_nv12 & lower_iyuv)); /* bitmasks should be mutually exclusive */
 422
 423 //   tgsi_dump(tokens, 0);
 424 //   debug_printf("\n");
 425
 426    memset(&ctx, 0, sizeof(ctx));
 427    ctx.base.transform_instruction = transform_instr;
 428    ctx.free_slots = free_slots;
 429    ctx.lower_nv12 = lower_nv12;
 430    ctx.lower_iyuv = lower_iyuv;
 431    tgsi_scan_shader(tokens, &ctx.info);
 432
 433    /* TODO better job of figuring out how many extra tokens we need..
 434     * this is a pain about tgsi_transform :-/
 435     */
 436    newlen = tgsi_num_tokens(tokens) + 120;
 437    newtoks = tgsi_alloc_tokens(newlen);
 438    if (!newtoks)
 439       return NULL;
 440
 441    tgsi_transform_shader(tokens, newtoks, newlen, &ctx.base);
 442
 443 //   tgsi_dump(newtoks, 0);
 444 //   debug_printf("\n");
 445
 446    return newtoks;
 447 }