struct pipe_video_decoder *
vl_create_decoder(struct pipe_context *pipe,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode)
+ const struct pipe_video_decoder *templat)
{
- unsigned buffer_width, buffer_height;
+ unsigned width = templat->width, height = templat->height;
+ struct pipe_video_decoder temp;
bool pot_buffers;
assert(pipe);
pot_buffers = !pipe->screen->get_video_param
(
pipe->screen,
- profile,
+ templat->profile,
PIPE_VIDEO_CAP_NPOT_TEXTURES
);
- buffer_width = pot_buffers ? util_next_power_of_two(width) : align(width, VL_MACROBLOCK_WIDTH);
- buffer_height = pot_buffers ? util_next_power_of_two(height) : align(height, VL_MACROBLOCK_HEIGHT);
+ temp = *templat;
+ temp.width = pot_buffers ? util_next_power_of_two(width) : align(width, VL_MACROBLOCK_WIDTH);
+ temp.height = pot_buffers ? util_next_power_of_two(height) : align(height, VL_MACROBLOCK_HEIGHT);
- switch (u_reduce_video_profile(profile)) {
+ switch (u_reduce_video_profile(temp.profile)) {
case PIPE_VIDEO_CODEC_MPEG12:
- return vl_create_mpeg12_decoder(pipe, profile, entrypoint, chroma_format,
- buffer_width, buffer_height, max_references,
- expect_chunked_decode);
+ return vl_create_mpeg12_decoder(pipe, &temp);
+
default:
return NULL;
}
*/
struct pipe_video_decoder *
vl_create_decoder(struct pipe_context *pipe,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templat);
#endif /* vl_decoder_h */
if (dec->base.entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM)
vl_mpg12_bs_init(&buffer->bs, &dec->base);
- if (dec->expect_chunked_decode)
+ if (dec->base.expect_chunked_decode)
vl_video_buffer_set_associated_data(target, &dec->base,
buffer, vl_mpeg12_destroy_buffer);
else
struct pipe_video_decoder *
vl_create_mpeg12_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode)
+ const struct pipe_video_decoder *templat)
{
const unsigned block_size_pixels = VL_BLOCK_WIDTH * VL_BLOCK_HEIGHT;
const struct format_config *format_config;
struct vl_mpeg12_decoder *dec;
- assert(u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12);
+ assert(u_reduce_video_profile(templat->profile) == PIPE_VIDEO_CODEC_MPEG12);
dec = CALLOC_STRUCT(vl_mpeg12_decoder);
if (!dec)
return NULL;
+ dec->base = *templat;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
- dec->base.width = width;
- dec->base.height = height;
- dec->base.max_references = max_references;
dec->base.destroy = vl_mpeg12_destroy;
dec->base.begin_frame = vl_mpeg12_begin_frame;
dec->blocks_per_line = MAX2(util_next_power_of_two(dec->base.width) / block_size_pixels, 4);
dec->num_blocks = (dec->base.width * dec->base.height) / block_size_pixels;
dec->width_in_macroblocks = align(dec->base.width, VL_MACROBLOCK_WIDTH) / VL_MACROBLOCK_WIDTH;
- dec->expect_chunked_decode = expect_chunked_decode;
/* TODO: Implement 422, 444 */
assert(dec->base.chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
dec->ves_ycbcr = vl_vb_get_ves_ycbcr(dec->base.context);
dec->ves_mv = vl_vb_get_ves_mv(dec->base.context);
- switch (entrypoint) {
+ switch (templat->entrypoint) {
case PIPE_VIDEO_ENTRYPOINT_BITSTREAM:
format_config = find_format_config(dec, bitstream_format_config, num_bitstream_format_configs);
break;
if (!init_zscan(dec, format_config))
goto error_zscan;
- if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
+ if (templat->entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
if (!init_idct(dec, format_config))
goto error_sources;
} else {
vl_mc_cleanup(&dec->mc_y);
error_mc_y:
- if (entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
+ if (templat->entrypoint <= PIPE_VIDEO_ENTRYPOINT_IDCT) {
vl_idct_cleanup(&dec->idct_y);
vl_idct_cleanup(&dec->idct_c);
dec->idct_source->destroy(dec->idct_source);
unsigned blocks_per_line;
unsigned num_blocks;
unsigned width_in_macroblocks;
- bool expect_chunked_decode;
enum pipe_format zscan_source_format;
*/
struct pipe_video_decoder *
vl_create_mpeg12_decoder(struct pipe_context *pipe,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templat);
#endif /* vl_mpeg12_decoder_h */
static struct pipe_video_decoder *
ilo_create_video_decoder(struct pipe_context *pipe,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode)
+ const struct pipe_video_decoder *templ)
{
- return vl_create_decoder(pipe, profile, entrypoint, chroma_format,
- width, height, max_references, expect_chunked_decode);
+ return vl_create_decoder(pipe, templ);
}
static struct pipe_video_buffer *
static struct pipe_video_decoder *
nouveau_create_decoder(struct pipe_context *context,
- struct nouveau_screen *screen,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode)
+ const struct pipe_video_decoder *templ,
+ struct nouveau_screen *screen)
{
struct nv04_fifo nv04_data = { .vram = 0xbeef0201, .gart = 0xbeef0202 };
+ unsigned width = templ->width, height = templ->height;
struct nouveau_object *mpeg = NULL;
struct nouveau_decoder *dec;
struct nouveau_pushbuf *push;
int ret;
bool is8274 = screen->device->chipset > 0x80;
- debug_printf("Acceleration level: %s\n", entrypoint <= PIPE_VIDEO_ENTRYPOINT_BITSTREAM ? "bit":
- entrypoint == PIPE_VIDEO_ENTRYPOINT_IDCT ? "IDCT" : "MC");
+ debug_printf("Acceleration level: %s\n", templ->entrypoint <= PIPE_VIDEO_ENTRYPOINT_BITSTREAM ? "bit":
+ templ->entrypoint == PIPE_VIDEO_ENTRYPOINT_IDCT ? "IDCT" : "MC");
if (getenv("XVMC_VL"))
goto vl;
- if (u_reduce_video_profile(profile) != PIPE_VIDEO_CODEC_MPEG12)
+ if (u_reduce_video_profile(templ->profile) != PIPE_VIDEO_CODEC_MPEG12)
goto vl;
if (screen->device->chipset >= 0x98 && screen->device->chipset != 0xa0)
goto vl;
}
dec->mpeg = mpeg;
+ dec->base = *templ;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
dec->base.width = width;
dec->base.height = height;
- dec->base.max_references = max_references;
dec->base.destroy = nouveau_decoder_destroy;
dec->base.begin_frame = nouveau_decoder_begin_frame;
dec->base.decode_macroblock = nouveau_decoder_decode_macroblock;
BEGIN_NV04(push, NV31_MPEG(FORMAT), 2);
PUSH_DATA (push, 0);
- switch (entrypoint) {
+ switch (templ->entrypoint) {
case PIPE_VIDEO_ENTRYPOINT_BITSTREAM: PUSH_DATA (push, 0x100); break;
case PIPE_VIDEO_ENTRYPOINT_IDCT: PUSH_DATA (push, 1); break;
case PIPE_VIDEO_ENTRYPOINT_MC: PUSH_DATA (push, 0); break;
vl:
debug_printf("Using g3dvl renderer\n");
- return vl_create_decoder(context, profile, entrypoint,
- chroma_format, width, height,
- max_references, expect_chunked_decode);
+ return vl_create_decoder(context, templ);
}
static struct pipe_sampler_view **
static struct pipe_video_decoder *
nouveau_context_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode)
+ const struct pipe_video_decoder *templ)
{
struct nouveau_screen *screen = nouveau_context(context)->screen;
- return nouveau_create_decoder(context, screen, profile, entrypoint,
- chroma_format, width, height,
- max_references, expect_chunked_decode);
+ return nouveau_create_decoder(context, templ, screen);
}
static struct pipe_video_buffer *
/* nv84_video.c */
struct pipe_video_decoder *
nv84_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templ);
struct pipe_video_buffer *
nv84_video_buffer_create(struct pipe_context *pipe,
/* nv98_video.c */
struct pipe_video_decoder *
nv98_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templ);
struct pipe_video_buffer *
nv98_video_buffer_create(struct pipe_context *pipe,
struct pipe_video_decoder *
nv84_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references,
- bool chunked_decode)
+ const struct pipe_video_decoder *templ)
{
struct nv50_context *nv50 = (struct nv50_context *)context;
struct nouveau_screen *screen = &nv50->screen->base;
union pipe_color_union color;
struct nv04_fifo nv04_data = { .vram = 0xbeef0201, .gart = 0xbeef0202 };
int ret, i;
- int is_h264 = u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG4_AVC;
- int is_mpeg12 = u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12;
+ int is_h264 = u_reduce_video_profile(templ->profile) == PIPE_VIDEO_CODEC_MPEG4_AVC;
+ int is_mpeg12 = u_reduce_video_profile(templ->profile) == PIPE_VIDEO_CODEC_MPEG12;
if (getenv("XVMC_VL"))
- return vl_create_decoder(context, profile, entrypoint,
- chroma_format, width, height,
- max_references, chunked_decode);
+ return vl_create_decoder(context, templ);
- if ((is_h264 && entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) ||
- (is_mpeg12 && entrypoint > PIPE_VIDEO_ENTRYPOINT_IDCT)) {
- debug_printf("%x\n", entrypoint);
+ if ((is_h264 && templ->entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) ||
+ (is_mpeg12 && templ->entrypoint > PIPE_VIDEO_ENTRYPOINT_IDCT)) {
+ debug_printf("%x\n", templ->entrypoint);
return NULL;
}
if (!is_h264 && !is_mpeg12) {
- debug_printf("invalid profile: %x\n", profile);
+ debug_printf("invalid profile: %x\n", templ->profile);
return NULL;
}
if (!dec)
return NULL;
+ dec->base = *templ;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
- dec->base.width = width;
- dec->base.height = height;
- dec->base.max_references = max_references;
dec->base.destroy = nv84_decoder_destroy;
dec->base.flush = nv84_decoder_flush;
if (is_h264) {
dec->base.begin_frame = nv84_decoder_begin_frame_mpeg12;
dec->base.end_frame = nv84_decoder_end_frame_mpeg12;
- if (entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
+ if (templ->entrypoint == PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
dec->mpeg12_bs = CALLOC_STRUCT(vl_mpg12_bs);
if (!dec->mpeg12_bs)
goto fail;
goto fail;
ret = nouveau_bo_new(screen->device, NOUVEAU_BO_VRAM | NOUVEAU_BO_NOSNOOP,
0,
- (max_references + 1) * dec->frame_mbs * 0x40 +
+ (templ->max_references + 1) * dec->frame_mbs * 0x40 +
dec->frame_size + 0x2000,
NULL, &dec->mbring);
if (ret)
if (is_mpeg12) {
ret = nouveau_bo_new(screen->device, NOUVEAU_BO_GART,
0,
- align(0x20 * mb(width) * mb(height), 0x100) +
- (6 * 64 * 8) * mb(width) * mb(height) + 0x100,
+ align(0x20 * mb(templ->width) * mb(templ->height), 0x100) +
+ (6 * 64 * 8) * mb(templ->width) * mb(templ->height) + 0x100,
NULL, &dec->mpeg12_bo);
if (ret)
goto fail;
color.f[0] = color.f[1] = color.f[2] = color.f[3] = 0;
surf.offset = dec->frame_size;
surf.width = 64;
- surf.height = (max_references + 1) * dec->frame_mbs / 4;
+ surf.height = (templ->max_references + 1) * dec->frame_mbs / 4;
surf.depth = 1;
surf.base.format = PIPE_FORMAT_B8G8R8A8_UNORM;
surf.base.u.tex.level = 0;
struct pipe_video_decoder *
nv98_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool chunked_decode)
+ const struct pipe_video_decoder *templ)
{
struct nouveau_screen *screen = &((struct nv50_context *)context)->screen->base;
struct nouveau_vp3_decoder *dec;
u32 tmp_size = 0;
if (getenv("XVMC_VL"))
- return vl_create_decoder(context, profile, entrypoint,
- chroma_format, width, height,
- max_references, chunked_decode);
+ return vl_create_decoder(context, templ);
- if (entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
- debug_printf("%x\n", entrypoint);
+ if (templ->entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
+ debug_printf("%x\n", templ->entrypoint);
return NULL;
}
for (i = 0; i < 5; i++)
PUSH_DATA (push[2], nv04_data.vram);
+ dec->base = *templ;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
- dec->base.width = width;
- dec->base.height = height;
- dec->base.max_references = max_references;
dec->base.decode_bitstream = nv98_decoder_decode_bitstream;
for (i = 0; i < NOUVEAU_VP3_VIDEO_QDEPTH && !ret; ++i)
if (ret)
goto fail;
- switch (u_reduce_video_profile(profile)) {
+ switch (u_reduce_video_profile(templ->profile)) {
case PIPE_VIDEO_CODEC_MPEG12: {
codec = 1;
- assert(max_references <= 2);
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_MPEG4: {
codec = 4;
- tmp_size = mb(height)*16 * mb(width)*16;
- assert(max_references <= 2);
+ tmp_size = mb(templ->height)*16 * mb(templ->width)*16;
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_VC1: {
ppp_codec = codec = 2;
- tmp_size = mb(height)*16 * mb(width)*16;
- assert(max_references <= 2);
+ tmp_size = mb(templ->height)*16 * mb(templ->width)*16;
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_MPEG4_AVC: {
codec = 3;
- dec->tmp_stride = 16 * mb_half(width) * nouveau_vp3_video_align(height) * 3 / 2;
- tmp_size = dec->tmp_stride * (max_references + 1);
- assert(max_references <= 16);
+ dec->tmp_stride = 16 * mb_half(templ->width) * nouveau_vp3_video_align(templ->height) * 3 / 2;
+ tmp_size = dec->tmp_stride * (templ->max_references + 1);
+ assert(templ->max_references <= 16);
break;
}
default:
if (ret)
goto fail;
- ret = nouveau_vp3_load_firmware(dec, profile, screen->device->chipset);
+ ret = nouveau_vp3_load_firmware(dec, templ->profile, screen->device->chipset);
if (ret)
goto fw_fail;
goto fail;
}
- dec->ref_stride = mb(width)*16 * (mb_half(height)*32 + nouveau_vp3_video_align(height)/2);
+ dec->ref_stride = mb(templ->width)*16 * (mb_half(templ->height)*32 + nouveau_vp3_video_align(templ->height)/2);
ret = nouveau_bo_new(screen->device, NOUVEAU_BO_VRAM, 0,
- dec->ref_stride * (max_references+2) + tmp_size,
+ dec->ref_stride * (templ->max_references+2) + tmp_size,
&cfg, &dec->ref_bo);
if (ret)
goto fail;
/* nvc0_video.c */
struct pipe_video_decoder *
nvc0_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templ);
struct pipe_video_buffer *
nvc0_video_buffer_create(struct pipe_context *pipe,
struct pipe_video_decoder *
nvc0_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool chunked_decode)
+ const struct pipe_video_decoder *templ)
{
struct nouveau_screen *screen = &((struct nvc0_context *)context)->screen->base;
struct nouveau_vp3_decoder *dec;
u32 tmp_size = 0;
if (getenv("XVMC_VL"))
- return vl_create_decoder(context, profile, entrypoint,
- chroma_format, width, height,
- max_references, chunked_decode);
+ return vl_create_decoder(context, templ);
- if (entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
- debug_printf("%x\n", entrypoint);
+ if (templ->entrypoint != PIPE_VIDEO_ENTRYPOINT_BITSTREAM) {
+ debug_printf("%x\n", templ->entrypoint);
return NULL;
}
BEGIN_NVC0(push[2], SUBC_PPP(NV01_SUBCHAN_OBJECT), 1);
PUSH_DATA (push[2], dec->ppp->handle);
+ dec->base = *templ;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
- dec->base.width = width;
- dec->base.height = height;
- dec->base.max_references = max_references;
dec->base.decode_bitstream = nvc0_decoder_decode_bitstream;
for (i = 0; i < NOUVEAU_VP3_VIDEO_QDEPTH && !ret; ++i)
if (ret)
goto fail;
- switch (u_reduce_video_profile(profile)) {
+ switch (u_reduce_video_profile(templ->profile)) {
case PIPE_VIDEO_CODEC_MPEG12: {
codec = 1;
- assert(max_references <= 2);
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_MPEG4: {
codec = 4;
- tmp_size = mb(height)*16 * mb(width)*16;
- assert(max_references <= 2);
+ tmp_size = mb(templ->height)*16 * mb(templ->width)*16;
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_VC1: {
ppp_codec = codec = 2;
- tmp_size = mb(height)*16 * mb(width)*16;
- assert(max_references <= 2);
+ tmp_size = mb(templ->height)*16 * mb(templ->width)*16;
+ assert(templ->max_references <= 2);
break;
}
case PIPE_VIDEO_CODEC_MPEG4_AVC: {
codec = 3;
- dec->tmp_stride = 16 * mb_half(width) * nouveau_vp3_video_align(height) * 3 / 2;
- tmp_size = dec->tmp_stride * (max_references + 1);
- assert(max_references <= 16);
+ dec->tmp_stride = 16 * mb_half(templ->width) * nouveau_vp3_video_align(templ->height) * 3 / 2;
+ tmp_size = dec->tmp_stride * (templ->max_references + 1);
+ assert(templ->max_references <= 16);
break;
}
default:
if (ret)
goto fail;
- ret = nouveau_vp3_load_firmware(dec, profile, screen->device->chipset);
+ ret = nouveau_vp3_load_firmware(dec, templ->profile, screen->device->chipset);
if (ret)
goto fw_fail;
}
goto fail;
}
- dec->ref_stride = mb(width)*16 * (mb_half(height)*32 + nouveau_vp3_video_align(height)/2);
+ dec->ref_stride = mb(templ->width)*16 * (mb_half(templ->height)*32 + nouveau_vp3_video_align(templ->height)/2);
ret = nouveau_bo_new(screen->device, NOUVEAU_BO_VRAM, 0,
- dec->ref_stride * (max_references+2) + tmp_size,
+ dec->ref_stride * (templ->max_references+2) + tmp_size,
&cfg, &dec->ref_bo);
if (ret)
goto fail;
/* r600_uvd.c */
struct pipe_video_decoder *r600_uvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode);
+ const struct pipe_video_decoder *decoder);
struct pipe_video_buffer *r600_video_buffer_create(struct pipe_context *pipe,
const struct pipe_video_buffer *tmpl);
/* create decoder */
struct pipe_video_decoder *r600_uvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode)
+ const struct pipe_video_decoder *templat)
{
struct r600_context *ctx = (struct r600_context *)context;
- return ruvd_create_decoder(context, profile, entrypoint, chroma_format,
- width, height, max_references, expect_chunked_decode,
- ctx->ws, r600_uvd_set_dtb);
+ return ruvd_create_decoder(context, templat, ctx->ws, r600_uvd_set_dtb);
}
int r600_uvd_get_video_param(struct pipe_screen *screen,
}
/* calculate size of reference picture buffer */
-static unsigned calc_dpb_size(enum pipe_video_profile profile,
- unsigned width, unsigned height,
- unsigned max_references)
+static unsigned calc_dpb_size(const struct pipe_video_decoder *templ)
{
unsigned width_in_mb, height_in_mb, image_size, dpb_size;
// always align them to MB size for dpb calculation
- width = align(width, VL_MACROBLOCK_WIDTH);
- height = align(height, VL_MACROBLOCK_HEIGHT);
+ unsigned width = align(templ->width, VL_MACROBLOCK_WIDTH);
+ unsigned height = align(templ->height, VL_MACROBLOCK_HEIGHT);
// always one more for currently decoded picture
- max_references += 1;
+ unsigned max_references = templ->max_references + 1;
// aligned size of a single frame
image_size = width * height;
width_in_mb = width / VL_MACROBLOCK_WIDTH;
height_in_mb = align(height / VL_MACROBLOCK_HEIGHT, 2);
- switch (u_reduce_video_profile(profile)) {
+ switch (u_reduce_video_profile(templ->profile)) {
case PIPE_VIDEO_CODEC_MPEG4_AVC:
// the firmware seems to allways assume a minimum of ref frames
max_references = MAX2(NUM_H264_REFS, max_references);
* create and UVD decoder
*/
struct pipe_video_decoder *ruvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode,
+ const struct pipe_video_decoder *templ,
struct radeon_winsys* ws,
ruvd_set_dtb set_dtb)
{
- unsigned dpb_size = calc_dpb_size(profile, width, height, max_references);
+ unsigned dpb_size = calc_dpb_size(templ);
+ unsigned width = templ->width, height = templ->height;
struct radeon_info info;
struct ruvd_decoder *dec;
struct ruvd_msg msg;
ws->query_info(ws, &info);
- switch(u_reduce_video_profile(profile)) {
+ switch(u_reduce_video_profile(templ->profile)) {
case PIPE_VIDEO_CODEC_MPEG12:
- if (entrypoint > PIPE_VIDEO_ENTRYPOINT_BITSTREAM || info.family < CHIP_PALM)
- return vl_create_mpeg12_decoder(context, profile, entrypoint,
- chroma_format, width,
- height, max_references, expect_chunked_decode);
+ if (templ->entrypoint > PIPE_VIDEO_ENTRYPOINT_BITSTREAM || info.family < CHIP_PALM)
+ return vl_create_mpeg12_decoder(context, templ);
/* fall through */
case PIPE_VIDEO_CODEC_MPEG4:
if (!dec)
return NULL;
+ dec->base = *templ;
dec->base.context = context;
- dec->base.profile = profile;
- dec->base.entrypoint = entrypoint;
- dec->base.chroma_format = chroma_format;
- dec->base.width = width;
- dec->base.height = height;
dec->base.destroy = ruvd_destroy;
dec->base.begin_frame = ruvd_begin_frame;
/* create an UVD decode */
struct pipe_video_decoder *ruvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode,
+ const struct pipe_video_decoder *templat,
struct radeon_winsys* ws,
ruvd_set_dtb set_dtb);
/* radeonsi_uvd.c */
struct pipe_video_decoder *radeonsi_uvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode);
+ const struct pipe_video_decoder *templ);
struct pipe_video_buffer *radeonsi_video_buffer_create(struct pipe_context *pipe,
const struct pipe_video_buffer *tmpl);
* creates an UVD compatible decoder
*/
struct pipe_video_decoder *radeonsi_uvd_create_decoder(struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height,
- unsigned max_references, bool expect_chunked_decode)
+ const struct pipe_video_decoder *templ)
{
struct r600_context *ctx = (struct r600_context *)context;
- return ruvd_create_decoder(context, profile, entrypoint, chroma_format,
- width, height, max_references, expect_chunked_decode,
- ctx->ws, radeonsi_uvd_set_dtb);
+ return ruvd_create_decoder(context, templ, ctx->ws, radeonsi_uvd_set_dtb);
}
* Creates a video decoder for a specific video codec/profile
*/
struct pipe_video_decoder *(*create_video_decoder)( struct pipe_context *context,
- enum pipe_video_profile profile,
- enum pipe_video_entrypoint entrypoint,
- enum pipe_video_chroma_format chroma_format,
- unsigned width, unsigned height, unsigned max_references,
- bool expect_chunked_decode);
+ const struct pipe_video_decoder *templat );
/**
* Creates a video buffer as decoding target
unsigned width;
unsigned height;
unsigned max_references;
+ bool expect_chunked_decode;
/**
* destroy this video decoder
uint32_t max_references,
VdpDecoder *decoder)
{
- enum pipe_video_profile p_profile;
+ struct pipe_video_decoder templat = {};
struct pipe_context *pipe;
struct pipe_screen *screen;
vlVdpDevice *dev;
if (!(width && height))
return VDP_STATUS_INVALID_VALUE;
- p_profile = ProfileToPipe(profile);
- if (p_profile == PIPE_VIDEO_PROFILE_UNKNOWN)
+ templat.profile = ProfileToPipe(profile);
+ if (templat.profile == PIPE_VIDEO_PROFILE_UNKNOWN)
return VDP_STATUS_INVALID_DECODER_PROFILE;
dev = vlGetDataHTAB(device);
supported = screen->get_video_param
(
screen,
- p_profile,
+ templat.profile,
PIPE_VIDEO_CAP_SUPPORTED
);
if (!supported) {
vldecoder->device = dev;
- vldecoder->decoder = pipe->create_video_decoder
- (
- pipe, p_profile,
- PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
- PIPE_VIDEO_CHROMA_FORMAT_420,
- width, height, max_references,
- false
- );
+ templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_BITSTREAM;
+ templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
+ templat.width = width;
+ templat.height = height;
+ templat.max_references = max_references;
+
+ vldecoder->decoder = pipe->create_video_decoder(pipe, &templat);
if (!vldecoder->decoder) {
ret = VDP_STATUS_ERROR;
Status ret;
struct vl_screen *vscreen;
struct pipe_context *pipe;
+ struct pipe_video_decoder templat = {};
XvMCContextPrivate *context_priv;
vl_csc_matrix csc;
return BadAlloc;
}
- context_priv->decoder = pipe->create_video_decoder
- (
- pipe, ProfileToPipe(mc_type),
- (mc_type & XVMC_IDCT) ? PIPE_VIDEO_ENTRYPOINT_IDCT : PIPE_VIDEO_ENTRYPOINT_MC,
- FormatToPipe(chroma_format),
- width, height, 2,
- true
- );
+ templat.profile = ProfileToPipe(mc_type);
+ templat.entrypoint = (mc_type & XVMC_IDCT) ? PIPE_VIDEO_ENTRYPOINT_IDCT : PIPE_VIDEO_ENTRYPOINT_MC;
+ templat.chroma_format = FormatToPipe(chroma_format);
+ templat.width = width;
+ templat.height = height;
+ templat.max_references = 2;
+ templat.expect_chunked_decode = true;
+
+ context_priv->decoder = pipe->create_video_decoder(pipe, &templat);
if (!context_priv->decoder) {
XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL decoder.\n");
projects / mesa.git / commitdiff