1 /**************************************************************************
3 * Copyright 2009 Younes Manton.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
31 #include <util/u_memory.h>
32 #include <util/u_rect.h>
33 #include <util/u_video.h>
35 #include "vl_mpeg12_decoder.h"
36 #include "vl_defines.h"
38 #define SCALE_FACTOR_SNORM (32768.0f / 256.0f)
39 #define SCALE_FACTOR_SSCALED (1.0f / 256.0f)
41 struct format_config
{
42 enum pipe_format zscan_source_format
;
43 enum pipe_format idct_source_format
;
44 enum pipe_format mc_source_format
;
50 static 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
}
57 static const unsigned num_bitstream_format_configs
=
58 sizeof(bitstream_format_config
) / sizeof(struct format_config
);
60 static 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
}
67 static const unsigned num_idct_format_configs
=
68 sizeof(idct_format_config
) / sizeof(struct format_config
);
70 static 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
}
75 static const unsigned num_mc_format_configs
=
76 sizeof(mc_format_config
) / sizeof(struct format_config
);
79 init_zscan_buffer(struct vl_mpeg12_decoder
*dec
, struct vl_mpeg12_buffer
*buffer
)
81 enum pipe_format formats
[3];
83 struct pipe_sampler_view
**source
;
84 struct pipe_surface
**destination
;
88 assert(dec
&& buffer
);
90 formats
[0] = formats
[1] = formats
[2] = dec
->zscan_source_format
;
91 buffer
->zscan_source
= vl_video_buffer_create_ex
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
99 if (!buffer
->zscan_source
)
102 source
= buffer
->zscan_source
->get_sampler_view_planes(buffer
->zscan_source
);
106 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
107 destination
= dec
->idct_source
->get_surfaces(dec
->idct_source
);
109 destination
= dec
->mc_source
->get_surfaces(dec
->mc_source
);
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
]))
123 vl_zscan_cleanup_buffer(&buffer
->zscan
[i
- 1]);
127 buffer
->zscan_source
->destroy(buffer
->zscan_source
);
134 cleanup_zscan_buffer(struct vl_mpeg12_buffer
*buffer
)
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
);
146 init_idct_buffer(struct vl_mpeg12_decoder
*dec
, struct vl_mpeg12_buffer
*buffer
)
148 struct pipe_sampler_view
**idct_source_sv
, **mc_source_sv
;
152 assert(dec
&& buffer
);
154 idct_source_sv
= dec
->idct_source
->get_sampler_view_planes(dec
->idct_source
);
156 goto error_source_sv
;
158 mc_source_sv
= dec
->mc_source
->get_sampler_view_planes(dec
->mc_source
);
160 goto error_mc_source_sv
;
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
],
172 vl_idct_cleanup_buffer(&buffer
->idct
[i
- 1]);
180 cleanup_idct_buffer(struct vl_mpeg12_buffer
*buf
)
186 for (i
= 0; i
< 3; ++i
)
187 vl_idct_cleanup_buffer(&buf
->idct
[0]);
191 init_mc_buffer(struct vl_mpeg12_decoder
*dec
, struct vl_mpeg12_buffer
*buf
)
195 if(!vl_mc_init_buffer(&dec
->mc_y
, &buf
->mc
[0]))
198 if(!vl_mc_init_buffer(&dec
->mc_c
, &buf
->mc
[1]))
201 if(!vl_mc_init_buffer(&dec
->mc_c
, &buf
->mc
[2]))
207 vl_mc_cleanup_buffer(&buf
->mc
[1]);
210 vl_mc_cleanup_buffer(&buf
->mc
[0]);
217 cleanup_mc_buffer(struct vl_mpeg12_buffer
*buf
)
223 for (i
= 0; i
< VL_MAX_PLANES
; ++i
)
224 vl_mc_cleanup_buffer(&buf
->mc
[i
]);
228 vl_mpeg12_destroy(struct pipe_video_decoder
*decoder
)
230 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
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
);
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
);
241 vl_mc_cleanup(&dec
->mc_y
);
242 vl_mc_cleanup(&dec
->mc_c
);
243 dec
->mc_source
->destroy(dec
->mc_source
);
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
);
251 vl_zscan_cleanup(&dec
->zscan_y
);
252 vl_zscan_cleanup(&dec
->zscan_c
);
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
);
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
);
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
);
269 vl_mpeg12_create_buffer(struct pipe_video_decoder
*decoder
)
271 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
272 struct vl_mpeg12_buffer
*buffer
;
276 buffer
= CALLOC_STRUCT(vl_mpeg12_buffer
);
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
;
285 if (!init_mc_buffer(dec
, buffer
))
288 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
289 if (!init_idct_buffer(dec
, buffer
))
292 if (!init_zscan_buffer(dec
, buffer
))
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
);
303 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
304 cleanup_idct_buffer(buffer
);
307 cleanup_mc_buffer(buffer
);
310 vl_vb_cleanup(&buffer
->vertex_stream
);
318 vl_mpeg12_destroy_buffer(struct pipe_video_decoder
*decoder
, void *buffer
)
320 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
321 struct vl_mpeg12_buffer
*buf
= buffer
;
325 cleanup_zscan_buffer(buf
);
327 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
328 cleanup_idct_buffer(buf
);
330 cleanup_mc_buffer(buf
);
332 vl_vb_cleanup(&buf
->vertex_stream
);
338 vl_mpeg12_set_decode_buffer(struct pipe_video_decoder
*decoder
, void *buffer
)
340 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
342 assert(dec
&& buffer
);
344 dec
->current_buffer
= buffer
;
348 vl_mpeg12_set_picture_parameters(struct pipe_video_decoder
*decoder
,
349 struct pipe_picture_desc
*picture
)
351 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
352 struct pipe_mpeg12_picture_desc
*pic
= (struct pipe_mpeg12_picture_desc
*)picture
;
356 dec
->picture_desc
= *pic
;
360 vl_mpeg12_set_quant_matrix(struct pipe_video_decoder
*decoder
,
361 const uint8_t intra_matrix
[64],
362 const uint8_t non_intra_matrix
[64])
364 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
368 memcpy(dec
->intra_matrix
, intra_matrix
, 64);
369 memcpy(dec
->non_intra_matrix
, non_intra_matrix
, 64);
373 vl_mpeg12_set_decode_target(struct pipe_video_decoder
*decoder
,
374 struct pipe_video_buffer
*target
)
376 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
377 struct pipe_surface
**surfaces
;
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
]);
388 vl_mpeg12_set_reference_frames(struct pipe_video_decoder
*decoder
,
389 struct pipe_video_buffer
**ref_frames
,
390 unsigned num_ref_frames
)
392 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
393 struct pipe_sampler_view
**sv
;
397 assert(num_ref_frames
<= VL_MAX_REF_FRAMES
);
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
]);
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
);
411 vl_mpeg12_begin_frame(struct pipe_video_decoder
*decoder
)
413 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
415 struct vl_mpeg12_buffer
*buf
;
416 struct pipe_sampler_view
**sampler_views
;
421 buf
= dec
->current_buffer
;
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);
429 vl_vb_map(&buf
->vertex_stream
, dec
->base
.context
);
431 sampler_views
= buf
->zscan_source
->get_sampler_view_planes(buf
->zscan_source
);
433 assert(sampler_views
);
435 for (i
= 0; i
< VL_MAX_PLANES
; ++i
) {
436 struct pipe_resource
*tex
= sampler_views
[i
]->texture
;
437 struct pipe_box rect
=
445 buf
->tex_transfer
[i
] = dec
->base
.context
->get_transfer
447 dec
->base
.context
, tex
,
448 0, PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD
,
452 buf
->texels
[i
] = dec
->base
.context
->transfer_map(dec
->base
.context
, buf
->tex_transfer
[i
]);
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
];
459 for (i
= 0; i
< VL_MAX_PLANES
; ++i
)
460 ycbcr_stream
[i
] = vl_vb_get_ycbcr_stream(&buf
->vertex_stream
, i
);
462 for (i
= 0; i
< VL_MAX_REF_FRAMES
; ++i
)
463 mv_stream
[i
] = vl_vb_get_mv_stream(&buf
->vertex_stream
, i
);
465 vl_mpg12_bs_set_buffers(&buf
->bs
, ycbcr_stream
, buf
->texels
, mv_stream
);
468 for (i
= 0; i
< VL_MAX_PLANES
; ++i
)
469 vl_zscan_set_layout(&buf
->zscan
[i
], dec
->zscan_linear
);
473 static struct pipe_ycbcr_block
*
474 vl_mpeg12_get_ycbcr_stream(struct pipe_video_decoder
*decoder
, int component
)
476 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
478 assert(dec
&& dec
->current_buffer
);
479 assert(component
< VL_MAX_PLANES
);
481 return vl_vb_get_ycbcr_stream(&dec
->current_buffer
->vertex_stream
, component
);
485 vl_mpeg12_get_ycbcr_buffer(struct pipe_video_decoder
*decoder
, int component
)
487 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
489 assert(dec
&& dec
->current_buffer
);
490 assert(component
< VL_MAX_PLANES
);
492 return dec
->current_buffer
->texels
[component
];
496 vl_mpeg12_get_mv_stream_stride(struct pipe_video_decoder
*decoder
)
498 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
500 assert(dec
&& dec
->current_buffer
);
502 return vl_vb_get_mv_stream_stride(&dec
->current_buffer
->vertex_stream
);
505 static struct pipe_motionvector
*
506 vl_mpeg12_get_mv_stream(struct pipe_video_decoder
*decoder
, int ref_frame
)
508 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
510 assert(dec
&& dec
->current_buffer
);
512 return vl_vb_get_mv_stream(&dec
->current_buffer
->vertex_stream
, ref_frame
);
516 vl_mpeg12_decode_bitstream(struct pipe_video_decoder
*decoder
,
517 unsigned num_bytes
, const void *data
,
518 unsigned num_ycbcr_blocks
[3])
520 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
521 struct vl_mpeg12_buffer
*buf
;
525 assert(dec
&& dec
->current_buffer
);
527 buf
= dec
->current_buffer
;
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
);
534 vl_mpg12_bs_decode(&buf
->bs
, num_bytes
, data
, &dec
->picture_desc
, num_ycbcr_blocks
);
538 vl_mpeg12_end_frame(struct pipe_video_decoder
*decoder
, unsigned num_ycbcr_blocks
[3])
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
;
545 unsigned i
, j
, component
;
546 unsigned nr_components
;
548 assert(dec
&& dec
->current_buffer
);
550 buf
= dec
->current_buffer
;
552 vl_vb_unmap(&buf
->vertex_stream
, dec
->base
.context
);
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
]);
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;
566 vl_mc_set_surface(&buf
->mc
[i
], dec
->target_surfaces
[i
]);
568 for (j
= 0; j
< VL_MAX_REF_FRAMES
; ++j
) {
569 if (!dec
->ref_frames
[j
][i
]) continue;
571 vb
[2] = vl_vb_get_mv(&buf
->vertex_stream
, j
);;
572 dec
->base
.context
->set_vertex_buffers(dec
->base
.context
, 3, vb
);
574 vl_mc_render_ref(&buf
->mc
[i
], dec
->ref_frames
[j
][i
]);
578 vb
[2] = dec
->block_num
;
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;
584 vb
[1] = vl_vb_get_ycbcr(&buf
->vertex_stream
, i
);
585 dec
->base
.context
->set_vertex_buffers(dec
->base
.context
, 3, vb
);
587 vl_zscan_render(&buf
->zscan
[i
] , num_ycbcr_blocks
[i
]);
589 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
590 vl_idct_flush(&buf
->idct
[i
], num_ycbcr_blocks
[i
]);
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;
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;
601 vb
[1] = vl_vb_get_ycbcr(&buf
->vertex_stream
, component
);
602 dec
->base
.context
->set_vertex_buffers(dec
->base
.context
, 3, vb
);
604 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
605 vl_idct_prepare_stage2(&buf
->idct
[component
]);
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
);
610 vl_mc_render_ycbcr(&buf
->mc
[i
], j
, num_ycbcr_blocks
[component
]);
616 vl_mpeg12_flush(struct pipe_video_decoder
*decoder
)
620 //Noop, for shaders it is much faster to flush everything in end_frame
624 init_pipe_state(struct vl_mpeg12_decoder
*dec
)
626 struct pipe_depth_stencil_alpha_state dsa
;
627 struct pipe_sampler_state sampler
;
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;
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
);
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
)
668 static const struct format_config
*
669 find_format_config(struct vl_mpeg12_decoder
*dec
, const struct format_config configs
[], unsigned num_configs
)
671 struct pipe_screen
*screen
;
676 screen
= dec
->base
.context
->screen
;
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
))
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
))
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
))
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
))
703 init_zscan(struct vl_mpeg12_decoder
*dec
, const struct format_config
* format_config
)
705 unsigned num_channels
;
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
);
714 num_channels
= dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
? 4 : 1;
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
))
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
))
728 init_idct(struct vl_mpeg12_decoder
*dec
, const struct format_config
* format_config
)
730 unsigned nr_of_idct_render_targets
, max_inst
;
731 enum pipe_format formats
[3];
733 struct pipe_sampler_view
*matrix
= NULL
;
735 nr_of_idct_render_targets
= dec
->base
.context
->screen
->get_param
737 dec
->base
.context
->screen
, PIPE_CAP_MAX_RENDER_TARGETS
740 max_inst
= dec
->base
.context
->screen
->get_shader_param
742 dec
->base
.context
->screen
, PIPE_SHADER_FRAGMENT
, PIPE_SHADER_CAP_MAX_INSTRUCTIONS
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;
750 nr_of_idct_render_targets
= 1;
752 formats
[0] = formats
[1] = formats
[2] = format_config
->idct_source_format
;
753 dec
->idct_source
= vl_video_buffer_create_ex
755 dec
->base
.context
, dec
->base
.width
/ 4, dec
->base
.height
, 1,
756 dec
->base
.chroma_format
, formats
, PIPE_USAGE_STATIC
759 if (!dec
->idct_source
)
760 goto error_idct_source
;
762 formats
[0] = formats
[1] = formats
[2] = format_config
->mc_source_format
;
763 dec
->mc_source
= vl_video_buffer_create_ex
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
771 goto error_mc_source
;
773 if (!(matrix
= vl_idct_upload_matrix(dec
->base
.context
, format_config
->idct_scale
)))
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
))
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
))
784 pipe_sampler_view_reference(&matrix
, NULL
);
789 vl_idct_cleanup(&dec
->idct_y
);
792 pipe_sampler_view_reference(&matrix
, NULL
);
795 dec
->mc_source
->destroy(dec
->mc_source
);
798 dec
->idct_source
->destroy(dec
->idct_source
);
805 init_mc_source_widthout_idct(struct vl_mpeg12_decoder
*dec
, const struct format_config
* format_config
)
807 enum pipe_format formats
[3];
809 formats
[0] = formats
[1] = formats
[2] = format_config
->mc_source_format
;
810 dec
->mc_source
= vl_video_buffer_create_ex
812 dec
->base
.context
, dec
->base
.width
, dec
->base
.height
, 1,
813 dec
->base
.chroma_format
, formats
, PIPE_USAGE_STATIC
816 return dec
->mc_source
!= NULL
;
820 mc_vert_shader_callback(void *priv
, struct vl_mc
*mc
,
821 struct ureg_program
*shader
,
822 unsigned first_output
,
825 struct vl_mpeg12_decoder
*dec
= priv
;
826 struct ureg_dst o_vtex
;
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
);
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
));
841 mc_frag_shader_callback(void *priv
, struct vl_mc
*mc
,
842 struct ureg_program
*shader
,
843 unsigned first_input
,
846 struct vl_mpeg12_decoder
*dec
= priv
;
847 struct ureg_src src
, sampler
;
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
);
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
);
862 struct pipe_video_decoder
*
863 vl_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
)
869 const unsigned block_size_pixels
= BLOCK_WIDTH
* BLOCK_HEIGHT
;
870 const struct format_config
*format_config
;
871 struct vl_mpeg12_decoder
*dec
;
873 assert(u_reduce_video_profile(profile
) == PIPE_VIDEO_CODEC_MPEG12
);
875 dec
= CALLOC_STRUCT(vl_mpeg12_decoder
);
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
;
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
;
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
;
907 dec
->quads
= vl_vb_upload_quads(dec
->base
.context
);
908 dec
->pos
= vl_vb_upload_pos(
910 dec
->base
.width
/ MACROBLOCK_WIDTH
,
911 dec
->base
.height
/ MACROBLOCK_HEIGHT
913 dec
->block_num
= vl_vb_upload_block_num(dec
->base
.context
, dec
->num_blocks
);
915 dec
->ves_ycbcr
= vl_vb_get_ves_ycbcr(dec
->base
.context
);
916 dec
->ves_mv
= vl_vb_get_ves_mv(dec
->base
.context
);
918 /* TODO: Implement 422, 444 */
919 assert(dec
->base
.chroma_format
== PIPE_VIDEO_CHROMA_FORMAT_420
);
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;
928 dec
->chroma_width
= dec
->base
.width
;
929 dec
->chroma_height
= dec
->base
.height
;
932 switch (entrypoint
) {
933 case PIPE_VIDEO_ENTRYPOINT_BITSTREAM
:
934 format_config
= find_format_config(dec
, bitstream_format_config
, num_bitstream_format_configs
);
937 case PIPE_VIDEO_ENTRYPOINT_IDCT
:
938 format_config
= find_format_config(dec
, idct_format_config
, num_idct_format_configs
);
941 case PIPE_VIDEO_ENTRYPOINT_MC
:
942 format_config
= find_format_config(dec
, mc_format_config
, num_mc_format_configs
);
953 if (!init_zscan(dec
, format_config
))
956 if (entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
) {
957 if (!init_idct(dec
, format_config
))
960 if (!init_mc_source_widthout_idct(dec
, format_config
))
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
))
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
))
975 if (!init_pipe_state(dec
))
976 goto error_pipe_state
;
981 vl_mc_cleanup(&dec
->mc_c
);
984 vl_mc_cleanup(&dec
->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
);
992 dec
->mc_source
->destroy(dec
->mc_source
);
995 vl_zscan_cleanup(&dec
->zscan_y
);
996 vl_zscan_cleanup(&dec
->zscan_c
);