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