vl_mpeg12_decoder.c revision 1d1d038c85ebb37f1da4540f092563e8ecab7dfb
1/************************************************************************** 2 * 3 * Copyright 2009 Younes Manton. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28#include <math.h> 29#include <assert.h> 30 31#include <util/u_memory.h> 32#include <util/u_rect.h> 33#include <util/u_video.h> 34 35#include "vl_mpeg12_decoder.h" 36#include "vl_defines.h" 37 38#define SCALE_FACTOR_SNORM (32768.0f / 256.0f) 39#define SCALE_FACTOR_SSCALED (1.0f / 256.0f) 40 41struct format_config { 42 enum pipe_format zscan_source_format; 43 enum pipe_format idct_source_format; 44 enum pipe_format mc_source_format; 45 46 float idct_scale; 47 float mc_scale; 48}; 49 50static const struct format_config bitstream_format_config[] = { 51 { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SSCALED }, 52 { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, 1.0f, SCALE_FACTOR_SSCALED }, 53 { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SNORM }, 54 { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, 1.0f, SCALE_FACTOR_SNORM } 55}; 56 57static const unsigned num_bitstream_format_configs = 58 sizeof(bitstream_format_config) / sizeof(struct format_config); 59 60static const struct format_config idct_format_config[] = { 61 { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SSCALED }, 62 { PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, PIPE_FORMAT_R16G16B16A16_SSCALED, 1.0f, SCALE_FACTOR_SSCALED }, 63 { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_FLOAT, 1.0f, SCALE_FACTOR_SNORM }, 64 { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, 1.0f, SCALE_FACTOR_SNORM } 65}; 66 67static const unsigned num_idct_format_configs = 68 sizeof(idct_format_config) / sizeof(struct format_config); 69 70static const struct format_config mc_format_config[] = { 71 //{ PIPE_FORMAT_R16_SSCALED, PIPE_FORMAT_NONE, PIPE_FORMAT_R16_SSCALED, 0.0f, SCALE_FACTOR_SSCALED }, 72 { PIPE_FORMAT_R16_SNORM, PIPE_FORMAT_NONE, PIPE_FORMAT_R16_SNORM, 0.0f, SCALE_FACTOR_SNORM } 73}; 74 75static const unsigned num_mc_format_configs = 76 sizeof(mc_format_config) / sizeof(struct format_config); 77 78static bool 79init_zscan_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buffer) 80{ 81 enum pipe_format formats[3]; 82 83 struct pipe_sampler_view **source; 84 struct pipe_surface **destination; 85 86 unsigned i; 87 88 assert(dec && buffer); 89 90 formats[0] = formats[1] = formats[2] = dec->zscan_source_format; 91 buffer->zscan_source = vl_video_buffer_create_ex 92 ( 93 dec->base.context, 94 dec->blocks_per_line * BLOCK_WIDTH * BLOCK_HEIGHT, 95 align(dec->num_blocks, dec->blocks_per_line) / dec->blocks_per_line, 96 1, PIPE_VIDEO_CHROMA_FORMAT_444, formats, PIPE_USAGE_STATIC 97 ); 98 99 if (!buffer->zscan_source) 100 goto error_source; 101 102 source = buffer->zscan_source->get_sampler_view_planes(buffer->zscan_source); 103 if (!source) 104 goto error_sampler; 105 106 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 107 destination = dec->idct_source->get_surfaces(dec->idct_source); 108 else 109 destination = dec->mc_source->get_surfaces(dec->mc_source); 110 111 if (!destination) 112 goto error_surface; 113 114 for (i = 0; i < VL_MAX_PLANES; ++i) 115 if (!vl_zscan_init_buffer(i == 0 ? &dec->zscan_y : &dec->zscan_c, 116 &buffer->zscan[i], source[i], destination[i])) 117 goto error_plane; 118 119 return true; 120 121error_plane: 122 for (; i > 0; --i) 123 vl_zscan_cleanup_buffer(&buffer->zscan[i - 1]); 124 125error_surface: 126error_sampler: 127 buffer->zscan_source->destroy(buffer->zscan_source); 128 129error_source: 130 return false; 131} 132 133static void 134cleanup_zscan_buffer(struct vl_mpeg12_buffer *buffer) 135{ 136 unsigned i; 137 138 assert(buffer); 139 140 for (i = 0; i < VL_MAX_PLANES; ++i) 141 vl_zscan_cleanup_buffer(&buffer->zscan[i]); 142 buffer->zscan_source->destroy(buffer->zscan_source); 143} 144 145static bool 146init_idct_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buffer) 147{ 148 struct pipe_sampler_view **idct_source_sv, **mc_source_sv; 149 150 unsigned i; 151 152 assert(dec && buffer); 153 154 idct_source_sv = dec->idct_source->get_sampler_view_planes(dec->idct_source); 155 if (!idct_source_sv) 156 goto error_source_sv; 157 158 mc_source_sv = dec->mc_source->get_sampler_view_planes(dec->mc_source); 159 if (!mc_source_sv) 160 goto error_mc_source_sv; 161 162 for (i = 0; i < 3; ++i) 163 if (!vl_idct_init_buffer(i == 0 ? &dec->idct_y : &dec->idct_c, 164 &buffer->idct[i], idct_source_sv[i], 165 mc_source_sv[i])) 166 goto error_plane; 167 168 return true; 169 170error_plane: 171 for (; i > 0; --i) 172 vl_idct_cleanup_buffer(&buffer->idct[i - 1]); 173 174error_mc_source_sv: 175error_source_sv: 176 return false; 177} 178 179static void 180cleanup_idct_buffer(struct vl_mpeg12_buffer *buf) 181{ 182 unsigned i; 183 184 assert(buf); 185 186 for (i = 0; i < 3; ++i) 187 vl_idct_cleanup_buffer(&buf->idct[0]); 188} 189 190static bool 191init_mc_buffer(struct vl_mpeg12_decoder *dec, struct vl_mpeg12_buffer *buf) 192{ 193 assert(dec && buf); 194 195 if(!vl_mc_init_buffer(&dec->mc_y, &buf->mc[0])) 196 goto error_mc_y; 197 198 if(!vl_mc_init_buffer(&dec->mc_c, &buf->mc[1])) 199 goto error_mc_cb; 200 201 if(!vl_mc_init_buffer(&dec->mc_c, &buf->mc[2])) 202 goto error_mc_cr; 203 204 return true; 205 206error_mc_cr: 207 vl_mc_cleanup_buffer(&buf->mc[1]); 208 209error_mc_cb: 210 vl_mc_cleanup_buffer(&buf->mc[0]); 211 212error_mc_y: 213 return false; 214} 215 216static void 217cleanup_mc_buffer(struct vl_mpeg12_buffer *buf) 218{ 219 unsigned i; 220 221 assert(buf); 222 223 for (i = 0; i < VL_MAX_PLANES; ++i) 224 vl_mc_cleanup_buffer(&buf->mc[i]); 225} 226 227static void 228vl_mpeg12_destroy(struct pipe_video_decoder *decoder) 229{ 230 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder; 231 232 assert(decoder); 233 234 /* Asserted in softpipe_delete_fs_state() for some reason */ 235 dec->base.context->bind_vs_state(dec->base.context, NULL); 236 dec->base.context->bind_fs_state(dec->base.context, NULL); 237 238 dec->base.context->delete_depth_stencil_alpha_state(dec->base.context, dec->dsa); 239 dec->base.context->delete_sampler_state(dec->base.context, dec->sampler_ycbcr); 240 241 vl_mc_cleanup(&dec->mc_y); 242 vl_mc_cleanup(&dec->mc_c); 243 dec->mc_source->destroy(dec->mc_source); 244 245 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { 246 vl_idct_cleanup(&dec->idct_y); 247 vl_idct_cleanup(&dec->idct_c); 248 dec->idct_source->destroy(dec->idct_source); 249 } 250 251 vl_zscan_cleanup(&dec->zscan_y); 252 vl_zscan_cleanup(&dec->zscan_c); 253 254 dec->base.context->delete_vertex_elements_state(dec->base.context, dec->ves_ycbcr); 255 dec->base.context->delete_vertex_elements_state(dec->base.context, dec->ves_mv); 256 257 pipe_resource_reference(&dec->quads.buffer, NULL); 258 pipe_resource_reference(&dec->pos.buffer, NULL); 259 pipe_resource_reference(&dec->block_num.buffer, NULL); 260 261 pipe_sampler_view_reference(&dec->zscan_linear, NULL); 262 pipe_sampler_view_reference(&dec->zscan_normal, NULL); 263 pipe_sampler_view_reference(&dec->zscan_alternate, NULL); 264 265 FREE(dec); 266} 267 268static void * 269vl_mpeg12_create_buffer(struct pipe_video_decoder *decoder) 270{ 271 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder; 272 struct vl_mpeg12_buffer *buffer; 273 274 assert(dec); 275 276 buffer = CALLOC_STRUCT(vl_mpeg12_buffer); 277 if (buffer == NULL) 278 return NULL; 279 280 if (!vl_vb_init(&buffer->vertex_stream, dec->base.context, 281 dec->base.width / MACROBLOCK_WIDTH, 282 dec->base.height / MACROBLOCK_HEIGHT)) 283 goto error_vertex_buffer; 284 285 if (!init_mc_buffer(dec, buffer)) 286 goto error_mc; 287 288 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 289 if (!init_idct_buffer(dec, buffer)) 290 goto error_idct; 291 292 if (!init_zscan_buffer(dec, buffer)) 293 goto error_zscan; 294 295 if (dec->base.entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM) 296 vl_mpg12_bs_init(&buffer->bs, 297 dec->base.width / MACROBLOCK_WIDTH, 298 dec->base.height / MACROBLOCK_HEIGHT); 299 300 return buffer; 301 302error_zscan: 303 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 304 cleanup_idct_buffer(buffer); 305 306error_idct: 307 cleanup_mc_buffer(buffer); 308 309error_mc: 310 vl_vb_cleanup(&buffer->vertex_stream); 311 312error_vertex_buffer: 313 FREE(buffer); 314 return NULL; 315} 316 317static void 318vl_mpeg12_destroy_buffer(struct pipe_video_decoder *decoder, void *buffer) 319{ 320 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder*)decoder; 321 struct vl_mpeg12_buffer *buf = buffer; 322 323 assert(dec && buf); 324 325 cleanup_zscan_buffer(buf); 326 327 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 328 cleanup_idct_buffer(buf); 329 330 cleanup_mc_buffer(buf); 331 332 vl_vb_cleanup(&buf->vertex_stream); 333 334 FREE(buf); 335} 336 337static void 338vl_mpeg12_set_decode_buffer(struct pipe_video_decoder *decoder, void *buffer) 339{ 340 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 341 342 assert(dec && buffer); 343 344 dec->current_buffer = buffer; 345} 346 347static void 348vl_mpeg12_set_picture_parameters(struct pipe_video_decoder *decoder, 349 struct pipe_picture_desc *picture) 350{ 351 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 352 struct pipe_mpeg12_picture_desc *pic = (struct pipe_mpeg12_picture_desc *)picture; 353 354 assert(dec && pic); 355 356 dec->picture_desc = *pic; 357} 358 359static void 360vl_mpeg12_set_quant_matrix(struct pipe_video_decoder *decoder, 361 const uint8_t intra_matrix[64], 362 const uint8_t non_intra_matrix[64]) 363{ 364 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 365 366 assert(dec); 367 368 memcpy(dec->intra_matrix, intra_matrix, 64); 369 memcpy(dec->non_intra_matrix, non_intra_matrix, 64); 370} 371 372static void 373vl_mpeg12_set_decode_target(struct pipe_video_decoder *decoder, 374 struct pipe_video_buffer *target) 375{ 376 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 377 struct pipe_surface **surfaces; 378 unsigned i; 379 380 assert(dec); 381 382 surfaces = target->get_surfaces(target); 383 for (i = 0; i < VL_MAX_PLANES; ++i) 384 pipe_surface_reference(&dec->target_surfaces[i], surfaces[i]); 385} 386 387static void 388vl_mpeg12_set_reference_frames(struct pipe_video_decoder *decoder, 389 struct pipe_video_buffer **ref_frames, 390 unsigned num_ref_frames) 391{ 392 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 393 struct pipe_sampler_view **sv; 394 unsigned i,j; 395 396 assert(dec); 397 assert(num_ref_frames <= VL_MAX_REF_FRAMES); 398 399 for (i = 0; i < num_ref_frames; ++i) { 400 sv = ref_frames[i]->get_sampler_view_planes(ref_frames[i]); 401 for (j = 0; j < VL_MAX_PLANES; ++j) 402 pipe_sampler_view_reference(&dec->ref_frames[i][j], sv[j]); 403 } 404 405 for (; i < VL_MAX_REF_FRAMES; ++i) 406 for (j = 0; j < VL_MAX_PLANES; ++j) 407 pipe_sampler_view_reference(&dec->ref_frames[i][j], NULL); 408} 409 410static void 411vl_mpeg12_begin_frame(struct pipe_video_decoder *decoder) 412{ 413 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 414 415 struct vl_mpeg12_buffer *buf; 416 struct pipe_sampler_view **sampler_views; 417 unsigned i; 418 419 assert(dec); 420 421 buf = dec->current_buffer; 422 assert(buf); 423 424 for (i = 0; i < VL_MAX_PLANES; ++i) { 425 vl_zscan_upload_quant(&buf->zscan[i], dec->intra_matrix, true); 426 vl_zscan_upload_quant(&buf->zscan[i], dec->non_intra_matrix, false); 427 } 428 429 vl_vb_map(&buf->vertex_stream, dec->base.context); 430 431 sampler_views = buf->zscan_source->get_sampler_view_planes(buf->zscan_source); 432 433 assert(sampler_views); 434 435 for (i = 0; i < VL_MAX_PLANES; ++i) { 436 struct pipe_resource *tex = sampler_views[i]->texture; 437 struct pipe_box rect = 438 { 439 0, 0, 0, 440 tex->width0, 441 tex->height0, 442 1 443 }; 444 445 buf->tex_transfer[i] = dec->base.context->get_transfer 446 ( 447 dec->base.context, tex, 448 0, PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD, 449 &rect 450 ); 451 452 buf->texels[i] = dec->base.context->transfer_map(dec->base.context, buf->tex_transfer[i]); 453 } 454 455 if (dec->base.entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM) { 456 struct pipe_ycbcr_block *ycbcr_stream[VL_MAX_PLANES]; 457 struct pipe_motionvector *mv_stream[VL_MAX_REF_FRAMES]; 458 459 for (i = 0; i < VL_MAX_PLANES; ++i) 460 ycbcr_stream[i] = vl_vb_get_ycbcr_stream(&buf->vertex_stream, i); 461 462 for (i = 0; i < VL_MAX_REF_FRAMES; ++i) 463 mv_stream[i] = vl_vb_get_mv_stream(&buf->vertex_stream, i); 464 465 vl_mpg12_bs_set_buffers(&buf->bs, ycbcr_stream, buf->texels, mv_stream); 466 } else { 467 468 for (i = 0; i < VL_MAX_PLANES; ++i) 469 vl_zscan_set_layout(&buf->zscan[i], dec->zscan_linear); 470 } 471} 472 473static struct pipe_ycbcr_block * 474vl_mpeg12_get_ycbcr_stream(struct pipe_video_decoder *decoder, int component) 475{ 476 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 477 478 assert(dec && dec->current_buffer); 479 assert(component < VL_MAX_PLANES); 480 481 return vl_vb_get_ycbcr_stream(&dec->current_buffer->vertex_stream, component); 482} 483 484static short * 485vl_mpeg12_get_ycbcr_buffer(struct pipe_video_decoder *decoder, int component) 486{ 487 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 488 489 assert(dec && dec->current_buffer); 490 assert(component < VL_MAX_PLANES); 491 492 return dec->current_buffer->texels[component]; 493} 494 495static unsigned 496vl_mpeg12_get_mv_stream_stride(struct pipe_video_decoder *decoder) 497{ 498 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 499 500 assert(dec && dec->current_buffer); 501 502 return vl_vb_get_mv_stream_stride(&dec->current_buffer->vertex_stream); 503} 504 505static struct pipe_motionvector * 506vl_mpeg12_get_mv_stream(struct pipe_video_decoder *decoder, int ref_frame) 507{ 508 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 509 510 assert(dec && dec->current_buffer); 511 512 return vl_vb_get_mv_stream(&dec->current_buffer->vertex_stream, ref_frame); 513} 514 515static void 516vl_mpeg12_decode_bitstream(struct pipe_video_decoder *decoder, 517 unsigned num_bytes, const void *data, 518 unsigned num_ycbcr_blocks[3]) 519{ 520 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 521 struct vl_mpeg12_buffer *buf; 522 523 unsigned i; 524 525 assert(dec && dec->current_buffer); 526 527 buf = dec->current_buffer; 528 assert(buf); 529 530 for (i = 0; i < VL_MAX_PLANES; ++i) 531 vl_zscan_set_layout(&buf->zscan[i], dec->picture_desc.alternate_scan ? 532 dec->zscan_alternate : dec->zscan_normal); 533 534 vl_mpg12_bs_decode(&buf->bs, num_bytes, data, &dec->picture_desc, num_ycbcr_blocks); 535} 536 537static void 538vl_mpeg12_end_frame(struct pipe_video_decoder *decoder, unsigned num_ycbcr_blocks[3]) 539{ 540 struct vl_mpeg12_decoder *dec = (struct vl_mpeg12_decoder *)decoder; 541 struct pipe_sampler_view **mc_source_sv; 542 struct pipe_vertex_buffer vb[3]; 543 struct vl_mpeg12_buffer *buf; 544 545 unsigned i, j, component; 546 unsigned nr_components; 547 548 assert(dec && dec->current_buffer); 549 550 buf = dec->current_buffer; 551 552 vl_vb_unmap(&buf->vertex_stream, dec->base.context); 553 554 for (i = 0; i < VL_MAX_PLANES; ++i) { 555 dec->base.context->transfer_unmap(dec->base.context, buf->tex_transfer[i]); 556 dec->base.context->transfer_destroy(dec->base.context, buf->tex_transfer[i]); 557 } 558 559 vb[0] = dec->quads; 560 vb[1] = dec->pos; 561 562 dec->base.context->bind_vertex_elements_state(dec->base.context, dec->ves_mv); 563 for (i = 0; i < VL_MAX_PLANES; ++i) { 564 if (!dec->target_surfaces[i]) continue; 565 566 vl_mc_set_surface(&buf->mc[i], dec->target_surfaces[i]); 567 568 for (j = 0; j < VL_MAX_REF_FRAMES; ++j) { 569 if (!dec->ref_frames[j][i]) continue; 570 571 vb[2] = vl_vb_get_mv(&buf->vertex_stream, j);; 572 dec->base.context->set_vertex_buffers(dec->base.context, 3, vb); 573 574 vl_mc_render_ref(&buf->mc[i], dec->ref_frames[j][i]); 575 } 576 } 577 578 vb[2] = dec->block_num; 579 580 dec->base.context->bind_vertex_elements_state(dec->base.context, dec->ves_ycbcr); 581 for (i = 0; i < VL_MAX_PLANES; ++i) { 582 if (!num_ycbcr_blocks[i]) continue; 583 584 vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, i); 585 dec->base.context->set_vertex_buffers(dec->base.context, 3, vb); 586 587 vl_zscan_render(&buf->zscan[i] , num_ycbcr_blocks[i]); 588 589 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 590 vl_idct_flush(&buf->idct[i], num_ycbcr_blocks[i]); 591 } 592 593 mc_source_sv = dec->mc_source->get_sampler_view_planes(dec->mc_source); 594 for (i = 0, component = 0; i < VL_MAX_PLANES; ++i) { 595 if (!dec->target_surfaces[i]) continue; 596 597 nr_components = util_format_get_nr_components(dec->target_surfaces[i]->texture->format); 598 for (j = 0; j < nr_components; ++j, ++component) { 599 if (!num_ycbcr_blocks[i]) continue; 600 601 vb[1] = vl_vb_get_ycbcr(&buf->vertex_stream, component); 602 dec->base.context->set_vertex_buffers(dec->base.context, 3, vb); 603 604 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) 605 vl_idct_prepare_stage2(&buf->idct[component]); 606 else { 607 dec->base.context->set_fragment_sampler_views(dec->base.context, 1, &mc_source_sv[component]); 608 dec->base.context->bind_fragment_sampler_states(dec->base.context, 1, &dec->sampler_ycbcr); 609 } 610 vl_mc_render_ycbcr(&buf->mc[i], j, num_ycbcr_blocks[component]); 611 } 612 } 613} 614 615static void 616vl_mpeg12_flush(struct pipe_video_decoder *decoder) 617{ 618 assert(decoder); 619 620 //Noop, for shaders it is much faster to flush everything in end_frame 621} 622 623static bool 624init_pipe_state(struct vl_mpeg12_decoder *dec) 625{ 626 struct pipe_depth_stencil_alpha_state dsa; 627 struct pipe_sampler_state sampler; 628 unsigned i; 629 630 assert(dec); 631 632 memset(&dsa, 0, sizeof dsa); 633 dsa.depth.enabled = 0; 634 dsa.depth.writemask = 0; 635 dsa.depth.func = PIPE_FUNC_ALWAYS; 636 for (i = 0; i < 2; ++i) { 637 dsa.stencil[i].enabled = 0; 638 dsa.stencil[i].func = PIPE_FUNC_ALWAYS; 639 dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP; 640 dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP; 641 dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP; 642 dsa.stencil[i].valuemask = 0; 643 dsa.stencil[i].writemask = 0; 644 } 645 dsa.alpha.enabled = 0; 646 dsa.alpha.func = PIPE_FUNC_ALWAYS; 647 dsa.alpha.ref_value = 0; 648 dec->dsa = dec->base.context->create_depth_stencil_alpha_state(dec->base.context, &dsa); 649 dec->base.context->bind_depth_stencil_alpha_state(dec->base.context, dec->dsa); 650 651 memset(&sampler, 0, sizeof(sampler)); 652 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE; 653 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE; 654 sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_BORDER; 655 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST; 656 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE; 657 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST; 658 sampler.compare_mode = PIPE_TEX_COMPARE_NONE; 659 sampler.compare_func = PIPE_FUNC_ALWAYS; 660 sampler.normalized_coords = 1; 661 dec->sampler_ycbcr = dec->base.context->create_sampler_state(dec->base.context, &sampler); 662 if (!dec->sampler_ycbcr) 663 return false; 664 665 return true; 666} 667 668static const struct format_config* 669find_format_config(struct vl_mpeg12_decoder *dec, const struct format_config configs[], unsigned num_configs) 670{ 671 struct pipe_screen *screen; 672 unsigned i; 673 674 assert(dec); 675 676 screen = dec->base.context->screen; 677 678 for (i = 0; i < num_configs; ++i) { 679 if (!screen->is_format_supported(screen, configs[i].zscan_source_format, PIPE_TEXTURE_2D, 680 1, PIPE_BIND_SAMPLER_VIEW)) 681 continue; 682 683 if (configs[i].idct_source_format != PIPE_FORMAT_NONE) { 684 if (!screen->is_format_supported(screen, configs[i].idct_source_format, PIPE_TEXTURE_2D, 685 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET)) 686 continue; 687 688 if (!screen->is_format_supported(screen, configs[i].mc_source_format, PIPE_TEXTURE_3D, 689 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET)) 690 continue; 691 } else { 692 if (!screen->is_format_supported(screen, configs[i].mc_source_format, PIPE_TEXTURE_2D, 693 1, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET)) 694 continue; 695 } 696 return &configs[i]; 697 } 698 699 return NULL; 700} 701 702static bool 703init_zscan(struct vl_mpeg12_decoder *dec, const struct format_config* format_config) 704{ 705 unsigned num_channels; 706 707 assert(dec); 708 709 dec->zscan_source_format = format_config->zscan_source_format; 710 dec->zscan_linear = vl_zscan_layout(dec->base.context, vl_zscan_linear, dec->blocks_per_line); 711 dec->zscan_normal = vl_zscan_layout(dec->base.context, vl_zscan_normal, dec->blocks_per_line); 712 dec->zscan_alternate = vl_zscan_layout(dec->base.context, vl_zscan_alternate, dec->blocks_per_line); 713 714 num_channels = dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT ? 4 : 1; 715 716 if (!vl_zscan_init(&dec->zscan_y, dec->base.context, dec->base.width, dec->base.height, 717 dec->blocks_per_line, dec->num_blocks, num_channels)) 718 return false; 719 720 if (!vl_zscan_init(&dec->zscan_c, dec->base.context, dec->chroma_width, dec->chroma_height, 721 dec->blocks_per_line, dec->num_blocks, num_channels)) 722 return false; 723 724 return true; 725} 726 727static bool 728init_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_config) 729{ 730 unsigned nr_of_idct_render_targets, max_inst; 731 enum pipe_format formats[3]; 732 733 struct pipe_sampler_view *matrix = NULL; 734 735 nr_of_idct_render_targets = dec->base.context->screen->get_param 736 ( 737 dec->base.context->screen, PIPE_CAP_MAX_RENDER_TARGETS 738 ); 739 740 max_inst = dec->base.context->screen->get_shader_param 741 ( 742 dec->base.context->screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INSTRUCTIONS 743 ); 744 745 // Just assume we need 32 inst per render target, not 100% true, but should work in most cases 746 if (nr_of_idct_render_targets >= 4 && max_inst >= 32*4) 747 // more than 4 render targets usually doesn't makes any seens 748 nr_of_idct_render_targets = 4; 749 else 750 nr_of_idct_render_targets = 1; 751 752 formats[0] = formats[1] = formats[2] = format_config->idct_source_format; 753 dec->idct_source = vl_video_buffer_create_ex 754 ( 755 dec->base.context, dec->base.width / 4, dec->base.height, 1, 756 dec->base.chroma_format, formats, PIPE_USAGE_STATIC 757 ); 758 759 if (!dec->idct_source) 760 goto error_idct_source; 761 762 formats[0] = formats[1] = formats[2] = format_config->mc_source_format; 763 dec->mc_source = vl_video_buffer_create_ex 764 ( 765 dec->base.context, dec->base.width / nr_of_idct_render_targets, 766 dec->base.height / 4, nr_of_idct_render_targets, 767 dec->base.chroma_format, formats, PIPE_USAGE_STATIC 768 ); 769 770 if (!dec->mc_source) 771 goto error_mc_source; 772 773 if (!(matrix = vl_idct_upload_matrix(dec->base.context, format_config->idct_scale))) 774 goto error_matrix; 775 776 if (!vl_idct_init(&dec->idct_y, dec->base.context, dec->base.width, dec->base.height, 777 nr_of_idct_render_targets, matrix, matrix)) 778 goto error_y; 779 780 if(!vl_idct_init(&dec->idct_c, dec->base.context, dec->chroma_width, dec->chroma_height, 781 nr_of_idct_render_targets, matrix, matrix)) 782 goto error_c; 783 784 pipe_sampler_view_reference(&matrix, NULL); 785 786 return true; 787 788error_c: 789 vl_idct_cleanup(&dec->idct_y); 790 791error_y: 792 pipe_sampler_view_reference(&matrix, NULL); 793 794error_matrix: 795 dec->mc_source->destroy(dec->mc_source); 796 797error_mc_source: 798 dec->idct_source->destroy(dec->idct_source); 799 800error_idct_source: 801 return false; 802} 803 804static bool 805init_mc_source_widthout_idct(struct vl_mpeg12_decoder *dec, const struct format_config* format_config) 806{ 807 enum pipe_format formats[3]; 808 809 formats[0] = formats[1] = formats[2] = format_config->mc_source_format; 810 dec->mc_source = vl_video_buffer_create_ex 811 ( 812 dec->base.context, dec->base.width, dec->base.height, 1, 813 dec->base.chroma_format, formats, PIPE_USAGE_STATIC 814 ); 815 816 return dec->mc_source != NULL; 817} 818 819static void 820mc_vert_shader_callback(void *priv, struct vl_mc *mc, 821 struct ureg_program *shader, 822 unsigned first_output, 823 struct ureg_dst tex) 824{ 825 struct vl_mpeg12_decoder *dec = priv; 826 struct ureg_dst o_vtex; 827 828 assert(priv && mc); 829 assert(shader); 830 831 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { 832 struct vl_idct *idct = mc == &dec->mc_y ? &dec->idct_y : &dec->idct_c; 833 vl_idct_stage2_vert_shader(idct, shader, first_output, tex); 834 } else { 835 o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, first_output); 836 ureg_MOV(shader, ureg_writemask(o_vtex, TGSI_WRITEMASK_XY), ureg_src(tex)); 837 } 838} 839 840static void 841mc_frag_shader_callback(void *priv, struct vl_mc *mc, 842 struct ureg_program *shader, 843 unsigned first_input, 844 struct ureg_dst dst) 845{ 846 struct vl_mpeg12_decoder *dec = priv; 847 struct ureg_src src, sampler; 848 849 assert(priv && mc); 850 assert(shader); 851 852 if (dec->base.entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { 853 struct vl_idct *idct = mc == &dec->mc_y ? &dec->idct_y : &dec->idct_c; 854 vl_idct_stage2_frag_shader(idct, shader, first_input, dst); 855 } else { 856 src = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input, TGSI_INTERPOLATE_LINEAR); 857 sampler = ureg_DECL_sampler(shader, 0); 858 ureg_TEX(shader, dst, TGSI_TEXTURE_2D, src, sampler); 859 } 860} 861 862struct pipe_video_decoder * 863vl_create_mpeg12_decoder(struct pipe_context *context, 864 enum pipe_video_profile profile, 865 enum pipe_video_entrypoint entrypoint, 866 enum pipe_video_chroma_format chroma_format, 867 unsigned width, unsigned height) 868{ 869 const unsigned block_size_pixels = BLOCK_WIDTH * BLOCK_HEIGHT; 870 const struct format_config *format_config; 871 struct vl_mpeg12_decoder *dec; 872 873 assert(u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12); 874 875 dec = CALLOC_STRUCT(vl_mpeg12_decoder); 876 877 if (!dec) 878 return NULL; 879 880 dec->base.context = context; 881 dec->base.profile = profile; 882 dec->base.entrypoint = entrypoint; 883 dec->base.chroma_format = chroma_format; 884 dec->base.width = width; 885 dec->base.height = height; 886 887 dec->base.destroy = vl_mpeg12_destroy; 888 dec->base.create_buffer = vl_mpeg12_create_buffer; 889 dec->base.destroy_buffer = vl_mpeg12_destroy_buffer; 890 dec->base.set_decode_buffer = vl_mpeg12_set_decode_buffer; 891 dec->base.set_picture_parameters = vl_mpeg12_set_picture_parameters; 892 dec->base.set_quant_matrix = vl_mpeg12_set_quant_matrix; 893 dec->base.set_decode_target = vl_mpeg12_set_decode_target; 894 dec->base.set_reference_frames = vl_mpeg12_set_reference_frames; 895 dec->base.begin_frame = vl_mpeg12_begin_frame; 896 dec->base.get_ycbcr_stream = vl_mpeg12_get_ycbcr_stream; 897 dec->base.get_ycbcr_buffer = vl_mpeg12_get_ycbcr_buffer; 898 dec->base.get_mv_stream_stride = vl_mpeg12_get_mv_stream_stride; 899 dec->base.get_mv_stream = vl_mpeg12_get_mv_stream; 900 dec->base.decode_bitstream = vl_mpeg12_decode_bitstream; 901 dec->base.end_frame = vl_mpeg12_end_frame; 902 dec->base.flush = vl_mpeg12_flush; 903 904 dec->blocks_per_line = MAX2(util_next_power_of_two(dec->base.width) / block_size_pixels, 4); 905 dec->num_blocks = (dec->base.width * dec->base.height) / block_size_pixels; 906 907 dec->quads = vl_vb_upload_quads(dec->base.context); 908 dec->pos = vl_vb_upload_pos( 909 dec->base.context, 910 dec->base.width / MACROBLOCK_WIDTH, 911 dec->base.height / MACROBLOCK_HEIGHT 912 ); 913 dec->block_num = vl_vb_upload_block_num(dec->base.context, dec->num_blocks); 914 915 dec->ves_ycbcr = vl_vb_get_ves_ycbcr(dec->base.context); 916 dec->ves_mv = vl_vb_get_ves_mv(dec->base.context); 917 918 /* TODO: Implement 422, 444 */ 919 assert(dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420); 920 921 if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) { 922 dec->chroma_width = dec->base.width / 2; 923 dec->chroma_height = dec->base.height / 2; 924 } else if (dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422) { 925 dec->chroma_width = dec->base.width; 926 dec->chroma_height = dec->base.height / 2; 927 } else { 928 dec->chroma_width = dec->base.width; 929 dec->chroma_height = dec->base.height; 930 } 931 932 switch (entrypoint) { 933 case PIPE_VIDEO_ENTRYPOINT_BITSTREAM: 934 format_config = find_format_config(dec, bitstream_format_config, num_bitstream_format_configs); 935 break; 936 937 case PIPE_VIDEO_ENTRYPOINT_IDCT: 938 format_config = find_format_config(dec, idct_format_config, num_idct_format_configs); 939 break; 940 941 case PIPE_VIDEO_ENTRYPOINT_MC: 942 format_config = find_format_config(dec, mc_format_config, num_mc_format_configs); 943 break; 944 945 default: 946 assert(0); 947 return NULL; 948 } 949 950 if (!format_config) 951 return NULL; 952 953 if (!init_zscan(dec, format_config)) 954 goto error_zscan; 955 956 if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { 957 if (!init_idct(dec, format_config)) 958 goto error_sources; 959 } else { 960 if (!init_mc_source_widthout_idct(dec, format_config)) 961 goto error_sources; 962 } 963 964 if (!vl_mc_init(&dec->mc_y, dec->base.context, dec->base.width, dec->base.height, 965 MACROBLOCK_HEIGHT, format_config->mc_scale, 966 mc_vert_shader_callback, mc_frag_shader_callback, dec)) 967 goto error_mc_y; 968 969 // TODO 970 if (!vl_mc_init(&dec->mc_c, dec->base.context, dec->base.width, dec->base.height, 971 BLOCK_HEIGHT, format_config->mc_scale, 972 mc_vert_shader_callback, mc_frag_shader_callback, dec)) 973 goto error_mc_c; 974 975 if (!init_pipe_state(dec)) 976 goto error_pipe_state; 977 978 return &dec->base; 979 980error_pipe_state: 981 vl_mc_cleanup(&dec->mc_c); 982 983error_mc_c: 984 vl_mc_cleanup(&dec->mc_y); 985 986error_mc_y: 987 if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) { 988 vl_idct_cleanup(&dec->idct_y); 989 vl_idct_cleanup(&dec->idct_c); 990 dec->idct_source->destroy(dec->idct_source); 991 } 992 dec->mc_source->destroy(dec->mc_source); 993 994error_sources: 995 vl_zscan_cleanup(&dec->zscan_y); 996 vl_zscan_cleanup(&dec->zscan_c); 997 998error_zscan: 999 FREE(dec); 1000 return NULL; 1001} 1002