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 static const unsigned const_empty_block_mask_420
[3][2][2] = {
42 { { 0x20, 0x10 }, { 0x08, 0x04 } },
43 { { 0x02, 0x02 }, { 0x02, 0x02 } },
44 { { 0x01, 0x01 }, { 0x01, 0x01 } }
47 static const enum pipe_format const_idct_source_formats
[] = {
48 PIPE_FORMAT_R16G16B16A16_SNORM
,
49 PIPE_FORMAT_R16G16B16A16_SSCALED
52 static const unsigned num_idct_source_formats
=
53 sizeof(const_idct_source_formats
) / sizeof(enum pipe_format
);
55 static const enum pipe_format const_idct_intermediate_formats
[] = {
56 PIPE_FORMAT_R16G16B16A16_FLOAT
,
57 PIPE_FORMAT_R16G16B16A16_SNORM
,
58 PIPE_FORMAT_R16G16B16A16_SSCALED
,
59 PIPE_FORMAT_R32G32B32A32_FLOAT
62 static const unsigned num_idct_intermediate_formats
=
63 sizeof(const_idct_intermediate_formats
) / sizeof(enum pipe_format
);
65 static const enum pipe_format const_mc_source_formats
[] = {
66 PIPE_FORMAT_R16_SNORM
,
67 PIPE_FORMAT_R16_SSCALED
70 static const unsigned num_mc_source_formats
=
71 sizeof(const_mc_source_formats
) / sizeof(enum pipe_format
);
74 map_buffers(struct vl_mpeg12_decoder
*ctx
, struct vl_mpeg12_buffer
*buffer
)
76 struct pipe_sampler_view
**sampler_views
;
77 struct pipe_resource
*tex
;
80 assert(ctx
&& buffer
);
82 if (ctx
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
83 sampler_views
= buffer
->idct_source
->get_sampler_views(buffer
->idct_source
);
85 sampler_views
= buffer
->mc_source
->get_sampler_views(buffer
->mc_source
);
86 assert(sampler_views
);
88 for (i
= 0; i
< VL_MAX_PLANES
; ++i
) {
89 tex
= sampler_views
[i
]->texture
;
91 struct pipe_box rect
=
99 buffer
->tex_transfer
[i
] = ctx
->pipe
->get_transfer
102 0, PIPE_TRANSFER_WRITE
| PIPE_TRANSFER_DISCARD
,
106 buffer
->texels
[i
] = ctx
->pipe
->transfer_map(ctx
->pipe
, buffer
->tex_transfer
[i
]);
111 upload_block(struct vl_mpeg12_buffer
*buffer
, unsigned plane
, unsigned x
, unsigned y
, short *block
)
121 tex_pitch
= buffer
->tex_transfer
[plane
]->stride
/ sizeof(short);
122 texels
= buffer
->texels
[plane
] + y
* tex_pitch
* BLOCK_HEIGHT
+ x
* BLOCK_WIDTH
;
124 for (i
= 0; i
< BLOCK_HEIGHT
; ++i
)
125 memcpy(texels
+ i
* tex_pitch
, block
+ i
* BLOCK_WIDTH
, BLOCK_WIDTH
* sizeof(short));
129 upload_buffer(struct vl_mpeg12_decoder
*ctx
,
130 struct vl_mpeg12_buffer
*buffer
,
131 struct pipe_mpeg12_macroblock
*mb
)
142 for (y
= 0; y
< 2; ++y
) {
143 for (x
= 0; x
< 2; ++x
, ++tb
) {
144 if (mb
->cbp
& (*ctx
->empty_block_mask
)[0][y
][x
]) {
145 upload_block(buffer
, 0, mb
->mbx
* 2 + x
, mb
->mby
* 2 + y
, blocks
);
146 blocks
+= BLOCK_WIDTH
* BLOCK_HEIGHT
;
151 /* TODO: Implement 422, 444 */
152 assert(ctx
->base
.chroma_format
== PIPE_VIDEO_CHROMA_FORMAT_420
);
154 for (tb
= 1; tb
< 3; ++tb
) {
155 if (mb
->cbp
& (*ctx
->empty_block_mask
)[tb
][0][0]) {
156 upload_block(buffer
, tb
, mb
->mbx
, mb
->mby
, blocks
);
157 blocks
+= BLOCK_WIDTH
* BLOCK_HEIGHT
;
163 unmap_buffers(struct vl_mpeg12_decoder
*ctx
, struct vl_mpeg12_buffer
*buffer
)
167 assert(ctx
&& buffer
);
169 for (i
= 0; i
< VL_MAX_PLANES
; ++i
) {
170 ctx
->pipe
->transfer_unmap(ctx
->pipe
, buffer
->tex_transfer
[i
]);
171 ctx
->pipe
->transfer_destroy(ctx
->pipe
, buffer
->tex_transfer
[i
]);
176 cleanup_idct_buffer(struct vl_mpeg12_buffer
*buf
)
178 struct vl_mpeg12_decoder
*dec
;
181 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
184 buf
->idct_source
->destroy(buf
->idct_source
);
185 buf
->idct_intermediate
->destroy(buf
->idct_intermediate
);
186 vl_idct_cleanup_buffer(&dec
->idct_y
, &buf
->idct
[0]);
187 vl_idct_cleanup_buffer(&dec
->idct_c
, &buf
->idct
[1]);
188 vl_idct_cleanup_buffer(&dec
->idct_c
, &buf
->idct
[2]);
192 vl_mpeg12_buffer_destroy(struct pipe_video_decode_buffer
*buffer
)
194 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
195 struct vl_mpeg12_decoder
*dec
;
200 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
203 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
204 cleanup_idct_buffer(buf
);
206 buf
->mc_source
->destroy(buf
->mc_source
);
207 vl_vb_cleanup(&buf
->vertex_stream
);
208 for (i
= 0; i
< VL_MAX_PLANES
; ++i
)
209 vl_mc_cleanup_buffer(&buf
->mc
[i
]);
215 vl_mpeg12_buffer_map(struct pipe_video_decode_buffer
*buffer
)
217 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
218 struct vl_mpeg12_decoder
*dec
;
221 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
224 vl_vb_map(&buf
->vertex_stream
, dec
->pipe
);
225 map_buffers(dec
, buf
);
229 vl_mpeg12_buffer_add_macroblocks(struct pipe_video_decode_buffer
*buffer
,
230 unsigned num_macroblocks
,
231 struct pipe_macroblock
*macroblocks
)
233 struct pipe_mpeg12_macroblock
*mb
= (struct pipe_mpeg12_macroblock
*)macroblocks
;
234 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
235 struct vl_mpeg12_decoder
*dec
;
240 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
243 assert(num_macroblocks
);
245 assert(macroblocks
->codec
== PIPE_VIDEO_CODEC_MPEG12
);
247 for ( i
= 0; i
< num_macroblocks
; ++i
) {
248 vl_vb_add_block(&buf
->vertex_stream
, &mb
[i
], dec
->empty_block_mask
);
249 upload_buffer(dec
, buf
, &mb
[i
]);
254 vl_mpeg12_buffer_unmap(struct pipe_video_decode_buffer
*buffer
)
256 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
257 struct vl_mpeg12_decoder
*dec
;
260 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
263 vl_vb_unmap(&buf
->vertex_stream
, dec
->pipe
);
264 unmap_buffers(dec
, buf
);
268 vl_mpeg12_destroy(struct pipe_video_decoder
*decoder
)
270 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
274 /* Asserted in softpipe_delete_fs_state() for some reason */
275 dec
->pipe
->bind_vs_state(dec
->pipe
, NULL
);
276 dec
->pipe
->bind_fs_state(dec
->pipe
, NULL
);
278 dec
->pipe
->delete_depth_stencil_alpha_state(dec
->pipe
, dec
->dsa
);
280 vl_mc_cleanup(&dec
->mc_y
);
281 vl_mc_cleanup(&dec
->mc_c
);
283 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
) {
284 vl_idct_cleanup(&dec
->idct_y
);
285 vl_idct_cleanup(&dec
->idct_c
);
288 dec
->pipe
->delete_vertex_elements_state(dec
->pipe
, dec
->ves_ycbcr
);
289 dec
->pipe
->delete_vertex_elements_state(dec
->pipe
, dec
->ves_mv
);
291 pipe_resource_reference(&dec
->quads
.buffer
, NULL
);
292 pipe_resource_reference(&dec
->pos
.buffer
, NULL
);
298 init_idct_buffer(struct vl_mpeg12_buffer
*buffer
)
300 enum pipe_format formats
[3];
302 struct pipe_sampler_view
**idct_source_sv
, **idct_intermediate_sv
;
303 struct pipe_surface
**idct_surfaces
;
305 struct vl_mpeg12_decoder
*dec
;
311 dec
= (struct vl_mpeg12_decoder
*)buffer
->base
.decoder
;
313 formats
[0] = formats
[1] = formats
[2] = dec
->idct_source_format
;
314 buffer
->idct_source
= vl_video_buffer_init(dec
->base
.context
, dec
->pipe
,
315 dec
->base
.width
/ 4, dec
->base
.height
, 1,
316 dec
->base
.chroma_format
,
317 formats
, PIPE_USAGE_STREAM
);
318 if (!buffer
->idct_source
)
321 formats
[0] = formats
[1] = formats
[2] = dec
->idct_intermediate_format
;
322 buffer
->idct_intermediate
= vl_video_buffer_init(dec
->base
.context
, dec
->pipe
,
323 dec
->base
.width
/ dec
->nr_of_idct_render_targets
,
324 dec
->base
.height
/ 4, dec
->nr_of_idct_render_targets
,
325 dec
->base
.chroma_format
,
326 formats
, PIPE_USAGE_STATIC
);
328 if (!buffer
->idct_intermediate
)
329 goto error_intermediate
;
331 idct_source_sv
= buffer
->idct_source
->get_sampler_views(buffer
->idct_source
);
333 goto error_source_sv
;
335 idct_intermediate_sv
= buffer
->idct_intermediate
->get_sampler_views(buffer
->idct_intermediate
);
336 if (!idct_intermediate_sv
)
337 goto error_intermediate_sv
;
339 idct_surfaces
= buffer
->mc_source
->get_surfaces(buffer
->mc_source
);
343 for (i
= 0; i
< 3; ++i
)
344 if (!vl_idct_init_buffer(i
== 0 ? &dec
->idct_y
: &dec
->idct_c
,
345 &buffer
->idct
[i
], idct_source_sv
[i
],
346 idct_intermediate_sv
[i
], idct_surfaces
[i
]))
353 vl_idct_cleanup_buffer(i
== 1 ? &dec
->idct_c
: &dec
->idct_y
, &buffer
->idct
[i
- 1]);
356 error_intermediate_sv
:
358 buffer
->idct_intermediate
->destroy(buffer
->idct_intermediate
);
361 buffer
->idct_source
->destroy(buffer
->idct_source
);
367 static struct pipe_video_decode_buffer
*
368 vl_mpeg12_create_buffer(struct pipe_video_decoder
*decoder
)
370 enum pipe_format formats
[3];
372 struct vl_mpeg12_decoder
*dec
= (struct vl_mpeg12_decoder
*)decoder
;
373 struct vl_mpeg12_buffer
*buffer
;
375 struct pipe_sampler_view
**mc_source_sv
;
379 buffer
= CALLOC_STRUCT(vl_mpeg12_buffer
);
383 buffer
->base
.decoder
= decoder
;
384 buffer
->base
.destroy
= vl_mpeg12_buffer_destroy
;
385 buffer
->base
.map
= vl_mpeg12_buffer_map
;
386 buffer
->base
.add_macroblocks
= vl_mpeg12_buffer_add_macroblocks
;
387 buffer
->base
.unmap
= vl_mpeg12_buffer_unmap
;
389 vl_vb_init(&buffer
->vertex_stream
, dec
->pipe
,
390 dec
->base
.width
/ MACROBLOCK_WIDTH
,
391 dec
->base
.height
/ MACROBLOCK_HEIGHT
);
393 formats
[0] = formats
[1] = formats
[2] =dec
->mc_source_format
;
394 buffer
->mc_source
= vl_video_buffer_init(dec
->base
.context
, dec
->pipe
,
395 dec
->base
.width
, dec
->base
.height
, 1,
396 dec
->base
.chroma_format
,
397 formats
, PIPE_USAGE_STATIC
);
399 if (!buffer
->mc_source
)
400 goto error_mc_source
;
402 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
403 if (!init_idct_buffer(buffer
))
406 mc_source_sv
= buffer
->mc_source
->get_sampler_views(buffer
->mc_source
);
408 goto error_mc_source_sv
;
410 if(!vl_mc_init_buffer(&dec
->mc_y
, &buffer
->mc
[0], mc_source_sv
[0]))
413 if(!vl_mc_init_buffer(&dec
->mc_c
, &buffer
->mc
[1], mc_source_sv
[1]))
416 if(!vl_mc_init_buffer(&dec
->mc_c
, &buffer
->mc
[2], mc_source_sv
[2]))
419 return &buffer
->base
;
422 vl_mc_cleanup_buffer(&buffer
->mc
[1]);
425 vl_mc_cleanup_buffer(&buffer
->mc
[0]);
429 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
430 cleanup_idct_buffer(buffer
);
433 buffer
->mc_source
->destroy(buffer
->mc_source
);
436 vl_vb_cleanup(&buffer
->vertex_stream
);
444 vl_mpeg12_decoder_flush_buffer(struct pipe_video_decode_buffer
*buffer
,
445 struct pipe_video_buffer
*refs
[2],
446 struct pipe_video_buffer
*dst
,
447 struct pipe_fence_handle
**fence
)
449 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
450 struct vl_mpeg12_decoder
*dec
;
452 struct pipe_sampler_view
**sv
[2];
453 struct pipe_surface
**surfaces
;
455 struct pipe_vertex_buffer vb
[3];
461 dec
= (struct vl_mpeg12_decoder
*)buf
->base
.decoder
;
464 for (i
= 0; i
< 2; ++i
)
465 sv
[i
] = refs
[i
] ? refs
[i
]->get_sampler_views(refs
[i
]) : NULL
;
467 surfaces
= dst
->get_surfaces(dst
);
472 dec
->pipe
->bind_vertex_elements_state(dec
->pipe
, dec
->ves_mv
);
473 for (i
= 0; i
< VL_MAX_PLANES
; ++i
) {
474 vl_mc_set_surface(&buf
->mc
[i
], surfaces
[i
]);
476 for (j
= 0; j
< 2; ++j
) {
477 if (sv
[j
] == NULL
) continue;
479 vb
[2] = vl_vb_get_mv(&buf
->vertex_stream
, j
);;
480 dec
->pipe
->set_vertex_buffers(dec
->pipe
, 3, vb
);
482 vl_mc_render_ref(&buf
->mc
[i
], sv
[j
][i
]);
486 dec
->pipe
->bind_vertex_elements_state(dec
->pipe
, dec
->ves_ycbcr
);
487 for (i
= 0; i
< VL_MAX_PLANES
; ++i
) {
488 unsigned num_instances
= vl_vb_restart(&buf
->vertex_stream
, i
);
490 vb
[1] = vl_vb_get_ycbcr(&buf
->vertex_stream
, i
);
491 dec
->pipe
->set_vertex_buffers(dec
->pipe
, 2, vb
);
493 if (dec
->base
.entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
)
494 vl_idct_flush(i
== 0 ? &dec
->idct_y
: &dec
->idct_c
, &buf
->idct
[i
], num_instances
);
496 vl_mc_render_ycbcr(&buf
->mc
[i
], num_instances
);
499 dec
->pipe
->flush(dec
->pipe
, fence
);
503 vl_mpeg12_decoder_clear_buffer(struct pipe_video_decode_buffer
*buffer
)
505 struct vl_mpeg12_buffer
*buf
= (struct vl_mpeg12_buffer
*)buffer
;
510 for (i
= 0; i
< VL_MAX_PLANES
; ++i
)
511 vl_vb_restart(&buf
->vertex_stream
, i
);
515 init_pipe_state(struct vl_mpeg12_decoder
*dec
)
517 struct pipe_depth_stencil_alpha_state dsa
;
522 memset(&dsa
, 0, sizeof dsa
);
523 dsa
.depth
.enabled
= 0;
524 dsa
.depth
.writemask
= 0;
525 dsa
.depth
.func
= PIPE_FUNC_ALWAYS
;
526 for (i
= 0; i
< 2; ++i
) {
527 dsa
.stencil
[i
].enabled
= 0;
528 dsa
.stencil
[i
].func
= PIPE_FUNC_ALWAYS
;
529 dsa
.stencil
[i
].fail_op
= PIPE_STENCIL_OP_KEEP
;
530 dsa
.stencil
[i
].zpass_op
= PIPE_STENCIL_OP_KEEP
;
531 dsa
.stencil
[i
].zfail_op
= PIPE_STENCIL_OP_KEEP
;
532 dsa
.stencil
[i
].valuemask
= 0;
533 dsa
.stencil
[i
].writemask
= 0;
535 dsa
.alpha
.enabled
= 0;
536 dsa
.alpha
.func
= PIPE_FUNC_ALWAYS
;
537 dsa
.alpha
.ref_value
= 0;
538 dec
->dsa
= dec
->pipe
->create_depth_stencil_alpha_state(dec
->pipe
, &dsa
);
539 dec
->pipe
->bind_depth_stencil_alpha_state(dec
->pipe
, dec
->dsa
);
544 static enum pipe_format
545 find_first_supported_format(struct vl_mpeg12_decoder
*dec
,
546 const enum pipe_format formats
[],
547 unsigned num_formats
,
548 enum pipe_texture_target target
)
550 struct pipe_screen
*screen
;
555 screen
= dec
->pipe
->screen
;
557 for (i
= 0; i
< num_formats
; ++i
)
558 if (screen
->is_format_supported(dec
->pipe
->screen
, formats
[i
], target
, 1,
559 PIPE_BIND_SAMPLER_VIEW
| PIPE_BIND_RENDER_TARGET
))
562 return PIPE_FORMAT_NONE
;
566 init_idct(struct vl_mpeg12_decoder
*dec
, unsigned buffer_width
, unsigned buffer_height
)
568 unsigned chroma_width
, chroma_height
, chroma_blocks_x
, chroma_blocks_y
;
569 struct pipe_sampler_view
*matrix
, *transpose
;
570 float matrix_scale
, transpose_scale
;
572 dec
->nr_of_idct_render_targets
= dec
->pipe
->screen
->get_param(dec
->pipe
->screen
, PIPE_CAP_MAX_RENDER_TARGETS
);
574 // more than 4 render targets usually doesn't makes any seens
575 dec
->nr_of_idct_render_targets
= MIN2(dec
->nr_of_idct_render_targets
, 4);
577 dec
->idct_source_format
= find_first_supported_format(dec
, const_idct_source_formats
,
578 num_idct_source_formats
, PIPE_TEXTURE_2D
);
580 if (dec
->idct_source_format
== PIPE_FORMAT_NONE
)
583 dec
->idct_intermediate_format
= find_first_supported_format(dec
, const_idct_intermediate_formats
,
584 num_idct_intermediate_formats
, PIPE_TEXTURE_3D
);
586 if (dec
->idct_intermediate_format
== PIPE_FORMAT_NONE
)
589 switch (dec
->idct_source_format
) {
590 case PIPE_FORMAT_R16G16B16A16_SSCALED
:
591 matrix_scale
= SCALE_FACTOR_SSCALED
;
594 case PIPE_FORMAT_R16G16B16A16_SNORM
:
595 matrix_scale
= SCALE_FACTOR_SNORM
;
603 if (dec
->idct_intermediate_format
== PIPE_FORMAT_R16G16B16A16_FLOAT
||
604 dec
->idct_intermediate_format
== PIPE_FORMAT_R32G32B32A32_FLOAT
)
605 transpose_scale
= 1.0f
;
607 transpose_scale
= matrix_scale
= sqrt(matrix_scale
);
609 if (dec
->mc_source_format
== PIPE_FORMAT_R16_SSCALED
)
610 transpose_scale
/= SCALE_FACTOR_SSCALED
;
612 if (!(matrix
= vl_idct_upload_matrix(dec
->pipe
, matrix_scale
)))
615 if (matrix_scale
!= transpose_scale
) {
616 if (!(transpose
= vl_idct_upload_matrix(dec
->pipe
, transpose_scale
)))
617 goto error_transpose
;
619 pipe_sampler_view_reference(&transpose
, matrix
);
621 if (!vl_idct_init(&dec
->idct_y
, dec
->pipe
, buffer_width
, buffer_height
,
622 2, 2, dec
->nr_of_idct_render_targets
, matrix
, transpose
))
625 if (dec
->base
.chroma_format
== PIPE_VIDEO_CHROMA_FORMAT_420
) {
626 chroma_width
= buffer_width
/ 2;
627 chroma_height
= buffer_height
/ 2;
630 } else if (dec
->base
.chroma_format
== PIPE_VIDEO_CHROMA_FORMAT_422
) {
631 chroma_width
= buffer_width
;
632 chroma_height
= buffer_height
/ 2;
636 chroma_width
= buffer_width
;
637 chroma_height
= buffer_height
;
642 if(!vl_idct_init(&dec
->idct_c
, dec
->pipe
, chroma_width
, chroma_height
,
643 chroma_blocks_x
, chroma_blocks_y
,
644 dec
->nr_of_idct_render_targets
, matrix
, transpose
))
647 pipe_sampler_view_reference(&matrix
, NULL
);
648 pipe_sampler_view_reference(&transpose
, NULL
);
652 vl_idct_cleanup(&dec
->idct_y
);
655 pipe_sampler_view_reference(&transpose
, NULL
);
658 pipe_sampler_view_reference(&matrix
, NULL
);
664 struct pipe_video_decoder
*
665 vl_create_mpeg12_decoder(struct pipe_video_context
*context
,
666 struct pipe_context
*pipe
,
667 enum pipe_video_profile profile
,
668 enum pipe_video_entrypoint entrypoint
,
669 enum pipe_video_chroma_format chroma_format
,
670 unsigned width
, unsigned height
)
672 struct vl_mpeg12_decoder
*dec
;
675 assert(u_reduce_video_profile(profile
) == PIPE_VIDEO_CODEC_MPEG12
);
677 dec
= CALLOC_STRUCT(vl_mpeg12_decoder
);
682 dec
->base
.context
= context
;
683 dec
->base
.profile
= profile
;
684 dec
->base
.entrypoint
= entrypoint
;
685 dec
->base
.chroma_format
= chroma_format
;
686 dec
->base
.width
= width
;
687 dec
->base
.height
= height
;
689 dec
->base
.destroy
= vl_mpeg12_destroy
;
690 dec
->base
.create_buffer
= vl_mpeg12_create_buffer
;
691 dec
->base
.flush_buffer
= vl_mpeg12_decoder_flush_buffer
;
692 dec
->base
.clear_buffer
= vl_mpeg12_decoder_clear_buffer
;
694 dec
->base
.width
= align(width
, MACROBLOCK_WIDTH
);
695 dec
->base
.height
= align(height
, MACROBLOCK_HEIGHT
);
699 dec
->quads
= vl_vb_upload_quads(dec
->pipe
, 2, 2);
700 dec
->pos
= vl_vb_upload_pos(
702 dec
->base
.width
/ MACROBLOCK_WIDTH
,
703 dec
->base
.height
/ MACROBLOCK_HEIGHT
706 dec
->ves_ycbcr
= vl_vb_get_ves_ycbcr(dec
->pipe
);
707 dec
->ves_mv
= vl_vb_get_ves_mv(dec
->pipe
);
709 /* TODO: Implement 422, 444 */
710 assert(dec
->base
.chroma_format
== PIPE_VIDEO_CHROMA_FORMAT_420
);
711 dec
->empty_block_mask
= &const_empty_block_mask_420
;
713 dec
->mc_source_format
= find_first_supported_format(dec
, const_mc_source_formats
,
714 num_mc_source_formats
, PIPE_TEXTURE_3D
);
716 if (dec
->mc_source_format
== PIPE_FORMAT_NONE
)
719 if (entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
) {
720 if (!init_idct(dec
, dec
->base
.width
, dec
->base
.height
))
722 if (dec
->mc_source_format
== PIPE_FORMAT_R16_SSCALED
)
723 mc_scale
= SCALE_FACTOR_SSCALED
;
727 switch (dec
->mc_source_format
) {
728 case PIPE_FORMAT_R16_SNORM
:
729 mc_scale
= SCALE_FACTOR_SNORM
;
732 case PIPE_FORMAT_R16_SSCALED
:
733 mc_scale
= SCALE_FACTOR_SSCALED
;
742 if (!vl_mc_init(&dec
->mc_y
, dec
->pipe
, dec
->base
.width
, dec
->base
.height
, MACROBLOCK_HEIGHT
, mc_scale
))
746 if (!vl_mc_init(&dec
->mc_c
, dec
->pipe
, dec
->base
.width
, dec
->base
.height
, BLOCK_HEIGHT
, mc_scale
))
749 if (!init_pipe_state(dec
))
750 goto error_pipe_state
;
755 vl_mc_cleanup(&dec
->mc_c
);
758 vl_mc_cleanup(&dec
->mc_y
);
761 if (entrypoint
<= PIPE_VIDEO_ENTRYPOINT_IDCT
) {
762 vl_idct_cleanup(&dec
->idct_y
);
763 vl_idct_cleanup(&dec
->idct_c
);