src/gallium/drivers/nouveau/nouveau_video.c

   1 /*
   2  * Copyright 2011 Maarten Lankhorst
   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 shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include "vl/vl_decoder.h"
  24 #include "vl/vl_video_buffer.h"
  25
  26 #include "nouveau_screen.h"
  27 #include "nouveau_context.h"
  28 #include "nouveau_video.h"
  29
  30 #include "nouveau/nouveau_buffer.h"
  31 #include "util/u_video.h"
  32 #include "util/u_format.h"
  33 #include "util/u_sampler.h"
  34
  35 static int
  36 nouveau_vpe_init(struct nouveau_decoder *dec) {
  37    int ret;
  38    if (dec->cmds)
  39       return 0;
  40    ret = nouveau_bo_map(dec->cmd_bo, NOUVEAU_BO_RDWR, dec->client);
  41    if (ret) {
  42       debug_printf("Mapping cmd bo: %s\n", strerror(-ret));
  43       return ret;
  44    }
  45    ret = nouveau_bo_map(dec->data_bo, NOUVEAU_BO_RDWR, dec->client);
  46    if (ret) {
  47       debug_printf("Mapping data bo: %s\n", strerror(-ret));
  48       return ret;
  49    }
  50    dec->cmds = dec->cmd_bo->map;
  51    dec->data = dec->data_bo->map;
  52    return ret;
  53 }
  54
  55 static void
  56 nouveau_vpe_synch(struct nouveau_decoder *dec) {
  57    struct nouveau_pushbuf *push = dec->push;
  58 #if 0
  59    if (dec->fence_map) {
  60       BEGIN_NV04(push, NV84_MPEG(QUERY_COUNTER), 1);
  61       PUSH_DATA (push, ++dec->fence_seq);
  62       PUSH_KICK (push);
  63       while (dec->fence_map[0] != dec->fence_seq)
  64          usleep(1000);
  65    } else
  66 #endif
  67       PUSH_KICK(push);
  68 }
  69
  70 static void
  71 nouveau_vpe_fini(struct nouveau_decoder *dec) {
  72    struct nouveau_pushbuf *push = dec->push;
  73    if (!dec->cmds)
  74       return;
  75
  76    nouveau_pushbuf_space(push, 8, 2, 0);
  77    nouveau_bufctx_reset(dec->bufctx, NV31_VIDEO_BIND_CMD);
  78
  79 #define BCTX_ARGS dec->bufctx, NV31_VIDEO_BIND_CMD, NOUVEAU_BO_RD
  80
  81    BEGIN_NV04(push, NV31_MPEG(CMD_OFFSET), 2);
  82    PUSH_MTHDl(push, NV31_MPEG(CMD_OFFSET), dec->cmd_bo, 0, BCTX_ARGS);
  83    PUSH_DATA (push, dec->ofs * 4);
  84
  85    BEGIN_NV04(push, NV31_MPEG(DATA_OFFSET), 2);
  86    PUSH_MTHDl(push, NV31_MPEG(DATA_OFFSET), dec->data_bo, 0, BCTX_ARGS);
  87    PUSH_DATA (push, dec->data_pos * 4);
  88
  89 #undef BCTX_ARGS
  90
  91    if (unlikely(nouveau_pushbuf_validate(dec->push)))
  92       return;
  93
  94    BEGIN_NV04(push, NV31_MPEG(EXEC), 1);
  95    PUSH_DATA (push, 1);
  96
  97    nouveau_vpe_synch(dec);
  98    dec->ofs = dec->data_pos = dec->num_surfaces = 0;
  99    dec->cmds = dec->data = NULL;
 100    dec->current = dec->future = dec->past = 8;
 101 }
 102
 103 static INLINE void
 104 nouveau_vpe_mb_dct_blocks(struct nouveau_decoder *dec, const struct pipe_mpeg12_macroblock *mb)
 105 {
 106    int cbb;
 107    unsigned cbp = mb->coded_block_pattern;
 108    short *db = mb->blocks;
 109    for (cbb = 0x20; cbb > 0; cbb >>= 1) {
 110       if (cbb & cbp) {
 111          static const int lookup[64] = {
 112              0, 1, 8,16, 9, 2, 3,10,
 113             17,24,32,25,18,11, 4, 5,
 114             12,19,26,33,40,48,41,34,
 115             27,20,13, 6, 7,14,21,28,
 116             35,42,49,56,57,50,43,36,
 117             29,22,15,23,30,37,44,51,
 118             58,59,52,45,38,31,39,46,
 119             53,60,61,54,47,55,62,63
 120          };
 121          int i, j = 0, found = 0;
 122          for (i = 0; i < 64; ++i) {
 123             if (!db[lookup[i]]) { j += 2; continue; }
 124             dec->data[dec->data_pos++] = (db[lookup[i]] << 16) | j;
 125             j = 0;
 126             found = 1;
 127          }
 128          if (found)
 129             dec->data[dec->data_pos - 1] |= 1;
 130          else
 131             dec->data[dec->data_pos++] = 1;
 132          db += 64;
 133       } else if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
 134          dec->data[dec->data_pos++] = 1;
 135       }
 136    }
 137 }
 138
 139 static INLINE void
 140 nouveau_vpe_mb_data_blocks(struct nouveau_decoder *dec, const struct pipe_mpeg12_macroblock *mb)
 141 {
 142    int cbb;
 143    unsigned cbp = mb->coded_block_pattern;
 144    short *db = mb->blocks;
 145    for (cbb = 0x20; cbb > 0; cbb >>= 1) {
 146       if (cbb & cbp) {
 147          memcpy(&dec->data[dec->data_pos], db, 128);
 148          dec->data_pos += 32;
 149          db += 64;
 150       } else if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
 151          memset(&dec->data[dec->data_pos], 0, 128);
 152          dec->data_pos += 32;
 153       }
 154    }
 155 }
 156
 157 static INLINE void
 158 nouveau_vpe_mb_dct_header(struct nouveau_decoder *dec,
 159                           const struct pipe_mpeg12_macroblock *mb,
 160                           bool luma)
 161 {
 162    unsigned base_dct, cbp;
 163    bool intra = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA;
 164    unsigned x = mb->x * 16;
 165    unsigned y = luma ? mb->y * 16 : mb->y * 8;
 166
 167    /* Setup the base dct header */
 168    base_dct = dec->current << NV17_MPEG_CMD_CHROMA_MB_HEADER_SURFACE__SHIFT;
 169    base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_RUN_SINGLE;
 170
 171    if (!(mb->x & 1))
 172       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_X_COORD_EVEN;
 173    if (intra)
 174       cbp = 0x3f;
 175    else
 176       cbp = mb->coded_block_pattern;
 177
 178    if (dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME) {
 179       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_TYPE_FRAME;
 180       if (luma && mb->macroblock_modes.bits.dct_type == PIPE_MPEG12_DCT_TYPE_FIELD)
 181          base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_FRAME_DCT_TYPE_FIELD;
 182    } else {
 183       if (dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_BOTTOM)
 184          base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_FIELD_BOTTOM;
 185       if (!intra)
 186          y *= 2;
 187    }
 188
 189    if (luma) {
 190       base_dct |= NV17_MPEG_CMD_LUMA_MB_HEADER_OP_LUMA_MB_HEADER;
 191       base_dct |= (cbp >> 2) << NV17_MPEG_CMD_LUMA_MB_HEADER_CBP__SHIFT;
 192    } else {
 193       base_dct |= NV17_MPEG_CMD_CHROMA_MB_HEADER_OP_CHROMA_MB_HEADER;
 194       base_dct |= (cbp & 3) << NV17_MPEG_CMD_CHROMA_MB_HEADER_CBP__SHIFT;
 195    }
 196    nouveau_vpe_write(dec, base_dct);
 197    nouveau_vpe_write(dec, NV17_MPEG_CMD_MB_COORDS_OP_MB_COORDS |
 198                      x | (y << NV17_MPEG_CMD_MB_COORDS_Y__SHIFT));
 199 }
 200
 201 static INLINE unsigned int
 202 nouveau_vpe_mb_mv_flags(bool luma, int mv_h, int mv_v, bool forward, bool first, bool vert)
 203 {
 204    unsigned mc_header = 0;
 205    if (luma)
 206       mc_header |= NV17_MPEG_CMD_LUMA_MV_HEADER_OP_LUMA_MV_HEADER;
 207    else
 208       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_OP_CHROMA_MV_HEADER;
 209    if (mv_h & 1)
 210       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_X_HALF;
 211    if (mv_v & 1)
 212       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_Y_HALF;
 213    if (!forward)
 214       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_DIRECTION_BACKWARD;
 215    if (!first)
 216       mc_header |= NV17_MPEG_CMD_CHROMA_MV_HEADER_IDX;
 217    if (vert)
 218       mc_header |= NV17_MPEG_CMD_LUMA_MV_HEADER_FIELD_BOTTOM;
 219    return mc_header;
 220 }
 221
 222 static unsigned pos(int pos, int mov, int max) {
 223    int ret = pos + mov;
 224    if (pos < 0)
 225       return 0;
 226    if (pos >= max)
 227       return max-1;
 228    return ret;
 229 }
 230
 231 /* because we want -1 / 2 = -1 */
 232 static int div_down(int val, int mult) {
 233    val &= ~(mult - 1);
 234    return val / mult;
 235 }
 236
 237 static int div_up(int val, int mult) {
 238    val += mult - 1;
 239    return val / mult;
 240 }
 241
 242 static INLINE void
 243 nouveau_vpe_mb_mv(struct nouveau_decoder *dec, unsigned mc_header,
 244                    bool luma, bool frame, bool forward, bool vert,
 245                    int x, int y, const short motions[2],
 246                    unsigned surface, bool first)
 247 {
 248    unsigned mc_vector;
 249    int mv_horizontal = motions[0];
 250    int mv_vertical = motions[1];
 251    int mv2 = mc_header & NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
 252    unsigned width = dec->base.width;
 253    unsigned height = dec->base.height;
 254    if (mv2)
 255       mv_vertical = div_down(mv_vertical, 2);
 256    assert(frame); // Untested for non-frames
 257    if (!frame)
 258       height *= 2;
 259
 260    mc_header |= surface << NV17_MPEG_CMD_CHROMA_MV_HEADER_SURFACE__SHIFT;
 261    if (!luma) {
 262       mv_vertical = div_up(mv_vertical, 2);
 263       mv_horizontal = div_up(mv_horizontal, 2);
 264       height /= 2;
 265    }
 266    mc_header |= nouveau_vpe_mb_mv_flags(luma, mv_horizontal, mv_vertical, forward, first, vert);
 267    nouveau_vpe_write(dec, mc_header);
 268
 269    mc_vector = NV17_MPEG_CMD_MV_COORDS_OP_MV_COORDS;
 270    if (luma)
 271       mc_vector |= pos(x, div_down(mv_horizontal, 2), width);
 272    else
 273       mc_vector |= pos(x, mv_horizontal & ~1, width);
 274    if (!mv2)
 275       mc_vector |= pos(y, div_down(mv_vertical, 2), height) << NV17_MPEG_CMD_MV_COORDS_Y__SHIFT;
 276    else
 277       mc_vector |= pos(y, mv_vertical & ~1, height) << NV17_MPEG_CMD_MV_COORDS_Y__SHIFT;
 278    nouveau_vpe_write(dec, mc_vector);
 279 }
 280
 281 static void
 282 nouveau_vpe_mb_mv_header(struct nouveau_decoder *dec,
 283                          const struct pipe_mpeg12_macroblock *mb,
 284                          bool luma)
 285 {
 286    bool frame = dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FRAME;
 287    unsigned base;
 288    bool forward, backward;
 289    int y, y2, x = mb->x * 16;
 290    if (luma)
 291       y = mb->y * (frame ? 16 : 32);
 292    else
 293       y = mb->y * (frame ? 8 : 16);
 294    if (frame)
 295       y2 = y;
 296    else
 297       y2 = y + (luma ? 16 : 8);
 298
 299    forward = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_FORWARD;
 300    backward = mb->macroblock_type & PIPE_MPEG12_MB_TYPE_MOTION_BACKWARD;
 301    assert(!forward || dec->past < 8);
 302    assert(!backward || dec->future < 8);
 303    if (frame) {
 304       switch (mb->macroblock_modes.bits.frame_motion_type) {
 305       case PIPE_MPEG12_MO_TYPE_FRAME: goto mv1;
 306       case PIPE_MPEG12_MO_TYPE_FIELD: goto mv2;
 307       case PIPE_MPEG12_MO_TYPE_DUAL_PRIME: {
 308          base = NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
 309          if (forward) {
 310             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, FALSE,
 311                               x, y, mb->PMV[0][0], dec->past, TRUE);
 312             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, TRUE,
 313                               x, y2, mb->PMV[0][0], dec->past, FALSE);
 314          }
 315          if (backward && forward) {
 316             nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, TRUE,
 317                               x, y, mb->PMV[1][0], dec->future, TRUE);
 318             nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, FALSE,
 319                               x, y2, mb->PMV[1][1], dec->future, FALSE);
 320          } else assert(!backward);
 321          break;
 322       }
 323       default: assert(0);
 324       }
 325    } else {
 326       switch (mb->macroblock_modes.bits.field_motion_type) {
 327       case PIPE_MPEG12_MO_TYPE_FIELD: goto mv1;
 328       case PIPE_MPEG12_MO_TYPE_16x8: goto mv2;
 329       case PIPE_MPEG12_MO_TYPE_DUAL_PRIME: {
 330       base = NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
 331          if (frame)
 332             base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_TYPE_FRAME;
 333          if (forward)
 334             nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
 335                               dec->picture_structure != PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_TOP,
 336                               x, y, mb->PMV[0][0], dec->past, TRUE);
 337          if (backward && forward)
 338             nouveau_vpe_mb_mv(dec, base, luma, frame, FALSE,
 339                               dec->picture_structure == PIPE_MPEG12_PICTURE_STRUCTURE_FIELD_TOP,
 340                               x, y, mb->PMV[0][1], dec->future, TRUE);
 341          else assert(!backward);
 342          break;
 343       }
 344       default: assert(0);
 345       }
 346    }
 347    return;
 348
 349 mv1:
 350    base = NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
 351    if (frame)
 352        base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_TYPE_FRAME;
 353     /* frame 16x16 */
 354    if (forward)
 355        nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE, FALSE,
 356                          x, y, mb->PMV[0][0], dec->past, TRUE);
 357    if (backward)
 358        nouveau_vpe_mb_mv(dec, base, luma, frame, !forward, FALSE,
 359                          x, y, mb->PMV[0][1], dec->future, TRUE);
 360     return;
 361
 362 mv2:
 363    base = NV17_MPEG_CMD_CHROMA_MV_HEADER_COUNT_2;
 364    if (!frame)
 365       base |= NV17_MPEG_CMD_CHROMA_MV_HEADER_MV_SPLIT_HALF_MB;
 366    if (forward) {
 367       nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
 368                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_FIRST_FORWARD,
 369                         x, y, mb->PMV[0][0], dec->past, TRUE);
 370       nouveau_vpe_mb_mv(dec, base, luma, frame, TRUE,
 371                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_SECOND_FORWARD,
 372                         x, y2, mb->PMV[1][0], dec->past, FALSE);
 373    }
 374    if (backward) {
 375       nouveau_vpe_mb_mv(dec, base, luma, frame, !forward,
 376                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_FIRST_BACKWARD,
 377                         x, y, mb->PMV[0][1], dec->future, TRUE);
 378       nouveau_vpe_mb_mv(dec, base, luma, frame, !forward,
 379                         mb->motion_vertical_field_select & PIPE_MPEG12_FS_SECOND_BACKWARD,
 380                         x, y2, mb->PMV[1][1], dec->future, FALSE);
 381    }
 382 }
 383
 384 static unsigned
 385 nouveau_decoder_surface_index(struct nouveau_decoder *dec,
 386                               struct pipe_video_buffer *buffer)
 387 {
 388    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
 389    struct nouveau_pushbuf *push = dec->push;
 390    struct nouveau_bo *bo_y = nv04_resource(buf->resources[0])->bo;
 391    struct nouveau_bo *bo_c = nv04_resource(buf->resources[1])->bo;
 392
 393    unsigned i;
 394
 395    if (!buf)
 396       return 8;
 397    for (i = 0; i < dec->num_surfaces; ++i) {
 398       if (dec->surfaces[i] == buf)
 399          return i;
 400    }
 401    assert(i < 8);
 402    dec->surfaces[i] = buf;
 403    dec->num_surfaces++;
 404
 405    nouveau_bufctx_reset(dec->bufctx, NV31_VIDEO_BIND_IMG(i));
 406
 407 #define BCTX_ARGS dec->bufctx, NV31_VIDEO_BIND_IMG(i), NOUVEAU_BO_RDWR
 408    BEGIN_NV04(push, NV31_MPEG(IMAGE_Y_OFFSET(i)), 2);
 409    PUSH_MTHDl(push, NV31_MPEG(IMAGE_Y_OFFSET(i)), bo_y, 0, BCTX_ARGS);
 410    PUSH_MTHDl(push, NV31_MPEG(IMAGE_C_OFFSET(i)), bo_c, 0, BCTX_ARGS);
 411 #undef BCTX_ARGS
 412
 413    return i;
 414 }
 415
 416 static void
 417 nouveau_decoder_begin_frame(struct pipe_video_decoder *decoder,
 418                             struct pipe_video_buffer *target,
 419                             struct pipe_picture_desc *picture)
 420 {
 421 }
 422
 423 static void
 424 nouveau_decoder_decode_macroblock(struct pipe_video_decoder *decoder,
 425                                   struct pipe_video_buffer *target,
 426                                   struct pipe_picture_desc *picture,
 427                                   const struct pipe_macroblock *pipe_mb,
 428                                   unsigned num_macroblocks)
 429 {
 430    struct nouveau_decoder *dec = (struct nouveau_decoder *)decoder;
 431    struct pipe_mpeg12_picture_desc *desc = (struct pipe_mpeg12_picture_desc*)picture;
 432    const struct pipe_mpeg12_macroblock *mb;
 433    unsigned i;
 434    assert(target->width == decoder->width);
 435    assert(target->height == decoder->height);
 436
 437    dec->current = nouveau_decoder_surface_index(dec, target);
 438    assert(dec->current < 8);
 439    dec->picture_structure = desc->picture_structure;
 440    if (desc->ref[1])
 441       dec->future = nouveau_decoder_surface_index(dec, desc->ref[1]);
 442    if (desc->ref[0])
 443       dec->past = nouveau_decoder_surface_index(dec, desc->ref[0]);
 444
 445    if (nouveau_vpe_init(dec)) return;
 446    mb = (const struct pipe_mpeg12_macroblock *)pipe_mb;
 447    for (i = 0; i < num_macroblocks; ++i, mb++) {
 448       if (mb->macroblock_type & PIPE_MPEG12_MB_TYPE_INTRA) {
 449          nouveau_vpe_mb_dct_header(dec, mb, TRUE);
 450          nouveau_vpe_mb_dct_header(dec, mb, FALSE);
 451       } else {
 452          nouveau_vpe_mb_mv_header(dec, mb, TRUE);
 453          nouveau_vpe_mb_dct_header(dec, mb, TRUE);
 454
 455          nouveau_vpe_mb_mv_header(dec, mb, FALSE);
 456          nouveau_vpe_mb_dct_header(dec, mb, FALSE);
 457       }
 458       if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT)
 459          nouveau_vpe_mb_dct_blocks(dec, mb);
 460       else
 461          nouveau_vpe_mb_data_blocks(dec, mb);
 462    }
 463 }
 464
 465 static void
 466 nouveau_decoder_end_frame(struct pipe_video_decoder *decoder,
 467                           struct pipe_video_buffer *target,
 468                           struct pipe_picture_desc *picture)
 469 {
 470 }
 471
 472 static void
 473 nouveau_decoder_flush(struct pipe_video_decoder *decoder)
 474 {
 475    struct nouveau_decoder *dec = (struct nouveau_decoder *)decoder;
 476    if (dec->ofs)
 477       nouveau_vpe_fini(dec);
 478 }
 479
 480 static void
 481 nouveau_decoder_destroy(struct pipe_video_decoder *decoder)
 482 {
 483    struct nouveau_decoder *dec = (struct nouveau_decoder*)decoder;
 484
 485    if (dec->data_bo)
 486       nouveau_bo_ref(NULL, &dec->data_bo);
 487    if (dec->cmd_bo)
 488       nouveau_bo_ref(NULL, &dec->cmd_bo);
 489    if (dec->fence_bo)
 490       nouveau_bo_ref(NULL, &dec->fence_bo);
 491
 492    nouveau_object_del(&dec->mpeg);
 493
 494    if (dec->bufctx)
 495       nouveau_bufctx_del(&dec->bufctx);
 496    if (dec->push)
 497       nouveau_pushbuf_del(&dec->push);
 498    if (dec->client)
 499       nouveau_client_del(&dec->client);
 500    if (dec->chan)
 501       nouveau_object_del(&dec->chan);
 502
 503    FREE(dec);
 504 }
 505
 506 static struct pipe_video_decoder *
 507 nouveau_create_decoder(struct pipe_context *context,
 508                        struct nouveau_screen *screen,
 509                        enum pipe_video_profile profile,
 510                        enum pipe_video_entrypoint entrypoint,
 511                        enum pipe_video_chroma_format chroma_format,
 512                        unsigned width, unsigned height,
 513                        unsigned max_references, bool expect_chunked_decode)
 514 {
 515    struct nv04_fifo nv04_data = { .vram = 0xbeef0201, .gart = 0xbeef0202 };
 516    struct nouveau_object *mpeg = NULL;
 517    struct nouveau_decoder *dec;
 518    struct nouveau_pushbuf *push;
 519    int ret;
 520    bool is8274 = screen->device->chipset > 0x80;
 521
 522    debug_printf("Acceleration level: %s\n", entrypoint <= PIPE_VIDEO_ENTRYPOINT_BITSTREAM ? "bit":
 523                                             entrypoint == PIPE_VIDEO_ENTRYPOINT_IDCT ? "IDCT" : "MC");
 524
 525    if (getenv("XVMC_VL"))
 526       goto vl;
 527    if (u_reduce_video_profile(profile) != PIPE_VIDEO_CODEC_MPEG12)
 528       goto vl;
 529    if (screen->device->chipset >= 0x98 && screen->device->chipset != 0xa0)
 530       goto vl;
 531
 532    dec = CALLOC_STRUCT(nouveau_decoder);
 533    if (!dec)
 534       return NULL;
 535
 536    ret = nouveau_object_new(&screen->device->object, 0,
 537                             NOUVEAU_FIFO_CHANNEL_CLASS,
 538                             &nv04_data, sizeof(nv04_data), &dec->chan);
 539    if (ret)
 540       goto fail;
 541    ret = nouveau_client_new(screen->device, &dec->client);
 542    if (ret)
 543       goto fail;
 544    ret = nouveau_pushbuf_new(dec->client, dec->chan, 2, 4096, 1, &dec->push);
 545    if (ret)
 546       goto fail;
 547    ret = nouveau_bufctx_new(dec->client, NV31_VIDEO_BIND_COUNT, &dec->bufctx);
 548    if (ret)
 549       goto fail;
 550    push = dec->push;
 551
 552    width = align(width, 64);
 553    height = align(height, 64);
 554
 555    if (is8274)
 556       ret = nouveau_object_new(dec->chan, 0xbeef8274, NV84_MPEG_CLASS, NULL, 0,
 557                                &mpeg);
 558    else
 559       ret = nouveau_object_new(dec->chan, 0xbeef3174, NV31_MPEG_CLASS, NULL, 0,
 560                                &mpeg);
 561    if (ret < 0) {
 562       debug_printf("Creation failed: %s (%i)\n", strerror(-ret), ret);
 563       return NULL;
 564    }
 565
 566    dec->mpeg = mpeg;
 567    dec->base.context = context;
 568    dec->base.profile = profile;
 569    dec->base.entrypoint = entrypoint;
 570    dec->base.chroma_format = chroma_format;
 571    dec->base.width = width;
 572    dec->base.height = height;
 573    dec->base.max_references = max_references;
 574    dec->base.destroy = nouveau_decoder_destroy;
 575    dec->base.begin_frame = nouveau_decoder_begin_frame;
 576    dec->base.decode_macroblock = nouveau_decoder_decode_macroblock;
 577    dec->base.end_frame = nouveau_decoder_end_frame;
 578    dec->base.flush = nouveau_decoder_flush;
 579    dec->screen = screen;
 580
 581    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 582                         0, 1024 * 1024, NULL, &dec->cmd_bo);
 583    if (ret)
 584       goto fail;
 585
 586    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 587                         0, width * height * 6, NULL, &dec->data_bo);
 588    if (ret)
 589       goto fail;
 590
 591    /* we don't need the fence, the kernel sync's for us */
 592 #if 0
 593    ret = nouveau_bo_new(dec->screen->device, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 594                         0, 4096, NULL, &dec->fence_bo);
 595    if (ret)
 596       goto fail;
 597    nouveau_bo_map(dec->fence_bo, NOUVEAU_BO_RDWR, NULL);
 598    dec->fence_map = dec->fence_bo->map;
 599    dec->fence_map[0] = 0;
 600 #endif
 601
 602    nouveau_pushbuf_bufctx(dec->push, dec->bufctx);
 603    nouveau_pushbuf_space(push, 32, 4, 0);
 604
 605    BEGIN_NV04(push, SUBC_MPEG(NV01_SUBCHAN_OBJECT), 1);
 606    PUSH_DATA (push, dec->mpeg->handle);
 607
 608    BEGIN_NV04(push, NV31_MPEG(DMA_CMD), 1);
 609    PUSH_DATA (push, nv04_data.gart);
 610
 611    BEGIN_NV04(push, NV31_MPEG(DMA_DATA), 1);
 612    PUSH_DATA (push, nv04_data.gart);
 613
 614    BEGIN_NV04(push, NV31_MPEG(DMA_IMAGE), 1);
 615    PUSH_DATA (push, nv04_data.vram);
 616
 617    BEGIN_NV04(push, NV31_MPEG(PITCH), 2);
 618    PUSH_DATA (push, width | NV31_MPEG_PITCH_UNK);
 619    PUSH_DATA (push, (height << NV31_MPEG_SIZE_H__SHIFT) | width);
 620
 621    BEGIN_NV04(push, NV31_MPEG(FORMAT), 2);
 622    PUSH_DATA (push, 0);
 623    switch (entrypoint) {
 624       case PIPE_VIDEO_ENTRYPOINT_BITSTREAM: PUSH_DATA (push, 0x100); break;
 625       case PIPE_VIDEO_ENTRYPOINT_IDCT: PUSH_DATA (push, 1); break;
 626       case PIPE_VIDEO_ENTRYPOINT_MC: PUSH_DATA (push, 0); break;
 627       default: assert(0);
 628    }
 629
 630    if (is8274) {
 631       BEGIN_NV04(push, NV84_MPEG(DMA_QUERY), 1);
 632       PUSH_DATA (push, nv04_data.vram);
 633 #if 0
 634       BEGIN_NV04(push, NV84_MPEG(QUERY_OFFSET), 2);
 635       PUSH_DATA (push, dec->fence_bo->offset);
 636       PUSH_DATA (push, dec->fence_seq);
 637 #endif
 638    }
 639
 640    ret = nouveau_vpe_init(dec);
 641    if (ret)
 642       goto fail;
 643    nouveau_vpe_fini(dec);
 644    return &dec->base;
 645
 646 fail:
 647    nouveau_decoder_destroy(&dec->base);
 648    return NULL;
 649
 650 vl:
 651    debug_printf("Using g3dvl renderer\n");
 652    return vl_create_decoder(context, profile, entrypoint,
 653                             chroma_format, width, height,
 654                             max_references, expect_chunked_decode);
 655 }
 656
 657 static struct pipe_sampler_view **
 658 nouveau_video_buffer_sampler_view_planes(struct pipe_video_buffer *buffer)
 659 {
 660    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
 661    struct pipe_sampler_view sv_templ;
 662    struct pipe_context *pipe;
 663    unsigned i;
 664
 665    assert(buf);
 666
 667    pipe = buf->base.context;
 668
 669    for (i = 0; i < buf->num_planes; ++i ) {
 670       if (!buf->sampler_view_planes[i]) {
 671          memset(&sv_templ, 0, sizeof(sv_templ));
 672          u_sampler_view_default_template(&sv_templ, buf->resources[i], buf->resources[i]->format);
 673
 674          if (util_format_get_nr_components(buf->resources[i]->format) == 1)
 675             sv_templ.swizzle_r = sv_templ.swizzle_g = sv_templ.swizzle_b = sv_templ.swizzle_a = PIPE_SWIZZLE_RED;
 676
 677          buf->sampler_view_planes[i] = pipe->create_sampler_view(pipe, buf->resources[i], &sv_templ);
 678          if (!buf->sampler_view_planes[i])
 679             goto error;
 680       }
 681    }
 682
 683    return buf->sampler_view_planes;
 684
 685 error:
 686    for (i = 0; i < buf->num_planes; ++i )
 687       pipe_sampler_view_reference(&buf->sampler_view_planes[i], NULL);
 688
 689    return NULL;
 690 }
 691
 692 static struct pipe_sampler_view **
 693 nouveau_video_buffer_sampler_view_components(struct pipe_video_buffer *buffer)
 694 {
 695    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
 696    struct pipe_sampler_view sv_templ;
 697    struct pipe_context *pipe;
 698    unsigned i, j, component;
 699
 700    assert(buf);
 701
 702    pipe = buf->base.context;
 703
 704    for (component = 0, i = 0; i < buf->num_planes; ++i ) {
 705       unsigned nr_components = util_format_get_nr_components(buf->resources[i]->format);
 706
 707       for (j = 0; j < nr_components; ++j, ++component) {
 708          assert(component < VL_NUM_COMPONENTS);
 709
 710          if (!buf->sampler_view_components[component]) {
 711             memset(&sv_templ, 0, sizeof(sv_templ));
 712             u_sampler_view_default_template(&sv_templ, buf->resources[i], buf->resources[i]->format);
 713             sv_templ.swizzle_r = sv_templ.swizzle_g = sv_templ.swizzle_b = PIPE_SWIZZLE_RED + j;
 714             sv_templ.swizzle_a = PIPE_SWIZZLE_ONE;
 715             buf->sampler_view_components[component] = pipe->create_sampler_view(pipe, buf->resources[i], &sv_templ);
 716             if (!buf->sampler_view_components[component])
 717                goto error;
 718          }
 719       }
 720    }
 721
 722    return buf->sampler_view_components;
 723
 724 error:
 725    for (i = 0; i < 3; ++i )
 726       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
 727
 728    return NULL;
 729 }
 730
 731 static struct pipe_surface **
 732 nouveau_video_buffer_surfaces(struct pipe_video_buffer *buffer)
 733 {
 734    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
 735    struct pipe_surface surf_templ;
 736    struct pipe_context *pipe;
 737    unsigned i;
 738
 739    assert(buf);
 740
 741    pipe = buf->base.context;
 742
 743    for (i = 0; i < buf->num_planes; ++i ) {
 744       if (!buf->surfaces[i]) {
 745          memset(&surf_templ, 0, sizeof(surf_templ));
 746          surf_templ.format = buf->resources[i]->format;
 747          buf->surfaces[i] = pipe->create_surface(pipe, buf->resources[i], &surf_templ);
 748          if (!buf->surfaces[i])
 749             goto error;
 750       }
 751    }
 752
 753    return buf->surfaces;
 754
 755 error:
 756    for (i = 0; i < buf->num_planes; ++i )
 757       pipe_surface_reference(&buf->surfaces[i], NULL);
 758
 759    return NULL;
 760 }
 761
 762 static void
 763 nouveau_video_buffer_destroy(struct pipe_video_buffer *buffer)
 764 {
 765    struct nouveau_video_buffer *buf = (struct nouveau_video_buffer *)buffer;
 766    unsigned i;
 767
 768    assert(buf);
 769
 770    for (i = 0; i < buf->num_planes; ++i) {
 771       pipe_surface_reference(&buf->surfaces[i], NULL);
 772       pipe_sampler_view_reference(&buf->sampler_view_planes[i], NULL);
 773       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
 774       pipe_resource_reference(&buf->resources[i], NULL);
 775    }
 776    for (;i < 3;++i)
 777       pipe_sampler_view_reference(&buf->sampler_view_components[i], NULL);
 778
 779    FREE(buffer);
 780 }
 781
 782 static struct pipe_video_buffer *
 783 nouveau_video_buffer_create(struct pipe_context *pipe,
 784                             struct nouveau_screen *screen,
 785                             const struct pipe_video_buffer *templat)
 786 {
 787    struct nouveau_video_buffer *buffer;
 788    struct pipe_resource templ;
 789    unsigned width, height;
 790
 791    /* Only do a linear surface when a hardware decoder is used
 792     * hardware decoder is only supported on some chipsets
 793     * and it only supports the NV12 format
 794     */
 795    if (templat->buffer_format != PIPE_FORMAT_NV12 || getenv("XVMC_VL") ||
 796        (screen->device->chipset >= 0x98 && screen->device->chipset != 0xa0))
 797       return vl_video_buffer_create(pipe, templat);
 798
 799    assert(templat->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
 800    width = align(templat->width, 64);
 801    height = align(templat->height, 64);
 802
 803    buffer = CALLOC_STRUCT(nouveau_video_buffer);
 804    if (!buffer)
 805       return NULL;
 806
 807    buffer->base.context = pipe;
 808    buffer->base.destroy = nouveau_video_buffer_destroy;
 809    buffer->base.get_sampler_view_planes = nouveau_video_buffer_sampler_view_planes;
 810    buffer->base.get_sampler_view_components = nouveau_video_buffer_sampler_view_components;
 811    buffer->base.get_surfaces = nouveau_video_buffer_surfaces;
 812    buffer->base.chroma_format = templat->chroma_format;
 813    buffer->base.width = width;
 814    buffer->base.height = height;
 815    buffer->num_planes = 2;
 816
 817    memset(&templ, 0, sizeof(templ));
 818    templ.target = PIPE_TEXTURE_2D;
 819    templ.format = PIPE_FORMAT_R8_UNORM;
 820    templ.width0 = width;
 821    templ.height0 = height;
 822    templ.depth0 = 1;
 823    templ.array_size = 1;
 824    templ.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
 825    templ.usage = PIPE_USAGE_STATIC;
 826    templ.flags = NOUVEAU_RESOURCE_FLAG_LINEAR;
 827
 828    buffer->resources[0] = pipe->screen->resource_create(pipe->screen, &templ);
 829    if (!buffer->resources[0])
 830       goto error;
 831    templ.width0 /= 2;
 832    templ.height0 /= 2;
 833    templ.format = PIPE_FORMAT_R8G8_UNORM;
 834    buffer->resources[1] = pipe->screen->resource_create(pipe->screen, &templ);
 835    if (!buffer->resources[1])
 836       goto error;
 837    return &buffer->base;
 838
 839 error:
 840    nouveau_video_buffer_destroy(&buffer->base);
 841    return NULL;
 842 }
 843
 844 static int
 845 nouveau_screen_get_video_param(struct pipe_screen *pscreen,
 846                                enum pipe_video_profile profile,
 847                                enum pipe_video_cap param)
 848 {
 849    switch (param) {
 850    case PIPE_VIDEO_CAP_SUPPORTED:
 851       return vl_profile_supported(pscreen, profile);
 852    case PIPE_VIDEO_CAP_NPOT_TEXTURES:
 853       return 1;
 854    case PIPE_VIDEO_CAP_MAX_WIDTH:
 855    case PIPE_VIDEO_CAP_MAX_HEIGHT:
 856       return vl_video_buffer_max_size(pscreen);
 857    case PIPE_VIDEO_CAP_PREFERED_FORMAT:
 858       return PIPE_FORMAT_NV12;
 859    case PIPE_VIDEO_CAP_PREFERS_INTERLACED:
 860       return false;
 861    case PIPE_VIDEO_CAP_SUPPORTS_INTERLACED:
 862       return false;
 863    case PIPE_VIDEO_CAP_SUPPORTS_PROGRESSIVE:
 864       return true;
 865    default:
 866       debug_printf("unknown video param: %d\n", param);
 867       return 0;
 868    }
 869 }
 870
 871 void
 872 nouveau_screen_init_vdec(struct nouveau_screen *screen)
 873 {
 874    screen->base.get_video_param = nouveau_screen_get_video_param;
 875    screen->base.is_video_format_supported = vl_video_buffer_is_format_supported;
 876 }
 877
 878 static struct pipe_video_decoder *
 879 nouveau_context_create_decoder(struct pipe_context *context,
 880                                enum pipe_video_profile profile,
 881                                enum pipe_video_entrypoint entrypoint,
 882                                enum pipe_video_chroma_format chroma_format,
 883                                unsigned width, unsigned height,
 884                                unsigned max_references, bool expect_chunked_decode)
 885 {
 886    struct nouveau_screen *screen = nouveau_context(context)->screen;
 887    return nouveau_create_decoder(context, screen, profile, entrypoint,
 888                                  chroma_format, width, height,
 889                                  max_references, expect_chunked_decode);
 890 }
 891
 892 static struct pipe_video_buffer *
 893 nouveau_context_video_buffer_create(struct pipe_context *pipe,
 894                                     const struct pipe_video_buffer *templat)
 895 {
 896    struct nouveau_screen *screen = nouveau_context(pipe)->screen;
 897    return nouveau_video_buffer_create(pipe, screen, templat);
 898 }
 899
 900 void
 901 nouveau_context_init_vdec(struct nouveau_context *nv)
 902 {
 903    nv->pipe.create_video_decoder = nouveau_context_create_decoder;
 904    nv->pipe.create_video_buffer = nouveau_context_video_buffer_create;
 905 }