*/
#include "sysdeps.h"
+#include <unistd.h>
#ifdef HAVE_VA_X11
# include "i965_output_dri.h"
#define HAS_TILED_SURFACE(ctx) ((ctx)->codec_info->has_tiled_surface)
+#define HAS_VP8_DECODING(ctx) ((ctx)->codec_info->has_vp8_decoding && \
+ (ctx)->intel.has_bsd)
+
+#define HAS_VP8_ENCODING(ctx) ((ctx)->codec_info->has_vp8_encoding && \
+ (ctx)->intel.has_bsd)
+
+#define HAS_H264_MVC_DECODING(ctx) \
+ (HAS_H264_DECODING(ctx) && (ctx)->codec_info->h264_mvc_dec_profiles)
+
+#define HAS_H264_MVC_DECODING_PROFILE(ctx, profile) \
+ (HAS_H264_MVC_DECODING(ctx) && \
+ ((ctx)->codec_info->h264_mvc_dec_profiles & (1U << profile)))
+
+#define HAS_H264_MVC_ENCODING(ctx) ((ctx)->codec_info->has_h264_mvc_encoding && \
+ (ctx)->intel.has_bsd)
+
static int get_sampling_from_fourcc(unsigned int fourcc);
/* Check whether we are rendering to X11 (VA/X11 or VA/GLX API) */
#define IS_VA_WAYLAND(ctx) \
(((ctx)->display_type & VA_DISPLAY_MAJOR_MASK) == VA_DISPLAY_WAYLAND)
+#define I965_BIT 1
+#define I965_2BITS (I965_BIT << 1)
+#define I965_4BITS (I965_BIT << 2)
+#define I965_8BITS (I965_BIT << 3)
+#define I965_16BITS (I965_BIT << 4)
+#define I965_32BITS (I965_BIT << 5)
+
+#define PLANE_0 0
+#define PLANE_1 1
+#define PLANE_2 2
+
+#define OFFSET_0 0
+#define OFFSET_4 4
+#define OFFSET_8 8
+#define OFFSET_16 16
+#define OFFSET_24 24
+
+/* hfactor, vfactor, num_planes, bpp[], num_components, components[] */
+#define I_NV12 2, 2, 2, {I965_8BITS, I965_4BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_1, OFFSET_8} }
+#define I_I420 2, 2, 3, {I965_8BITS, I965_2BITS, I965_2BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_2, OFFSET_0} }
+#define I_IYUV I_I420
+#define I_IMC3 I_I420
+#define I_YV12 2, 2, 3, {I965_8BITS, I965_2BITS, I965_2BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_2, OFFSET_0}, {PLANE_1, OFFSET_0} }
+#define I_IMC1 I_YV12
+
+#define I_422H 2, 1, 3, {I965_8BITS, I965_4BITS, I965_4BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_2, OFFSET_0} }
+#define I_422V 1, 2, 3, {I965_8BITS, I965_4BITS, I965_4BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_2, OFFSET_0} }
+#define I_YV16 2, 1, 3, {I965_8BITS, I965_4BITS, I965_4BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_2, OFFSET_0}, {PLANE_1, OFFSET_0} }
+#define I_YUY2 2, 1, 1, {I965_32BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_24} }
+#define I_UYVY 2, 1, 1, {I965_32BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_16} }
+
+#define I_444P 1, 1, 3, {I965_8BITS, I965_8BITS, I965_8BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_2, OFFSET_0} }
+
+#define I_411P 4, 1, 3, {I965_8BITS, I965_2BITS, I965_2BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_1, OFFSET_0}, {PLANE_2, OFFSET_0} }
+
+#define I_Y800 1, 1, 1, {I965_8BITS}, 1, { {PLANE_0, OFFSET_0} }
+
+#define I_RGBA 1, 1, 1, {I965_32BITS}, 4, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_16}, {PLANE_0, OFFSET_24} }
+#define I_RGBX 1, 1, 1, {I965_32BITS}, 3, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_16} }
+#define I_BGRA 1, 1, 1, {I965_32BITS}, 4, { {PLANE_0, OFFSET_16}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_24} }
+#define I_BGRX 1, 1, 1, {I965_32BITS}, 3, { {PLANE_0, OFFSET_16}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_0} }
+
+#define I_ARGB 1, 1, 1, {I965_32BITS}, 4, { {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_16}, {PLANE_0, OFFSET_24}, {PLANE_0, OFFSET_0} }
+#define I_ABGR 1, 1, 1, {I965_32BITS}, 4, { {PLANE_0, OFFSET_24}, {PLANE_0, OFFSET_16}, {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_0} }
+
+#define I_IA88 1, 1, 1, {I965_16BITS}, 2, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_8} }
+#define I_AI88 1, 1, 1, {I965_16BITS}, 2, { {PLANE_0, OFFSET_8}, {PLANE_0, OFFSET_0} }
+
+#define I_IA44 1, 1, 1, {I965_8BITS}, 2, { {PLANE_0, OFFSET_0}, {PLANE_0, OFFSET_4} }
+#define I_AI44 1, 1, 1, {I965_8BITS}, 2, { {PLANE_0, OFFSET_4}, {PLANE_0, OFFSET_0} }
+
+/* flag */
+#define I_S 1
+#define I_I 2
+#define I_SI (I_S | I_I)
+
+#define DEF_FOUCC_INFO(FOURCC, FORMAT, SUB, FLAG) { VA_FOURCC_##FOURCC, I965_COLOR_##FORMAT, SUBSAMPLE_##SUB, FLAG, I_##FOURCC }
+#define DEF_YUV(FOURCC, SUB, FLAG) DEF_FOUCC_INFO(FOURCC, YUV, SUB, FLAG)
+#define DEF_RGB(FOURCC, SUB, FLAG) DEF_FOUCC_INFO(FOURCC, RGB, SUB, FLAG)
+#define DEF_INDEX(FOURCC, SUB, FLAG) DEF_FOUCC_INFO(FOURCC, INDEX, SUB, FLAG)
+
+static const i965_fourcc_info i965_fourcc_infos[] = {
+ DEF_YUV(NV12, YUV420, I_SI),
+ DEF_YUV(I420, YUV420, I_SI),
+ DEF_YUV(IYUV, YUV420, I_S),
+ DEF_YUV(IMC3, YUV420, I_S),
+ DEF_YUV(YV12, YUV420, I_SI),
+ DEF_YUV(IMC1, YUV420, I_S),
+
+ DEF_YUV(422H, YUV422H, I_SI),
+ DEF_YUV(422V, YUV422V, I_S),
+ DEF_YUV(YV16, YUV422H, I_S),
+ DEF_YUV(YUY2, YUV422H, I_SI),
+ DEF_YUV(UYVY, YUV422H, I_SI),
+
+ DEF_YUV(444P, YUV444, I_S),
+
+ DEF_YUV(411P, YUV411, I_S),
+
+ DEF_YUV(Y800, YUV400, I_S),
+
+ DEF_RGB(RGBA, RGBX, I_SI),
+ DEF_RGB(RGBX, RGBX, I_SI),
+ DEF_RGB(BGRA, RGBX, I_SI),
+ DEF_RGB(BGRX, RGBX, I_SI),
+
+ DEF_RGB(ARGB, RGBX, I_I),
+ DEF_RGB(ABGR, RGBX, I_I),
+
+ DEF_INDEX(IA88, RGBX, I_I),
+ DEF_INDEX(AI88, RGBX, I_I),
+
+ DEF_INDEX(IA44, RGBX, I_I),
+ DEF_INDEX(AI44, RGBX, I_I)
+};
+
+const i965_fourcc_info *
+get_fourcc_info(unsigned int fourcc)
+{
+ unsigned int i;
+
+ for (i = 0; ARRAY_ELEMS(i965_fourcc_infos); i++) {
+ const i965_fourcc_info * const info = &i965_fourcc_infos[i];
+
+ if (info->fourcc == fourcc)
+ return info;
+ }
+
+ return NULL;
+}
+
enum {
I965_SURFACETYPE_RGBA = 1,
I965_SURFACETYPE_YUV,
/* List of supported display attributes */
static const VADisplayAttribute i965_display_attributes[] = {
{
+ VADisplayAttribBrightness,
+ -100, 100, DEFAULT_BRIGHTNESS,
+ VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE
+ },
+
+ {
+ VADisplayAttribContrast,
+ 0, 100, DEFAULT_CONTRAST,
+ VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE
+ },
+
+ {
+ VADisplayAttribHue,
+ -180, 180, DEFAULT_HUE,
+ VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE
+ },
+
+ {
+ VADisplayAttribSaturation,
+ 0, 100, DEFAULT_SATURATION,
+ VA_DISPLAY_ATTRIB_GETTABLE | VA_DISPLAY_ATTRIB_SETTABLE
+ },
+
+ {
VADisplayAttribRotation,
0, 3, VA_ROTATION_NONE,
VA_DISPLAY_ATTRIB_GETTABLE|VA_DISPLAY_ATTRIB_SETTABLE
static const i965_image_format_map_t
i965_image_formats_map[I965_MAX_IMAGE_FORMATS + 1] = {
{ I965_SURFACETYPE_YUV,
- { VA_FOURCC('Y','V','1','2'), VA_LSB_FIRST, 12, } },
+ { VA_FOURCC_YV12, VA_LSB_FIRST, 12, } },
+ { I965_SURFACETYPE_YUV,
+ { VA_FOURCC_I420, VA_LSB_FIRST, 12, } },
{ I965_SURFACETYPE_YUV,
- { VA_FOURCC('I','4','2','0'), VA_LSB_FIRST, 12, } },
+ { VA_FOURCC_NV12, VA_LSB_FIRST, 12, } },
{ I965_SURFACETYPE_YUV,
- { VA_FOURCC('N','V','1','2'), VA_LSB_FIRST, 12, } },
+ { VA_FOURCC_YUY2, VA_LSB_FIRST, 16, } },
{ I965_SURFACETYPE_YUV,
- { VA_FOURCC('Y','U','Y','2'), VA_LSB_FIRST, 16, } },
+ { VA_FOURCC_UYVY, VA_LSB_FIRST, 16, } },
{ I965_SURFACETYPE_YUV,
- { VA_FOURCC('U','Y','V','Y'), VA_LSB_FIRST, 16, } },
+ { VA_FOURCC_422H, VA_LSB_FIRST, 16, } },
{ I965_SURFACETYPE_RGBA,
- { VA_FOURCC('R','G','B','X'), VA_LSB_FIRST, 32, 24, 0x000000ff, 0x0000ff00, 0x00ff0000 } },
+ { VA_FOURCC_RGBX, VA_LSB_FIRST, 32, 24, 0x000000ff, 0x0000ff00, 0x00ff0000 } },
{ I965_SURFACETYPE_RGBA,
- { VA_FOURCC('B','G','R','X'), VA_LSB_FIRST, 32, 24, 0x00ff0000, 0x0000ff00, 0x000000ff } },
+ { VA_FOURCC_BGRX, VA_LSB_FIRST, 32, 24, 0x00ff0000, 0x0000ff00, 0x000000ff } },
};
/* List of supported subpicture formats */
static const i965_subpic_format_map_t
i965_subpic_formats_map[I965_MAX_SUBPIC_FORMATS + 1] = {
{ I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_P4A4_UNORM,
- { VA_FOURCC('I','A','4','4'), VA_MSB_FIRST, 8, },
+ { VA_FOURCC_IA44, VA_MSB_FIRST, 8, },
COMMON_SUBPICTURE_FLAGS },
{ I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_A4P4_UNORM,
- { VA_FOURCC('A','I','4','4'), VA_MSB_FIRST, 8, },
+ { VA_FOURCC_AI44, VA_MSB_FIRST, 8, },
COMMON_SUBPICTURE_FLAGS },
{ I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_P8A8_UNORM,
- { VA_FOURCC('I','A','8','8'), VA_MSB_FIRST, 16, },
+ { VA_FOURCC_IA88, VA_MSB_FIRST, 16, },
COMMON_SUBPICTURE_FLAGS },
{ I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_A8P8_UNORM,
- { VA_FOURCC('A','I','8','8'), VA_MSB_FIRST, 16, },
+ { VA_FOURCC_AI88, VA_MSB_FIRST, 16, },
COMMON_SUBPICTURE_FLAGS },
{ I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_B8G8R8A8_UNORM,
- { VA_FOURCC('B','G','R','A'), VA_LSB_FIRST, 32,
+ { VA_FOURCC_BGRA, VA_LSB_FIRST, 32,
32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 },
COMMON_SUBPICTURE_FLAGS },
{ I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_R8G8B8A8_UNORM,
- { VA_FOURCC('R','G','B','A'), VA_LSB_FIRST, 32,
+ { VA_FOURCC_RGBA, VA_LSB_FIRST, 32,
32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 },
COMMON_SUBPICTURE_FLAGS },
};
return NULL;
}
-extern struct hw_context *i965_proc_context_init(VADriverContextP, struct object_config *);
-extern struct hw_context *g4x_dec_hw_context_init(VADriverContextP, struct object_config *);
-static struct hw_codec_info g4x_hw_codec_info = {
- .dec_hw_context_init = g4x_dec_hw_context_init,
- .enc_hw_context_init = NULL,
- .proc_hw_context_init = NULL,
- .max_width = 2048,
- .max_height = 2048,
-
- .has_mpeg2_decoding = 1,
-
- .num_filters = 0,
-};
-
-extern struct hw_context *ironlake_dec_hw_context_init(VADriverContextP, struct object_config *);
-static struct hw_codec_info ironlake_hw_codec_info = {
- .dec_hw_context_init = ironlake_dec_hw_context_init,
- .enc_hw_context_init = NULL,
- .proc_hw_context_init = i965_proc_context_init,
- .max_width = 2048,
- .max_height = 2048,
-
- .has_mpeg2_decoding = 1,
- .has_h264_decoding = 1,
- .has_vpp = 1,
- .has_accelerated_putimage = 1,
-
- .num_filters = 0,
-};
-
-extern struct hw_context *gen6_dec_hw_context_init(VADriverContextP, struct object_config *);
-extern struct hw_context *gen6_enc_hw_context_init(VADriverContextP, struct object_config *);
-static struct hw_codec_info gen6_hw_codec_info = {
- .dec_hw_context_init = gen6_dec_hw_context_init,
- .enc_hw_context_init = gen6_enc_hw_context_init,
- .proc_hw_context_init = i965_proc_context_init,
- .max_width = 2048,
- .max_height = 2048,
-
- .has_mpeg2_decoding = 1,
- .has_mpeg2_encoding = 1,
- .has_h264_decoding = 1,
- .has_h264_encoding = 1,
- .has_vc1_decoding = 1,
- .has_vpp = 1,
- .has_accelerated_getimage = 1,
- .has_accelerated_putimage = 1,
- .has_tiled_surface = 1,
-
- .num_filters = 2,
- .filters = {
- { VAProcFilterNoiseReduction, I965_RING_NULL },
- { VAProcFilterDeinterlacing, I965_RING_NULL },
- },
-};
-
-extern struct hw_context *gen7_dec_hw_context_init(VADriverContextP, struct object_config *);
-extern struct hw_context *gen7_enc_hw_context_init(VADriverContextP, struct object_config *);
-static struct hw_codec_info gen7_hw_codec_info = {
- .dec_hw_context_init = gen7_dec_hw_context_init,
- .enc_hw_context_init = gen7_enc_hw_context_init,
- .proc_hw_context_init = i965_proc_context_init,
- .max_width = 4096,
- .max_height = 4096,
-
- .has_mpeg2_decoding = 1,
- .has_mpeg2_encoding = 1,
- .has_h264_decoding = 1,
- .has_h264_encoding = 1,
- .has_vc1_decoding = 1,
- .has_jpeg_decoding = 1,
- .has_vpp = 1,
- .has_accelerated_getimage = 1,
- .has_accelerated_putimage = 1,
- .has_tiled_surface = 1,
- .has_di_motion_adptive = 1,
-
- .num_filters = 2,
- .filters = {
- { VAProcFilterNoiseReduction, I965_RING_NULL },
- { VAProcFilterDeinterlacing, I965_RING_NULL },
- },
-};
-
-extern struct hw_context *gen75_proc_context_init(VADriverContextP, struct object_config *);
-static struct hw_codec_info gen75_hw_codec_info = {
- .dec_hw_context_init = gen75_dec_hw_context_init,
- .enc_hw_context_init = gen75_enc_hw_context_init,
- .proc_hw_context_init = gen75_proc_context_init,
- .max_width = 4096,
- .max_height = 4096,
-
- .has_mpeg2_decoding = 1,
- .has_mpeg2_encoding = 1,
- .has_h264_decoding = 1,
- .has_h264_encoding = 1,
- .has_vc1_decoding = 1,
- .has_jpeg_decoding = 1,
- .has_vpp = 1,
- .has_accelerated_getimage = 1,
- .has_accelerated_putimage = 1,
- .has_tiled_surface = 1,
- .has_di_motion_adptive = 1,
- .has_di_motion_compensated = 1,
-
- .num_filters = 4,
- .filters = {
- { VAProcFilterNoiseReduction, I965_RING_VEBOX },
- { VAProcFilterDeinterlacing, I965_RING_VEBOX },
- { VAProcFilterSharpening, I965_RING_NULL },
- { VAProcFilterColorBalance, I965_RING_VEBOX},
- },
-};
-
#define I965_PACKED_HEADER_BASE 0
#define I965_PACKED_MISC_HEADER_BASE 3
if (packed_type & VAEncPackedHeaderMiscMask) {
idx = I965_PACKED_MISC_HEADER_BASE;
packed_type = (~VAEncPackedHeaderMiscMask & packed_type);
- assert(packed_type > 0);
+ ASSERT_RET(packed_type > 0, 0);
idx += (packed_type - 1);
} else {
idx = I965_PACKED_HEADER_BASE;
default:
/* Should not get here */
- assert(0);
+ ASSERT_RET(0, 0);
break;
}
}
- assert(idx < 4);
+ ASSERT_RET(idx < 4, 0);
return idx;
}
-
VAStatus
i965_QueryConfigProfiles(VADriverContextP ctx,
VAProfile *profile_list, /* out */
if (HAS_H264_DECODING(i965) ||
HAS_H264_ENCODING(i965)) {
- profile_list[i++] = VAProfileH264Baseline;
+ profile_list[i++] = VAProfileH264ConstrainedBaseline;
profile_list[i++] = VAProfileH264Main;
profile_list[i++] = VAProfileH264High;
}
+ if (HAS_H264_MVC_DECODING_PROFILE(i965, VAProfileH264MultiviewHigh))
+ profile_list[i++] = VAProfileH264MultiviewHigh;
+ if (HAS_H264_MVC_DECODING_PROFILE(i965, VAProfileH264StereoHigh))
+ profile_list[i++] = VAProfileH264StereoHigh;
if (HAS_VC1_DECODING(i965)) {
profile_list[i++] = VAProfileVC1Simple;
profile_list[i++] = VAProfileJPEGBaseline;
}
+ if (HAS_VP8_DECODING(i965) ||
+ HAS_VP8_ENCODING(i965)) {
+ profile_list[i++] = VAProfileVP8Version0_3;
+ }
+
+ if (HAS_H264_MVC_ENCODING(i965)) {
+ profile_list[i++] = VAProfileH264MultiviewHigh;
+ profile_list[i++] = VAProfileH264StereoHigh;
+ }
+
/* If the assert fails then I965_MAX_PROFILES needs to be bigger */
- assert(i <= I965_MAX_PROFILES);
+ ASSERT_RET(i <= I965_MAX_PROFILES, VA_STATUS_ERROR_OPERATION_FAILED);
*num_profiles = i;
return VA_STATUS_SUCCESS;
break;
- case VAProfileH264Baseline:
+ case VAProfileH264ConstrainedBaseline:
case VAProfileH264Main:
case VAProfileH264High:
if (HAS_H264_DECODING(i965))
entrypoint_list[n++] = VAEntrypointVLD;
-
+
if (HAS_H264_ENCODING(i965))
entrypoint_list[n++] = VAEntrypointEncSlice;
break;
+ case VAProfileH264MultiviewHigh:
+ case VAProfileH264StereoHigh:
+ if (HAS_H264_MVC_DECODING_PROFILE(i965, profile))
+ entrypoint_list[n++] = VAEntrypointVLD;
+
+ if (HAS_H264_MVC_ENCODING(i965))
+ entrypoint_list[n++] = VAEntrypointEncSlice;
+ break;
case VAProfileVC1Simple:
case VAProfileVC1Main:
entrypoint_list[n++] = VAEntrypointVLD;
break;
+ case VAProfileVP8Version0_3:
+ if (HAS_VP8_DECODING(i965))
+ entrypoint_list[n++] = VAEntrypointVLD;
+
+ if (HAS_VP8_ENCODING(i965))
+ entrypoint_list[n++] = VAEntrypointEncSlice;
+
default:
break;
}
/* If the assert fails then I965_MAX_ENTRYPOINTS needs to be bigger */
- assert(n <= I965_MAX_ENTRYPOINTS);
+ ASSERT_RET(n <= I965_MAX_ENTRYPOINTS, VA_STATUS_ERROR_OPERATION_FAILED);
*num_entrypoints = n;
return n > 0 ? VA_STATUS_SUCCESS : VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
}
+static VAStatus
+i965_validate_config(VADriverContextP ctx, VAProfile profile,
+ VAEntrypoint entrypoint)
+{
+ struct i965_driver_data * const i965 = i965_driver_data(ctx);
+ VAStatus va_status;
+
+ /* Validate profile & entrypoint */
+ switch (profile) {
+ case VAProfileMPEG2Simple:
+ case VAProfileMPEG2Main:
+ if ((HAS_MPEG2_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
+ (HAS_MPEG2_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileH264ConstrainedBaseline:
+ case VAProfileH264Main:
+ case VAProfileH264High:
+ if ((HAS_H264_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
+ (HAS_H264_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileVC1Simple:
+ case VAProfileVC1Main:
+ case VAProfileVC1Advanced:
+ if (HAS_VC1_DECODING(i965) && entrypoint == VAEntrypointVLD) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileNone:
+ if (HAS_VPP(i965) && VAEntrypointVideoProc == entrypoint) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileJPEGBaseline:
+ if (HAS_JPEG_DECODING(i965) && entrypoint == VAEntrypointVLD) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileVP8Version0_3:
+ if ((HAS_VP8_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
+ (HAS_VP8_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+ break;
+
+ case VAProfileH264MultiviewHigh:
+ case VAProfileH264StereoHigh:
+ if ((HAS_H264_MVC_DECODING_PROFILE(i965, profile) &&
+ entrypoint == VAEntrypointVLD) ||
+ (HAS_H264_MVC_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
+ va_status = VA_STATUS_SUCCESS;
+ } else {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+
+ break;
+
+ default:
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ break;
+ }
+ return va_status;
+}
+
+static uint32_t
+i965_get_default_chroma_formats(VADriverContextP ctx, VAProfile profile,
+ VAEntrypoint entrypoint)
+{
+ struct i965_driver_data * const i965 = i965_driver_data(ctx);
+ uint32_t chroma_formats = VA_RT_FORMAT_YUV420;
+
+ switch (profile) {
+ case VAProfileH264ConstrainedBaseline:
+ case VAProfileH264Main:
+ case VAProfileH264High:
+ if (HAS_H264_DECODING(i965) && entrypoint == VAEntrypointVLD)
+ chroma_formats |= i965->codec_info->h264_dec_chroma_formats;
+ break;
+
+ case VAProfileH264MultiviewHigh:
+ case VAProfileH264StereoHigh:
+ if (HAS_H264_MVC_DECODING(i965) && entrypoint == VAEntrypointVLD)
+ chroma_formats |= i965->codec_info->h264_dec_chroma_formats;
+ break;
+
+ case VAProfileJPEGBaseline:
+ if (HAS_JPEG_DECODING(i965) && entrypoint == VAEntrypointVLD)
+ chroma_formats |= i965->codec_info->jpeg_dec_chroma_formats;
+ break;
+
+ default:
+ break;
+ }
+ return chroma_formats;
+}
+
VAStatus
i965_GetConfigAttributes(VADriverContextP ctx,
VAProfile profile,
VAConfigAttrib *attrib_list, /* in/out */
int num_attribs)
{
+ VAStatus va_status;
+ struct i965_driver_data *i965 = i965_driver_data(ctx);
int i;
+ va_status = i965_validate_config(ctx, profile, entrypoint);
+ if (va_status != VA_STATUS_SUCCESS)
+ return va_status;
+
/* Other attributes don't seem to be defined */
/* What to do if we don't know the attribute? */
for (i = 0; i < num_attribs; i++) {
switch (attrib_list[i].type) {
case VAConfigAttribRTFormat:
- attrib_list[i].value = VA_RT_FORMAT_YUV420;
+ attrib_list[i].value = i965_get_default_chroma_formats(ctx,
+ profile, entrypoint);
break;
case VAConfigAttribRateControl:
if (entrypoint == VAEntrypointEncSlice) {
- attrib_list[i].value = VA_RC_CBR | VA_RC_CQP;
+ attrib_list[i].value = VA_RC_CQP;
+
+ if (profile != VAProfileMPEG2Main &&
+ profile != VAProfileMPEG2Simple)
+ attrib_list[i].value |= VA_RC_CBR;
break;
}
case VAConfigAttribEncPackedHeaders:
if (entrypoint == VAEntrypointEncSlice) {
attrib_list[i].value = VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_PICTURE | VA_ENC_PACKED_HEADER_MISC;
+ if (profile == VAProfileH264ConstrainedBaseline ||
+ profile == VAProfileH264Main ||
+ profile == VAProfileH264High ||
+ profile == VAProfileH264StereoHigh ||
+ profile == VAProfileH264MultiviewHigh) {
+ attrib_list[i].value |= (VA_ENC_PACKED_HEADER_RAW_DATA |
+ VA_ENC_PACKED_HEADER_SLICE);
+ }
break;
}
break;
}
+ case VAConfigAttribEncQualityRange:
+ if (entrypoint == VAEntrypointEncSlice) {
+ attrib_list[i].value = 1;
+ if (profile == VAProfileH264ConstrainedBaseline ||
+ profile == VAProfileH264Main ||
+ profile == VAProfileH264High )
+ attrib_list[i].value = ENCODER_QUALITY_RANGE;
+ break;
+ }
+
default:
/* Do nothing */
attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED;
object_heap_free(heap, obj);
}
-static VAStatus
-i965_update_attribute(struct object_config *obj_config, VAConfigAttrib *attrib)
+static VAConfigAttrib *
+i965_lookup_config_attribute(struct object_config *obj_config,
+ VAConfigAttribType type)
{
int i;
- /* Check existing attrbiutes */
for (i = 0; i < obj_config->num_attribs; i++) {
- if (obj_config->attrib_list[i].type == attrib->type) {
- /* Update existing attribute */
- obj_config->attrib_list[i].value = attrib->value;
- return VA_STATUS_SUCCESS;
- }
+ VAConfigAttrib * const attrib = &obj_config->attrib_list[i];
+ if (attrib->type == type)
+ return attrib;
}
+ return NULL;
+}
+
+static VAStatus
+i965_append_config_attribute(struct object_config *obj_config,
+ const VAConfigAttrib *new_attrib)
+{
+ VAConfigAttrib *attrib;
- if (obj_config->num_attribs < I965_MAX_CONFIG_ATTRIBUTES) {
- i = obj_config->num_attribs;
- obj_config->attrib_list[i].type = attrib->type;
- obj_config->attrib_list[i].value = attrib->value;
- obj_config->num_attribs++;
+ if (obj_config->num_attribs >= I965_MAX_CONFIG_ATTRIBUTES)
+ return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
+
+ attrib = &obj_config->attrib_list[obj_config->num_attribs++];
+ attrib->type = new_attrib->type;
+ attrib->value = new_attrib->value;
+ return VA_STATUS_SUCCESS;
+}
+
+static VAStatus
+i965_ensure_config_attribute(struct object_config *obj_config,
+ const VAConfigAttrib *new_attrib)
+{
+ VAConfigAttrib *attrib;
+
+ /* Check for existing attributes */
+ attrib = i965_lookup_config_attribute(obj_config, new_attrib->type);
+ if (attrib) {
+ /* Update existing attribute */
+ attrib->value = new_attrib->value;
return VA_STATUS_SUCCESS;
}
-
- return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
+ return i965_append_config_attribute(obj_config, new_attrib);
}
VAStatus
int i;
VAStatus vaStatus;
- /* Validate profile & entrypoint */
- switch (profile) {
- case VAProfileMPEG2Simple:
- case VAProfileMPEG2Main:
- if ((HAS_MPEG2_DECODING(i965) && VAEntrypointVLD == entrypoint) ||
- (HAS_MPEG2_ENCODING(i965) && VAEntrypointEncSlice == entrypoint)) {
- vaStatus = VA_STATUS_SUCCESS;
- } else {
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
- }
- break;
-
- case VAProfileH264Baseline:
- case VAProfileH264Main:
- case VAProfileH264High:
- if ((HAS_H264_DECODING(i965) && VAEntrypointVLD == entrypoint) ||
- (HAS_H264_ENCODING(i965) && VAEntrypointEncSlice == entrypoint)) {
- vaStatus = VA_STATUS_SUCCESS;
- } else {
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
- }
-
- break;
-
- case VAProfileVC1Simple:
- case VAProfileVC1Main:
- case VAProfileVC1Advanced:
- if (HAS_VC1_DECODING(i965) && VAEntrypointVLD == entrypoint) {
- vaStatus = VA_STATUS_SUCCESS;
- } else {
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
- }
-
- break;
-
- case VAProfileNone:
- if (HAS_VPP(i965) && VAEntrypointVideoProc == entrypoint) {
- vaStatus = VA_STATUS_SUCCESS;
- } else {
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
- }
-
- break;
-
- case VAProfileJPEGBaseline:
- if (HAS_JPEG_DECODING(i965) && VAEntrypointVLD == entrypoint) {
- vaStatus = VA_STATUS_SUCCESS;
- } else {
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
- }
-
- break;
-
- default:
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
- break;
- }
+ vaStatus = i965_validate_config(ctx, profile, entrypoint);
if (VA_STATUS_SUCCESS != vaStatus) {
return vaStatus;
obj_config->profile = profile;
obj_config->entrypoint = entrypoint;
- obj_config->attrib_list[0].type = VAConfigAttribRTFormat;
- obj_config->attrib_list[0].value = VA_RT_FORMAT_YUV420;
- obj_config->num_attribs = 1;
+ obj_config->num_attribs = 0;
- for(i = 0; i < num_attribs; i++) {
- vaStatus = i965_update_attribute(obj_config, &(attrib_list[i]));
-
- if (VA_STATUS_SUCCESS != vaStatus) {
+ for (i = 0; i < num_attribs; i++) {
+ vaStatus = i965_ensure_config_attribute(obj_config, &attrib_list[i]);
+ if (vaStatus != VA_STATUS_SUCCESS)
break;
- }
+ }
+
+ if (vaStatus == VA_STATUS_SUCCESS) {
+ VAConfigAttrib attrib, *attrib_found;
+ attrib.type = VAConfigAttribRTFormat;
+ attrib.value = i965_get_default_chroma_formats(ctx, profile, entrypoint);
+ attrib_found = i965_lookup_config_attribute(obj_config, attrib.type);
+ if (!attrib_found || !attrib_found->value)
+ vaStatus = i965_append_config_attribute(obj_config, &attrib);
+ else if (!(attrib_found->value & attrib.value))
+ vaStatus = VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
}
/* Error recovery */
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i;
- assert(obj_config);
+ ASSERT_RET(obj_config, VA_STATUS_ERROR_INVALID_CONFIG);
*profile = obj_config->profile;
*entrypoint = obj_config->entrypoint;
*num_attribs = obj_config->num_attribs;
return vaStatus;
}
-static void
-i965_destroy_surface(struct object_heap *heap, struct object_base *obj)
+void
+i965_destroy_surface_storage(struct object_surface *obj_surface)
{
- struct object_surface *obj_surface = (struct object_surface *)obj;
+ if (!obj_surface)
+ return;
dri_bo_unreference(obj_surface->bo);
obj_surface->bo = NULL;
obj_surface->free_private_data(&obj_surface->private_data);
obj_surface->private_data = NULL;
}
+}
+static void
+i965_destroy_surface(struct object_heap *heap, struct object_base *obj)
+{
+ struct object_surface *obj_surface = (struct object_surface *)obj;
+
+ i965_destroy_surface_storage(obj_surface);
object_heap_free(heap, obj);
}
return VA_STATUS_SUCCESS;
// todo, should we disable tiling for 422 format?
- if (expected_fourcc == VA_FOURCC('I', '4', '2', '0') ||
- expected_fourcc == VA_FOURCC('I', 'Y', 'U', 'V') ||
- expected_fourcc == VA_FOURCC('Y', 'V', '1', '2'))
+ if (expected_fourcc == VA_FOURCC_I420 ||
+ expected_fourcc == VA_FOURCC_IYUV ||
+ expected_fourcc == VA_FOURCC_YV12 ||
+ expected_fourcc == VA_FOURCC_YV16)
tiling = 0;
i965_check_alloc_surface_bo(ctx, obj_surface, tiling, expected_fourcc, get_sampling_from_fourcc(expected_fourcc));
index > memory_attibute->num_buffers)
return VA_STATUS_ERROR_INVALID_PARAMETER;
- assert(obj_surface->orig_width == memory_attibute->width);
- assert(obj_surface->orig_height == memory_attibute->height);
- assert(memory_attibute->num_planes >= 1);
+ ASSERT_RET(obj_surface->orig_width == memory_attibute->width, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(obj_surface->orig_height == memory_attibute->height, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->num_planes >= 1, VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->fourcc = memory_attibute->pixel_format;
obj_surface->width = memory_attibute->pitches[0];
obj_surface->x_cr_offset = 0;
switch (obj_surface->fourcc) {
- case VA_FOURCC('N', 'V', '1', '2'):
- assert(memory_attibute->num_planes == 2);
- assert(memory_attibute->pitches[0] == memory_attibute->pitches[1]);
+ case VA_FOURCC_NV12:
+ ASSERT_RET(memory_attibute->num_planes == 2, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[0] == memory_attibute->pitches[1], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cb_offset = obj_surface->height;
break;
- case VA_FOURCC('Y', 'V', '1', '2'):
- case VA_FOURCC('I', 'M', 'C', '1'):
- assert(memory_attibute->num_planes == 3);
- assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_IMC1:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cr_offset = obj_surface->height;
break;
- case VA_FOURCC('I', '4', '2', '0'):
- case VA_FOURCC('I', 'Y', 'U', 'V'):
- case VA_FOURCC('I', 'M', 'C', '3'):
- assert(memory_attibute->num_planes == 3);
- assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
+ case VA_FOURCC_I420:
+ case VA_FOURCC_IYUV:
+ case VA_FOURCC_IMC3:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cb_offset = obj_surface->height;
break;
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('U', 'Y', 'V', 'Y'):
- assert(memory_attibute->num_planes == 1);
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_UYVY:
+ ASSERT_RET(memory_attibute->num_planes == 1, VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = 0;
break;
- case VA_FOURCC('R', 'G', 'B', 'A'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
- assert(memory_attibute->num_planes == 1);
+ case VA_FOURCC_RGBA:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
+ ASSERT_RET(memory_attibute->num_planes == 1, VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_RGBX;
obj_surface->y_cb_offset = 0;
break;
- case VA_FOURCC('Y', '8', '0', '0'): /* monochrome surface */
- assert(memory_attibute->num_planes == 1);
+ case VA_FOURCC_Y800: /* monochrome surface */
+ ASSERT_RET(memory_attibute->num_planes == 1, VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV400;
obj_surface->y_cb_offset = 0;
break;
- case VA_FOURCC('4', '1', '1', 'P'):
- assert(memory_attibute->num_planes == 3);
- assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
+ case VA_FOURCC_411P:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV411;
obj_surface->y_cb_offset = 0;
break;
- case VA_FOURCC('4', '2', '2', 'H'):
- assert(memory_attibute->num_planes == 3);
- assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
+ case VA_FOURCC_422H:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = obj_surface->height;
break;
- case VA_FOURCC('4', '2', '2', 'V'):
+ case VA_FOURCC_YV16:
assert(memory_attibute->num_planes == 3);
assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
+ obj_surface->y_cr_offset = memory_attibute->offsets[1] / obj_surface->width;
+ obj_surface->y_cb_offset = memory_attibute->offsets[2] / obj_surface->width;
+ obj_surface->cb_cr_width = obj_surface->orig_width / 2;
+ obj_surface->cb_cr_height = obj_surface->orig_height;
+ obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
+
+ break;
+
+ case VA_FOURCC_422V:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
+
+ obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset = memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width;
break;
- case VA_FOURCC('4', '4', '4', 'P'):
- assert(memory_attibute->num_planes == 3);
- assert(memory_attibute->pitches[1] == memory_attibute->pitches[2]);
+ case VA_FOURCC_444P:
+ ASSERT_RET(memory_attibute->num_planes == 3, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(memory_attibute->pitches[1] == memory_attibute->pitches[2], VA_STATUS_ERROR_INVALID_PARAMETER);
obj_surface->subsampling = SUBSAMPLE_YUV444;
obj_surface->y_cb_offset = obj_surface->height;
return VA_STATUS_SUCCESS;
}
+/* byte-per-pixel of the first plane */
+static int
+bpp_1stplane_by_fourcc(unsigned int fourcc)
+{
+ const i965_fourcc_info *info = get_fourcc_info(fourcc);
+
+ if (info && (info->flag & I_S))
+ return info->bpp[0] / 8;
+ else
+ return 0;
+}
+
static VAStatus
i965_CreateSurfaces2(
VADriverContextP ctx,
for (i = 0; i < num_attribs && attrib_list; i++) {
if ((attrib_list[i].type == VASurfaceAttribPixelFormat) &&
(attrib_list[i].flags & VA_SURFACE_ATTRIB_SETTABLE)) {
- assert(attrib_list[i].value.type == VAGenericValueTypeInteger);
+ ASSERT_RET(attrib_list[i].value.type == VAGenericValueTypeInteger, VA_STATUS_ERROR_INVALID_PARAMETER);
expected_fourcc = attrib_list[i].value.value.i;
}
if ((attrib_list[i].type == VASurfaceAttribMemoryType) &&
(attrib_list[i].flags & VA_SURFACE_ATTRIB_SETTABLE)) {
- assert(attrib_list[i].value.type == VAGenericValueTypeInteger);
+ ASSERT_RET(attrib_list[i].value.type == VAGenericValueTypeInteger, VA_STATUS_ERROR_INVALID_PARAMETER);
if (attrib_list[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM)
memory_type = I965_SURFACE_MEM_GEM_FLINK; /* flinked GEM handle */
else if (attrib_list[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME)
memory_type = I965_SURFACE_MEM_DRM_PRIME; /* drm prime fd */
+ else if (attrib_list[i].value.value.i == VA_SURFACE_ATTRIB_MEM_TYPE_VA)
+ memory_type = I965_SURFACE_MEM_NATIVE; /* va native memory, to be allocated */
}
if ((attrib_list[i].type == VASurfaceAttribExternalBufferDescriptor) &&
(attrib_list[i].flags == VA_SURFACE_ATTRIB_SETTABLE)) {
- assert(attrib_list[i].value.type == VAGenericValueTypePointer);
+ ASSERT_RET(attrib_list[i].value.type == VAGenericValueTypePointer, VA_STATUS_ERROR_INVALID_PARAMETER);
memory_attibute = (VASurfaceAttribExternalBuffers *)attrib_list[i].value.value.p;
}
}
obj_surface->status = VASurfaceReady;
obj_surface->orig_width = width;
obj_surface->orig_height = height;
+ obj_surface->user_disable_tiling = false;
+ obj_surface->user_h_stride_set = false;
+ obj_surface->user_v_stride_set = false;
obj_surface->subpic_render_idx = 0;
for(j = 0; j < I965_MAX_SUBPIC_SUM; j++){
obj_surface->obj_subpic[j] = NULL;
}
- obj_surface->width = ALIGN(width, 16);
- obj_surface->height = ALIGN(height, 16);
+ assert(i965->codec_info->min_linear_wpitch);
+ assert(i965->codec_info->min_linear_hpitch);
+ obj_surface->width = ALIGN(width, i965->codec_info->min_linear_wpitch);
+ obj_surface->height = ALIGN(height, i965->codec_info->min_linear_hpitch);
obj_surface->flags = SURFACE_REFERENCED;
obj_surface->fourcc = 0;
obj_surface->bo = NULL;
switch (memory_type) {
case I965_SURFACE_MEM_NATIVE:
+ if (memory_attibute) {
+ if (!(memory_attibute->flags & VA_SURFACE_EXTBUF_DESC_ENABLE_TILING))
+ obj_surface->user_disable_tiling = true;
+
+ if (memory_attibute->pixel_format) {
+ if (expected_fourcc)
+ ASSERT_RET(memory_attibute->pixel_format == expected_fourcc, VA_STATUS_ERROR_INVALID_PARAMETER);
+ else
+ expected_fourcc = memory_attibute->pixel_format;
+ }
+ ASSERT_RET(expected_fourcc, VA_STATUS_ERROR_INVALID_PARAMETER);
+ if (memory_attibute->pitches[0]) {
+ int bpp_1stplane = bpp_1stplane_by_fourcc(expected_fourcc);
+ ASSERT_RET(bpp_1stplane, VA_STATUS_ERROR_INVALID_PARAMETER);
+ obj_surface->width = memory_attibute->pitches[0]/bpp_1stplane;
+ obj_surface->user_h_stride_set = true;
+ ASSERT_RET(IS_ALIGNED(obj_surface->width, 16), VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(obj_surface->width >= width, VA_STATUS_ERROR_INVALID_PARAMETER);
+
+ if (memory_attibute->offsets[1]) {
+ ASSERT_RET(!memory_attibute->offsets[0], VA_STATUS_ERROR_INVALID_PARAMETER);
+ obj_surface->height = memory_attibute->offsets[1]/memory_attibute->pitches[0];
+ obj_surface->user_v_stride_set = true;
+ ASSERT_RET(IS_ALIGNED(obj_surface->height, 16), VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(obj_surface->height >= height, VA_STATUS_ERROR_INVALID_PARAMETER);
+ }
+ }
+ }
i965_surface_native_memory(ctx,
obj_surface,
format,
for (i = num_surfaces; i--; ) {
struct object_surface *obj_surface = SURFACE(surface_list[i]);
- assert(obj_surface);
+ ASSERT_RET(obj_surface, VA_STATUS_ERROR_INVALID_SURFACE);
i965_destroy_surface(&i965->surface_heap, (struct object_base *)obj_surface);
}
struct object_context *obj_context = NULL;
struct object_config *obj_config = NULL;
- *fourcc = VA_FOURCC('Y', 'V', '1', '2');
+ *fourcc = VA_FOURCC_YV12;
*is_tiled = 0;
if (i965->current_context_id == VA_INVALID_ID)
if (!obj_config)
return;
- if (IS_GEN6(i965->intel.device_id) || IS_GEN7(i965->intel.device_id)) {
- *fourcc = VA_FOURCC('N', 'V', '1', '2');
+ if (IS_GEN6(i965->intel.device_info) ||
+ IS_GEN7(i965->intel.device_info) ||
+ IS_GEN8(i965->intel.device_info)) {
+ *fourcc = VA_FOURCC_NV12;
*is_tiled = 1;
return;
}
switch (obj_config->profile) {
case VAProfileMPEG2Simple:
case VAProfileMPEG2Main:
- *fourcc = VA_FOURCC('I', '4', '2', '0');
+ *fourcc = VA_FOURCC_I420;
*is_tiled = 0;
break;
default:
- *fourcc = VA_FOURCC('N', 'V', '1', '2');
+ *fourcc = VA_FOURCC_NV12;
*is_tiled = 0;
break;
}
if (!obj_subpic)
return VA_STATUS_ERROR_INVALID_SUBPICTURE;
- assert(obj_subpic->obj_image);
+ ASSERT_RET(obj_subpic->obj_image, VA_STATUS_ERROR_INVALID_SUBPICTURE);
i965_destroy_subpic(&i965->subpic_heap, (struct object_base *)obj_subpic);
return VA_STATUS_SUCCESS;
}
if (!obj_subpic)
return VA_STATUS_ERROR_INVALID_SUBPICTURE;
- assert(obj_subpic->obj_image);
+ ASSERT_RET(obj_subpic->obj_image, VA_STATUS_ERROR_INVALID_SUBPICTURE);
obj_subpic->src_rect.x = src_x;
obj_subpic->src_rect.y = src_y;
i965_release_buffer_store(&obj_context->codec_state.encode.slice_params_ext[i]);
free(obj_context->codec_state.encode.slice_params_ext);
+ if (obj_context->codec_state.encode.slice_rawdata_index) {
+ free(obj_context->codec_state.encode.slice_rawdata_index);
+ obj_context->codec_state.encode.slice_rawdata_index = NULL;
+ }
+ if (obj_context->codec_state.encode.slice_rawdata_count) {
+ free(obj_context->codec_state.encode.slice_rawdata_count);
+ obj_context->codec_state.encode.slice_rawdata_count = NULL;
+ }
+
+ if (obj_context->codec_state.encode.slice_header_index) {
+ free(obj_context->codec_state.encode.slice_header_index);
+ obj_context->codec_state.encode.slice_header_index = NULL;
+ }
+
+ for (i = 0; i < obj_context->codec_state.encode.num_packed_header_params_ext; i++)
+ i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_params_ext[i]);
+ free(obj_context->codec_state.encode.packed_header_params_ext);
+
+ for (i = 0; i < obj_context->codec_state.encode.num_packed_header_data_ext; i++)
+ i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_data_ext[i]);
+ free(obj_context->codec_state.encode.packed_header_data_ext);
+
} else {
assert(obj_context->codec_state.decode.num_slice_params <= obj_context->codec_state.decode.max_slice_params);
assert(obj_context->codec_state.decode.num_slice_datas <= obj_context->codec_state.decode.max_slice_datas);
struct i965_render_state *render_state = &i965->render_state;
struct object_config *obj_config = CONFIG(config_id);
struct object_context *obj_context = NULL;
+ VAConfigAttrib *attrib;
VAStatus vaStatus = VA_STATUS_SUCCESS;
int contextID;
int i;
render_state->inited = 1;
switch (obj_config->profile) {
- case VAProfileH264Baseline:
+ case VAProfileH264ConstrainedBaseline:
case VAProfileH264Main:
case VAProfileH264High:
if (!HAS_H264_DECODING(i965) &&
return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
render_state->interleaved_uv = 1;
break;
+ case VAProfileH264MultiviewHigh:
+ case VAProfileH264StereoHigh:
+ if (!HAS_H264_MVC_DECODING(i965))
+ return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ render_state->interleaved_uv = 1;
+ break;
default:
- render_state->interleaved_uv = !!(IS_GEN6(i965->intel.device_id) || IS_GEN7(i965->intel.device_id));
+ render_state->interleaved_uv = !!(IS_GEN6(i965->intel.device_info) || IS_GEN7(i965->intel.device_info) || IS_GEN8(i965->intel.device_info));
break;
}
assert(i965->codec_info->proc_hw_context_init);
obj_context->hw_context = i965->codec_info->proc_hw_context_init(ctx, obj_config);
} else if (VAEntrypointEncSlice == obj_config->entrypoint) { /*encode routin only*/
+ VAConfigAttrib *packed_attrib;
obj_context->codec_type = CODEC_ENC;
memset(&obj_context->codec_state.encode, 0, sizeof(obj_context->codec_state.encode));
obj_context->codec_state.encode.current_render_target = VA_INVALID_ID;
obj_context->codec_state.encode.max_slice_params = NUM_SLICES;
obj_context->codec_state.encode.slice_params = calloc(obj_context->codec_state.encode.max_slice_params,
sizeof(*obj_context->codec_state.encode.slice_params));
+ obj_context->codec_state.encode.max_packed_header_params_ext = NUM_SLICES;
+ obj_context->codec_state.encode.packed_header_params_ext =
+ calloc(obj_context->codec_state.encode.max_packed_header_params_ext,
+ sizeof(struct buffer_store *));
+
+ obj_context->codec_state.encode.max_packed_header_data_ext = NUM_SLICES;
+ obj_context->codec_state.encode.packed_header_data_ext =
+ calloc(obj_context->codec_state.encode.max_packed_header_data_ext,
+ sizeof(struct buffer_store *));
+
+ obj_context->codec_state.encode.max_slice_num = NUM_SLICES;
+ obj_context->codec_state.encode.slice_rawdata_index =
+ calloc(obj_context->codec_state.encode.max_slice_num, sizeof(int));
+ obj_context->codec_state.encode.slice_rawdata_count =
+ calloc(obj_context->codec_state.encode.max_slice_num, sizeof(int));
+
+ obj_context->codec_state.encode.slice_header_index =
+ calloc(obj_context->codec_state.encode.max_slice_num, sizeof(int));
+
+ obj_context->codec_state.encode.slice_index = 0;
+ packed_attrib = i965_lookup_config_attribute(obj_config, VAConfigAttribEncPackedHeaders);
+ if (packed_attrib)
+ obj_context->codec_state.encode.packed_header_flag = packed_attrib->value;
+ else {
+ /* use the default value. SPS/PPS/RAWDATA is passed from user
+ * while Slice_header data is generated by driver.
+ */
+ obj_context->codec_state.encode.packed_header_flag =
+ VA_ENC_PACKED_HEADER_SEQUENCE |
+ VA_ENC_PACKED_HEADER_PICTURE |
+ VA_ENC_PACKED_HEADER_RAW_DATA;
+ }
assert(i965->codec_info->enc_hw_context_init);
obj_context->hw_context = i965->codec_info->enc_hw_context_init(ctx, obj_config);
} else {
}
}
+ attrib = i965_lookup_config_attribute(obj_config, VAConfigAttribRTFormat);
+ if (!attrib)
+ return VA_STATUS_ERROR_INVALID_CONFIG;
+ obj_context->codec_state.base.chroma_formats = attrib->value;
+
/* Error recovery */
if (VA_STATUS_SUCCESS != vaStatus) {
i965_destroy_context(&i965->context_heap, (struct object_base *)obj_context);
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_context *obj_context = CONTEXT(context);
- assert(obj_context);
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
if (i965->current_context_id == context)
i965->current_context_id = VA_INVALID_ID;
case VAProcPipelineParameterBufferType:
case VAProcFilterParameterBufferType:
case VAHuffmanTableBufferType:
+ case VAProbabilityBufferType:
/* Ok */
break;
obj_buffer->num_elements = num_elements;
obj_buffer->size_element = size;
obj_buffer->type = type;
+ obj_buffer->export_refcount = 0;
obj_buffer->buffer_store = NULL;
buffer_store = calloc(1, sizeof(struct buffer_store));
assert(buffer_store);
dri_bo_subdata(buffer_store->bo, 0, size * num_elements, data);
} else if (type == VASliceDataBufferType ||
type == VAImageBufferType ||
- type == VAEncCodedBufferType) {
+ type == VAEncCodedBufferType ||
+ type == VAProbabilityBufferType) {
buffer_store->bo = dri_bo_alloc(i965->intel.bufmgr,
"Buffer",
size * num_elements, 64);
struct object_buffer *obj_buffer = BUFFER(buf_id);
VAStatus vaStatus = VA_STATUS_SUCCESS;
- assert(obj_buffer);
-
- if (!obj_buffer)
- return VA_STATUS_ERROR_INVALID_BUFFER;
+ ASSERT_RET(obj_buffer, VA_STATUS_ERROR_INVALID_BUFFER);
if ((num_elements < 0) ||
(num_elements > obj_buffer->max_num_elements)) {
struct object_buffer *obj_buffer = BUFFER(buf_id);
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
- assert(obj_buffer && obj_buffer->buffer_store);
- assert(obj_buffer->buffer_store->bo || obj_buffer->buffer_store->buffer);
- assert(!(obj_buffer->buffer_store->bo && obj_buffer->buffer_store->buffer));
-
- if (!obj_buffer || !obj_buffer->buffer_store)
- return VA_STATUS_ERROR_INVALID_BUFFER;
+ ASSERT_RET(obj_buffer && obj_buffer->buffer_store, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(obj_buffer->buffer_store->bo || obj_buffer->buffer_store->buffer, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(!(obj_buffer->buffer_store->bo && obj_buffer->buffer_store->buffer), VA_STATUS_ERROR_INVALID_BUFFER);
if (NULL != obj_buffer->buffer_store->bo) {
unsigned int tiling, swizzle;
else
dri_bo_map(obj_buffer->buffer_store->bo, 1);
- assert(obj_buffer->buffer_store->bo->virtual);
+ ASSERT_RET(obj_buffer->buffer_store->bo->virtual, VA_STATUS_ERROR_OPERATION_FAILED);
*pbuf = obj_buffer->buffer_store->bo->virtual;
if (obj_buffer->type == VAEncCodedBufferType) {
coded_buffer_segment->base.buf = buffer = (unsigned char *)(obj_buffer->buffer_store->bo->virtual) + I965_CODEDBUFFER_HEADER_SIZE;
- if (coded_buffer_segment->codec == CODEC_H264) {
+ if (coded_buffer_segment->codec == CODEC_H264 ||
+ coded_buffer_segment->codec == CODEC_H264_MVC) {
delimiter0 = H264_DELIMITER0;
delimiter1 = H264_DELIMITER1;
delimiter2 = H264_DELIMITER2;
delimiter3 = MPEG2_DELIMITER3;
delimiter4 = MPEG2_DELIMITER4;
} else {
- assert(0);
+ ASSERT_RET(0, VA_STATUS_ERROR_UNSUPPORTED_PROFILE);
}
for (i = 0; i < obj_buffer->size_element - I965_CODEDBUFFER_HEADER_SIZE - 3 - 0x1000; i++) {
if ((buf_id & OBJECT_HEAP_OFFSET_MASK) != BUFFER_ID_OFFSET)
return VA_STATUS_ERROR_INVALID_BUFFER;
- assert(obj_buffer && obj_buffer->buffer_store);
- assert(obj_buffer->buffer_store->bo || obj_buffer->buffer_store->buffer);
- assert(!(obj_buffer->buffer_store->bo && obj_buffer->buffer_store->buffer));
-
- if (!obj_buffer || !obj_buffer->buffer_store)
- return VA_STATUS_ERROR_INVALID_BUFFER;
+ ASSERT_RET(obj_buffer && obj_buffer->buffer_store, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(obj_buffer->buffer_store->bo || obj_buffer->buffer_store->buffer, VA_STATUS_ERROR_OPERATION_FAILED);
+ ASSERT_RET(!(obj_buffer->buffer_store->bo && obj_buffer->buffer_store->buffer), VA_STATUS_ERROR_OPERATION_FAILED);
if (NULL != obj_buffer->buffer_store->bo) {
unsigned int tiling, swizzle;
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_buffer *obj_buffer = BUFFER(buffer_id);
- assert(obj_buffer);
-
- if (!obj_buffer)
- return VA_STATUS_ERROR_INVALID_BUFFER;
+ ASSERT_RET(obj_buffer, VA_STATUS_ERROR_INVALID_BUFFER);
i965_destroy_buffer(&i965->buffer_heap, (struct object_base *)obj_buffer);
VAStatus vaStatus;
int i;
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
-
- assert(obj_surface);
-
- if (!obj_surface)
- return VA_STATUS_ERROR_INVALID_SURFACE;
-
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
+ ASSERT_RET(obj_surface, VA_STATUS_ERROR_INVALID_SURFACE);
obj_config = obj_context->obj_config;
- assert(obj_config);
+ ASSERT_RET(obj_config, VA_STATUS_ERROR_INVALID_CONFIG);
switch (obj_config->profile) {
case VAProfileMPEG2Simple:
vaStatus = VA_STATUS_SUCCESS;
break;
- case VAProfileH264Baseline:
+ case VAProfileH264ConstrainedBaseline:
case VAProfileH264Main:
case VAProfileH264High:
vaStatus = VA_STATUS_SUCCESS;
break;
+ case VAProfileH264MultiviewHigh:
+ case VAProfileH264StereoHigh:
+ if (HAS_H264_MVC_DECODING_PROFILE(i965, obj_config->profile) ||
+ HAS_H264_MVC_ENCODING(i965)) {
+ vaStatus = VA_STATUS_SUCCESS;
+ } else {
+ ASSERT_RET(0, VA_STATUS_ERROR_UNSUPPORTED_PROFILE);
+ }
+ break;
+
case VAProfileVC1Simple:
case VAProfileVC1Main:
case VAProfileVC1Advanced:
vaStatus = VA_STATUS_SUCCESS;
break;
+ case VAProfileVP8Version0_3:
+ vaStatus = VA_STATUS_SUCCESS;
+ break;
+
default:
- assert(0);
- vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ ASSERT_RET(0, VA_STATUS_ERROR_UNSUPPORTED_PROFILE);
break;
}
obj_context->codec_state.encode.num_slice_params_ext = 0;
obj_context->codec_state.encode.current_render_target = render_target; /*This is input new frame*/
obj_context->codec_state.encode.last_packed_header_type = 0;
+ memset(obj_context->codec_state.encode.slice_rawdata_index, 0,
+ sizeof(int) * obj_context->codec_state.encode.max_slice_num);
+ memset(obj_context->codec_state.encode.slice_rawdata_count, 0,
+ sizeof(int) * obj_context->codec_state.encode.max_slice_num);
+ memset(obj_context->codec_state.encode.slice_header_index, 0,
+ sizeof(int) * obj_context->codec_state.encode.max_slice_num);
+
+ for (i = 0; i < obj_context->codec_state.encode.num_packed_header_params_ext; i++)
+ i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_params_ext[i]);
+ for (i = 0; i < obj_context->codec_state.encode.num_packed_header_data_ext; i++)
+ i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_data_ext[i]);
+ obj_context->codec_state.encode.num_packed_header_params_ext = 0;
+ obj_context->codec_state.encode.num_packed_header_data_ext = 0;
+ obj_context->codec_state.encode.slice_index = 0;
} else {
obj_context->codec_state.decode.current_render_target = render_target;
i965_release_buffer_store(&obj_context->codec_state.decode.pic_param);
struct object_buffer *obj_buffer) \
{ \
struct category##_state *category = &obj_context->codec_state.category; \
- assert(obj_buffer->buffer_store->bo == NULL); \
- assert(obj_buffer->buffer_store->buffer); \
i965_release_buffer_store(&category->member); \
i965_reference_buffer_store(&category->member, obj_buffer->buffer_store); \
return VA_STATUS_SUCCESS; \
DEF_RENDER_DECODE_SINGLE_BUFFER_FUNC(iq_matrix, iq_matrix)
DEF_RENDER_DECODE_SINGLE_BUFFER_FUNC(bit_plane, bit_plane)
DEF_RENDER_DECODE_SINGLE_BUFFER_FUNC(huffman_table, huffman_table)
+DEF_RENDER_DECODE_SINGLE_BUFFER_FUNC(probability_data, probability_data)
#define DEF_RENDER_DECODE_MULTI_BUFFER_FUNC(name, member) DEF_RENDER_MULTI_BUFFER_FUNC(decode, name, member)
DEF_RENDER_DECODE_MULTI_BUFFER_FUNC(slice_parameter, slice_params)
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i;
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
for (i = 0; i < num_buffers && vaStatus == VA_STATUS_SUCCESS; i++) {
struct object_buffer *obj_buffer = BUFFER(buffers[i]);
vaStatus = I965_RENDER_DECODE_BUFFER(huffman_table);
break;
+ case VAProbabilityBufferType:
+ vaStatus = I965_RENDER_DECODE_BUFFER(probability_data);
+ break;
+
default:
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
break;
// DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(slice_parameter, slice_params)
DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(slice_parameter_ext, slice_params_ext)
+DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(packed_header_params_ext, packed_header_params_ext)
+DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(packed_header_data_ext, packed_header_data_ext)
+
static VAStatus
i965_encoder_render_packed_header_parameter_buffer(VADriverContextP ctx,
struct object_context *obj_context,
{
struct encode_state *encode = &obj_context->codec_state.encode;
- assert(obj_buffer->buffer_store->bo == NULL);
- assert(obj_buffer->buffer_store->buffer);
+ ASSERT_RET(obj_buffer->buffer_store->bo == NULL, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(obj_buffer->buffer_store->buffer, VA_STATUS_ERROR_INVALID_BUFFER);
i965_release_buffer_store(&encode->packed_header_param[type_index]);
i965_reference_buffer_store(&encode->packed_header_param[type_index], obj_buffer->buffer_store);
{
struct encode_state *encode = &obj_context->codec_state.encode;
- assert(obj_buffer->buffer_store->bo == NULL);
- assert(obj_buffer->buffer_store->buffer);
+ ASSERT_RET(obj_buffer->buffer_store->bo == NULL, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(obj_buffer->buffer_store->buffer, VA_STATUS_ERROR_INVALID_BUFFER);
i965_release_buffer_store(&encode->packed_header_data[type_index]);
i965_reference_buffer_store(&encode->packed_header_data[type_index], obj_buffer->buffer_store);
struct encode_state *encode = &obj_context->codec_state.encode;
VAEncMiscParameterBuffer *param = NULL;
- assert(obj_buffer->buffer_store->bo == NULL);
- assert(obj_buffer->buffer_store->buffer);
+ ASSERT_RET(obj_buffer->buffer_store->bo == NULL, VA_STATUS_ERROR_INVALID_BUFFER);
+ ASSERT_RET(obj_buffer->buffer_store->buffer, VA_STATUS_ERROR_INVALID_BUFFER);
param = (VAEncMiscParameterBuffer *)obj_buffer->buffer_store->buffer;
+
+ if (param->type >= ARRAY_ELEMS(encode->misc_param))
+ return VA_STATUS_ERROR_INVALID_PARAMETER;
+
i965_release_buffer_store(&encode->misc_param[param->type]);
i965_reference_buffer_store(&encode->misc_param[param->type], obj_buffer->buffer_store);
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_context *obj_context = CONTEXT(context);
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
+ struct encode_state *encode;
int i;
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
+ encode = &obj_context->codec_state.encode;
for (i = 0; i < num_buffers; i++) {
struct object_buffer *obj_buffer = BUFFER(buffers[i]);
case VAEncSliceParameterBufferType:
vaStatus = I965_RENDER_ENCODE_BUFFER(slice_parameter_ext);
+ if (vaStatus == VA_STATUS_SUCCESS) {
+ /* When the max number of slices is updated, it also needs
+ * to reallocate the arrays that is used to store
+ * the packed data index/count for the slice
+ */
+ if (!(encode->packed_header_flag & VA_ENC_PACKED_HEADER_SLICE)) {
+ encode->slice_index++;
+ }
+ if (encode->slice_index == encode->max_slice_num) {
+ int slice_num = encode->max_slice_num;
+ encode->slice_rawdata_index = realloc(encode->slice_rawdata_index,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ encode->slice_rawdata_count = realloc(encode->slice_rawdata_count,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ encode->slice_header_index = realloc(encode->slice_header_index,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ memset(encode->slice_rawdata_index + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+ memset(encode->slice_rawdata_count + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+ memset(encode->slice_header_index + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+
+ encode->max_slice_num += NUM_SLICES;
+ if ((encode->slice_rawdata_index == NULL) ||
+ (encode->slice_header_index == NULL) ||
+ (encode->slice_rawdata_count == NULL)) {
+ vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+ return vaStatus;
+ }
+ }
+ }
break;
case VAEncPackedHeaderParameterBufferType:
{
- struct encode_state *encode = &obj_context->codec_state.encode;
VAEncPackedHeaderParameterBuffer *param = (VAEncPackedHeaderParameterBuffer *)obj_buffer->buffer_store->buffer;
encode->last_packed_header_type = param->type;
- vaStatus = i965_encoder_render_packed_header_parameter_buffer(ctx,
+ if ((param->type == VAEncPackedHeaderRawData) ||
+ (param->type == VAEncPackedHeaderSlice)) {
+ vaStatus = I965_RENDER_ENCODE_BUFFER(packed_header_params_ext);
+ } else {
+ vaStatus = i965_encoder_render_packed_header_parameter_buffer(ctx,
obj_context,
obj_buffer,
va_enc_packed_type_to_idx(encode->last_packed_header_type));
+ }
break;
}
case VAEncPackedHeaderDataBufferType:
{
- struct encode_state *encode = &obj_context->codec_state.encode;
-
- assert(encode->last_packed_header_type == VAEncPackedHeaderSequence ||
- encode->last_packed_header_type == VAEncPackedHeaderPicture ||
- encode->last_packed_header_type == VAEncPackedHeaderSlice ||
+ if (encode->last_packed_header_type == 0) {
+ WARN_ONCE("the packed header data is passed without type!\n");
+ vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;
+ return vaStatus;
+ }
+ if (encode->last_packed_header_type == VAEncPackedHeaderRawData ||
+ encode->last_packed_header_type == VAEncPackedHeaderSlice) {
+ vaStatus = I965_RENDER_ENCODE_BUFFER(packed_header_data_ext);
+
+ /* When the PACKED_SLICE_HEADER flag is passed, it will use
+ * the packed_slice_header as the delimeter to decide how
+ * the packed rawdata is inserted for the given slice.
+ * Otherwise it will use the VAEncSequenceParameterBuffer
+ * as the delimeter
+ */
+ if (encode->packed_header_flag & VA_ENC_PACKED_HEADER_SLICE) {
+ /* store the first index of the packed header data for current slice */
+ if (encode->slice_rawdata_index[encode->slice_index] == 0) {
+ encode->slice_rawdata_index[encode->slice_index] =
+ SLICE_PACKED_DATA_INDEX_TYPE | (encode->num_packed_header_data_ext - 1);
+ }
+ encode->slice_rawdata_count[encode->slice_index]++;
+ if (encode->last_packed_header_type == VAEncPackedHeaderSlice) {
+ /* find one packed slice_header delimeter. And the following
+ * packed data is for the next slice
+ */
+ encode->slice_header_index[encode->slice_index] =
+ SLICE_PACKED_DATA_INDEX_TYPE | (encode->num_packed_header_data_ext - 1);
+ encode->slice_index++;
+ /* Reallocate the buffer to record the index/count of
+ * packed_data for one slice.
+ */
+ if (encode->slice_index == encode->max_slice_num) {
+ int slice_num = encode->max_slice_num;
+
+ encode->slice_rawdata_index = realloc(encode->slice_rawdata_index,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ encode->slice_rawdata_count = realloc(encode->slice_rawdata_count,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ encode->slice_header_index = realloc(encode->slice_header_index,
+ (slice_num + NUM_SLICES) * sizeof(int));
+ memset(encode->slice_rawdata_index + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+ memset(encode->slice_rawdata_count + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+ memset(encode->slice_header_index + slice_num, 0,
+ sizeof(int) * NUM_SLICES);
+ encode->max_slice_num += NUM_SLICES;
+ }
+ }
+ } else {
+ if (vaStatus == VA_STATUS_SUCCESS) {
+ /* store the first index of the packed header data for current slice */
+ if (encode->slice_rawdata_index[encode->slice_index] == 0) {
+ encode->slice_rawdata_index[encode->slice_index] =
+ SLICE_PACKED_DATA_INDEX_TYPE | (encode->num_packed_header_data_ext - 1);
+ }
+ encode->slice_rawdata_count[encode->slice_index]++;
+ if (encode->last_packed_header_type == VAEncPackedHeaderSlice) {
+ if (encode->slice_header_index[encode->slice_index] == 0) {
+ encode->slice_header_index[encode->slice_index] =
+ SLICE_PACKED_DATA_INDEX_TYPE | (encode->num_packed_header_data_ext - 1);
+ } else {
+ WARN_ONCE("Multi slice header data is passed for"
+ " slice %d!\n", encode->slice_index);
+ }
+ }
+ }
+ }
+ } else {
+ ASSERT_RET(encode->last_packed_header_type == VAEncPackedHeaderSequence ||
+ encode->last_packed_header_type == VAEncPackedHeaderPicture ||
+ encode->last_packed_header_type == VAEncPackedHeaderSlice ||
(((encode->last_packed_header_type & VAEncPackedHeaderMiscMask) == VAEncPackedHeaderMiscMask) &&
- ((encode->last_packed_header_type & (~VAEncPackedHeaderMiscMask)) != 0)));
- vaStatus = i965_encoder_render_packed_header_data_buffer(ctx,
+ ((encode->last_packed_header_type & (~VAEncPackedHeaderMiscMask)) != 0)),
+ VA_STATUS_ERROR_ENCODING_ERROR);
+ vaStatus = i965_encoder_render_packed_header_data_buffer(ctx,
obj_context,
obj_buffer,
va_enc_packed_type_to_idx(encode->last_packed_header_type));
+ }
+ encode->last_packed_header_type = 0;
break;
}
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i;
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
for (i = 0; i < num_buffers && vaStatus == VA_STATUS_SUCCESS; i++) {
struct object_buffer *obj_buffer = BUFFER(buffers[i]);
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
obj_context = CONTEXT(context);
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
if (num_buffers <= 0)
return VA_STATUS_ERROR_INVALID_PARAMETER;
obj_config = obj_context->obj_config;
- assert(obj_config);
+ ASSERT_RET(obj_config, VA_STATUS_ERROR_INVALID_CONFIG);
if (VAEntrypointVideoProc == obj_config->entrypoint) {
vaStatus = i965_proc_render_picture(ctx, context, buffers, num_buffers);
struct object_context *obj_context = CONTEXT(context);
struct object_config *obj_config;
- assert(obj_context);
-
- if (!obj_context)
- return VA_STATUS_ERROR_INVALID_CONTEXT;
-
+ ASSERT_RET(obj_context, VA_STATUS_ERROR_INVALID_CONTEXT);
obj_config = obj_context->obj_config;
- assert(obj_config);
+ ASSERT_RET(obj_config, VA_STATUS_ERROR_INVALID_CONFIG);
if (obj_context->codec_type == CODEC_PROC) {
- assert(VAEntrypointVideoProc == obj_config->entrypoint);
+ ASSERT_RET(VAEntrypointVideoProc == obj_config->entrypoint, VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT);
} else if (obj_context->codec_type == CODEC_ENC) {
- assert(VAEntrypointEncSlice == obj_config->entrypoint);
+ ASSERT_RET(VAEntrypointEncSlice == obj_config->entrypoint, VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT);
+ if (obj_context->codec_state.encode.num_packed_header_params_ext !=
+ obj_context->codec_state.encode.num_packed_header_data_ext) {
+ WARN_ONCE("the packed header/data is not paired for encoding!\n");
+ return VA_STATUS_ERROR_INVALID_PARAMETER;
+ }
if (!(obj_context->codec_state.encode.pic_param ||
obj_context->codec_state.encode.pic_param_ext)) {
return VA_STATUS_ERROR_INVALID_PARAMETER;
(obj_context->codec_state.encode.num_slice_params_ext <=0)) {
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
+
+ if ((obj_context->codec_state.encode.packed_header_flag & VA_ENC_PACKED_HEADER_SLICE) &&
+ (obj_context->codec_state.encode.num_slice_params_ext !=
+ obj_context->codec_state.encode.slice_index)) {
+ WARN_ONCE("packed slice_header data is missing for some slice"
+ " under packed SLICE_HEADER mode\n");
+ return VA_STATUS_ERROR_INVALID_PARAMETER;
+ }
} else {
if (obj_context->codec_state.decode.pic_param == NULL) {
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
}
- assert(obj_context->hw_context->run);
+ ASSERT_RET(obj_context->hw_context->run, VA_STATUS_ERROR_OPERATION_FAILED);
return obj_context->hw_context->run(ctx, obj_config->profile, &obj_context->codec_state, obj_context->hw_context);
}
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_surface *obj_surface = SURFACE(render_target);
- assert(obj_surface);
+ ASSERT_RET(obj_surface, VA_STATUS_ERROR_INVALID_SURFACE);
if(obj_surface->bo)
drm_intel_bo_wait_rendering(obj_surface->bo);
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_surface *obj_surface = SURFACE(render_target);
- assert(obj_surface);
+ ASSERT_RET(obj_surface, VA_STATUS_ERROR_INVALID_SURFACE);
if (obj_surface->bo) {
if (drm_intel_bo_busy(obj_surface->bo)){
);
i965->rotation_attrib = get_display_attribute(ctx, VADisplayAttribRotation);
- if (!i965->rotation_attrib) {
+ i965->brightness_attrib = get_display_attribute(ctx, VADisplayAttribBrightness);
+ i965->contrast_attrib = get_display_attribute(ctx, VADisplayAttribContrast);
+ i965->hue_attrib = get_display_attribute(ctx, VADisplayAttribHue);
+ i965->saturation_attrib = get_display_attribute(ctx, VADisplayAttribSaturation);
+
+ if (!i965->rotation_attrib ||
+ !i965->brightness_attrib ||
+ !i965->contrast_attrib ||
+ !i965->hue_attrib ||
+ !i965->saturation_attrib) {
goto error;
}
return true;
struct object_image *obj_image;
VAStatus va_status = VA_STATUS_ERROR_OPERATION_FAILED;
VAImageID image_id;
- unsigned int width2, height2, size2, size;
+ unsigned int size2, size, awidth, aheight;
out_image->image_id = VA_INVALID_ID;
out_image->buf = VA_INVALID_ID;
image->image_id = image_id;
image->buf = VA_INVALID_ID;
- size = width * height;
- width2 = (width + 1) / 2;
- height2 = (height + 1) / 2;
- size2 = width2 * height2;
+ awidth = ALIGN(width, i965->codec_info->min_linear_wpitch);
+
+ if ((format->fourcc == VA_FOURCC_YV12) ||
+ (format->fourcc == VA_FOURCC_I420)) {
+ if (awidth % 128 != 0) {
+ awidth = ALIGN(width, 128);
+ }
+ }
+
+ aheight = ALIGN(height, i965->codec_info->min_linear_hpitch);
+ size = awidth * aheight;
+ size2 = (awidth / 2) * (aheight / 2);
image->num_palette_entries = 0;
image->entry_bytes = 0;
memset(image->component_order, 0, sizeof(image->component_order));
switch (format->fourcc) {
- case VA_FOURCC('I','A','4','4'):
- case VA_FOURCC('A','I','4','4'):
+ case VA_FOURCC_IA44:
+ case VA_FOURCC_AI44:
image->num_planes = 1;
- image->pitches[0] = width;
+ image->pitches[0] = awidth;
image->offsets[0] = 0;
- image->data_size = image->offsets[0] + image->pitches[0] * height;
+ image->data_size = image->offsets[0] + image->pitches[0] * aheight;
image->num_palette_entries = 16;
image->entry_bytes = 3;
image->component_order[0] = 'R';
image->component_order[1] = 'G';
image->component_order[2] = 'B';
break;
- case VA_FOURCC('I','A','8','8'):
- case VA_FOURCC('A','I','8','8'):
+ case VA_FOURCC_IA88:
+ case VA_FOURCC_AI88:
image->num_planes = 1;
- image->pitches[0] = width * 2;
+ image->pitches[0] = awidth * 2;
image->offsets[0] = 0;
- image->data_size = image->offsets[0] + image->pitches[0] * height;
+ image->data_size = image->offsets[0] + image->pitches[0] * aheight;
image->num_palette_entries = 256;
image->entry_bytes = 3;
image->component_order[0] = 'R';
image->component_order[1] = 'G';
image->component_order[2] = 'B';
break;
- case VA_FOURCC('A','R','G','B'):
- case VA_FOURCC('A','B','G','R'):
- case VA_FOURCC('B','G','R','A'):
- case VA_FOURCC('R','G','B','A'):
- case VA_FOURCC('B','G','R','X'):
- case VA_FOURCC('R','G','B','X'):
+ case VA_FOURCC_ARGB:
+ case VA_FOURCC_ABGR:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_RGBA:
+ case VA_FOURCC_BGRX:
+ case VA_FOURCC_RGBX:
image->num_planes = 1;
- image->pitches[0] = width * 4;
+ image->pitches[0] = awidth * 4;
image->offsets[0] = 0;
- image->data_size = image->offsets[0] + image->pitches[0] * height;
+ image->data_size = image->offsets[0] + image->pitches[0] * aheight;
break;
- case VA_FOURCC('Y','V','1','2'):
+ case VA_FOURCC_YV12:
image->num_planes = 3;
- image->pitches[0] = width;
+ image->pitches[0] = awidth;
image->offsets[0] = 0;
- image->pitches[1] = width2;
- image->offsets[1] = size + size2;
- image->pitches[2] = width2;
- image->offsets[2] = size;
+ image->pitches[1] = awidth / 2;
+ image->offsets[1] = size;
+ image->pitches[2] = awidth / 2;
+ image->offsets[2] = size + size2;
image->data_size = size + 2 * size2;
break;
- case VA_FOURCC('I','4','2','0'):
+ case VA_FOURCC_I420:
image->num_planes = 3;
- image->pitches[0] = width;
+ image->pitches[0] = awidth;
image->offsets[0] = 0;
- image->pitches[1] = width2;
+ image->pitches[1] = awidth / 2;
image->offsets[1] = size;
- image->pitches[2] = width2;
+ image->pitches[2] = awidth / 2;
image->offsets[2] = size + size2;
image->data_size = size + 2 * size2;
break;
- case VA_FOURCC('N','V','1','2'):
+ case VA_FOURCC_422H:
+ image->num_planes = 3;
+ image->pitches[0] = awidth;
+ image->offsets[0] = 0;
+ image->pitches[1] = awidth / 2;
+ image->offsets[1] = size;
+ image->pitches[2] = awidth / 2;
+ image->offsets[2] = size + (awidth / 2) * aheight;
+ image->data_size = size + 2 * ((awidth / 2) * aheight);
+ break;
+ case VA_FOURCC_NV12:
image->num_planes = 2;
- image->pitches[0] = width;
+ image->pitches[0] = awidth;
image->offsets[0] = 0;
- image->pitches[1] = width;
+ image->pitches[1] = awidth;
image->offsets[1] = size;
image->data_size = size + 2 * size2;
break;
- case VA_FOURCC('Y','U','Y','2'):
- case VA_FOURCC('U','Y','V','Y'):
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_UYVY:
image->num_planes = 1;
- image->pitches[0] = width * 2;
+ image->pitches[0] = awidth * 2;
image->offsets[0] = 0;
image->data_size = size * 2;
break;
return va_status;
}
-void
+VAStatus
i965_check_alloc_surface_bo(VADriverContextP ctx,
struct object_surface *obj_surface,
int tiled,
int region_width, region_height;
if (obj_surface->bo) {
- assert(obj_surface->fourcc);
- assert(obj_surface->fourcc == fourcc);
- assert(obj_surface->subsampling == subsampling);
- return;
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(obj_surface->fourcc == fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(obj_surface->subsampling == subsampling, VA_STATUS_ERROR_INVALID_SURFACE);
+ return VA_STATUS_SUCCESS;
}
obj_surface->x_cb_offset = 0; /* X offset is always 0 */
obj_surface->x_cr_offset = 0;
- if (tiled) {
- assert(fourcc != VA_FOURCC('I', '4', '2', '0') &&
- fourcc != VA_FOURCC('I', 'Y', 'U', 'V') &&
- fourcc != VA_FOURCC('Y', 'V', '1', '2'));
+ if ((tiled && !obj_surface->user_disable_tiling)) {
+ ASSERT_RET(fourcc != VA_FOURCC_I420 &&
+ fourcc != VA_FOURCC_IYUV &&
+ fourcc != VA_FOURCC_YV12,
+ VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
+ if (obj_surface->user_h_stride_set) {
+ ASSERT_RET(IS_ALIGNED(obj_surface->width, 128), VA_STATUS_ERROR_INVALID_PARAMETER);
+ } else
+ obj_surface->width = ALIGN(obj_surface->orig_width, 128);
+
+ if (obj_surface->user_v_stride_set) {
+ ASSERT_RET(IS_ALIGNED(obj_surface->height, 32), VA_STATUS_ERROR_INVALID_PARAMETER);
+ } else
+ obj_surface->height = ALIGN(obj_surface->orig_height, 32);
- obj_surface->width = ALIGN(obj_surface->orig_width, 128);
- obj_surface->height = ALIGN(obj_surface->orig_height, 32);
region_height = obj_surface->height;
switch (fourcc) {
- case VA_FOURCC('N', 'V', '1', '2'):
+ case VA_FOURCC_NV12:
assert(subsampling == SUBSAMPLE_YUV420);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
break;
- case VA_FOURCC('I', 'M', 'C', '1'):
+ case VA_FOURCC_IMC1:
assert(subsampling == SUBSAMPLE_YUV420);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
break;
- case VA_FOURCC('I', 'M', 'C', '3'):
+ case VA_FOURCC_IMC3:
assert(subsampling == SUBSAMPLE_YUV420);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
break;
- case VA_FOURCC('4', '2', '2', 'H'):
+ case VA_FOURCC_422H:
assert(subsampling == SUBSAMPLE_YUV422H);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
break;
- case VA_FOURCC('4', '2', '2', 'V'):
+ case VA_FOURCC_422V:
assert(subsampling == SUBSAMPLE_YUV422V);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width;
break;
- case VA_FOURCC('4', '1', '1', 'P'):
+ case VA_FOURCC_411P:
assert(subsampling == SUBSAMPLE_YUV411);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 4;
break;
- case VA_FOURCC('4', '4', '4', 'P'):
+ case VA_FOURCC_444P:
assert(subsampling == SUBSAMPLE_YUV444);
obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width;
break;
- case VA_FOURCC('Y', '8', '0', '0'):
+ case VA_FOURCC_Y800:
assert(subsampling == SUBSAMPLE_YUV400);
- obj_surface->cb_cr_pitch = obj_surface->width;
+ obj_surface->cb_cr_pitch = 0;
obj_surface->cb_cr_width = 0;
obj_surface->cb_cr_height = 0;
- obj_surface->y_cb_offset = obj_surface->height;
- obj_surface->y_cr_offset = obj_surface->y_cb_offset + ALIGN(obj_surface->cb_cr_height, 32);
+ obj_surface->y_cb_offset = 0;
+ obj_surface->y_cr_offset = 0;
region_width = obj_surface->width;
- region_height = obj_surface->height + ALIGN(obj_surface->cb_cr_height, 32) * 2;
+ region_height = obj_surface->height;
break;
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('U', 'Y', 'V', 'Y'):
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_UYVY:
assert(subsampling == SUBSAMPLE_YUV422H);
- obj_surface->cb_cr_pitch = obj_surface->width * 2;
+ obj_surface->width = ALIGN(obj_surface->orig_width * 2, 128);
+ obj_surface->cb_cr_pitch = obj_surface->width;
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height / 2;
- region_width = obj_surface->width * 2;
+ region_width = obj_surface->width;
region_height = obj_surface->height;
break;
- case VA_FOURCC('R', 'G', 'B', 'A'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
+ case VA_FOURCC_RGBA:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
assert(subsampling == SUBSAMPLE_RGBX);
- region_width = obj_surface->width * 4;
+ obj_surface->width = ALIGN(obj_surface->orig_width * 4, 128);
+ region_width = obj_surface->width;
region_height = obj_surface->height;
break;
default:
/* Never get here */
- assert(0);
+ ASSERT_RET(0, VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
break;
}
} else {
region_height = obj_surface->height;
switch (fourcc) {
- case VA_FOURCC('N', 'V', '1', '2'):
+ case VA_FOURCC_NV12:
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset = obj_surface->height;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
region_height = obj_surface->height + obj_surface->height / 2;
break;
- case VA_FOURCC('Y', 'V', '1', '2'):
- case VA_FOURCC('I', '4', '2', '0'):
- if (fourcc == VA_FOURCC('Y', 'V', '1', '2')) {
+ case VA_FOURCC_YV16:
+ obj_surface->cb_cr_width = obj_surface->orig_width / 2;
+ obj_surface->cb_cr_height = obj_surface->orig_height;
+ obj_surface->y_cr_offset = obj_surface->height;
+ obj_surface->y_cb_offset = obj_surface->y_cr_offset + ALIGN(obj_surface->cb_cr_height, 32) / 2;
+ obj_surface->cb_cr_pitch = obj_surface->width / 2;
+ region_height = obj_surface->height + ALIGN(obj_surface->cb_cr_height, 32);
+ break;
+
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_I420:
+ if (fourcc == VA_FOURCC_YV12) {
obj_surface->y_cr_offset = obj_surface->height;
obj_surface->y_cb_offset = obj_surface->height + obj_surface->height / 4;
} else {
region_height = obj_surface->height + obj_surface->height / 2;
break;
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('U', 'Y', 'V', 'Y'):
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_UYVY:
+ obj_surface->width = ALIGN(obj_surface->orig_width * 2, i965->codec_info->min_linear_wpitch);
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height;
- obj_surface->cb_cr_pitch = obj_surface->width * 2;
- region_width = obj_surface->width * 2;
+ obj_surface->cb_cr_pitch = obj_surface->width;
+ region_width = obj_surface->width;
region_height = obj_surface->height;
break;
- case VA_FOURCC('R', 'G', 'B', 'A'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
- region_width = obj_surface->width * 4;
+ case VA_FOURCC_RGBA:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
+ obj_surface->width = ALIGN(obj_surface->orig_width * 4, i965->codec_info->min_linear_wpitch);
+ region_width = obj_surface->width;
region_height = obj_surface->height;
break;
default:
/* Never get here */
- assert(0);
+ ASSERT_RET(0, VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT);
break;
}
}
obj_surface->size = ALIGN(region_width * region_height, 0x1000);
- if (tiled) {
+ if ((tiled && !obj_surface->user_disable_tiling)) {
uint32_t tiling_mode = I915_TILING_Y; /* always uses Y-tiled format */
unsigned long pitch;
&pitch,
0);
assert(tiling_mode == I915_TILING_Y);
- assert(pitch == obj_surface->width ||
- pitch == obj_surface->width * 2 ||
- pitch == obj_surface->width * 4) ;
+ assert(pitch == obj_surface->width);
} else {
obj_surface->bo = dri_bo_alloc(i965->intel.bufmgr,
"vaapi surface",
obj_surface->fourcc = fourcc;
obj_surface->subsampling = subsampling;
assert(obj_surface->bo);
+ return VA_STATUS_SUCCESS;
}
VAStatus i965_DeriveImage(VADriverContextP ctx,
if (!obj_surface->bo) {
unsigned int is_tiled = 0;
- unsigned int fourcc = VA_FOURCC('Y', 'V', '1', '2');
+ unsigned int fourcc = VA_FOURCC_YV12;
i965_guess_surface_format(ctx, surface, &fourcc, &is_tiled);
int sampling = get_sampling_from_fourcc(fourcc);
- i965_check_alloc_surface_bo(ctx, obj_surface, is_tiled, fourcc, sampling);
+ va_status = i965_check_alloc_surface_bo(ctx, obj_surface, is_tiled, fourcc, sampling);
+ if (va_status != VA_STATUS_SUCCESS)
+ return va_status;
}
- assert(obj_surface->fourcc);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
w_pitch = obj_surface->width;
image->format.bits_per_pixel = 12;
switch (image->format.fourcc) {
- case VA_FOURCC('Y', 'V', '1', '2'):
+ case VA_FOURCC_YV12:
image->num_planes = 3;
image->pitches[0] = w_pitch; /* Y */
image->offsets[0] = 0;
image->offsets[2] = w_pitch * obj_surface->y_cb_offset;
break;
- case VA_FOURCC('N', 'V', '1', '2'):
+ case VA_FOURCC_YV16:
+ image->num_planes = 3;
+ image->pitches[0] = w_pitch; /* Y */
+ image->offsets[0] = 0;
+ image->pitches[1] = obj_surface->cb_cr_pitch; /* V */
+ image->offsets[1] = w_pitch * obj_surface->y_cr_offset;
+ image->pitches[2] = obj_surface->cb_cr_pitch; /* U */
+ image->offsets[2] = w_pitch * obj_surface->y_cb_offset;
+ break;
+
+ case VA_FOURCC_NV12:
image->num_planes = 2;
image->pitches[0] = w_pitch; /* Y */
image->offsets[0] = 0;
image->offsets[1] = w_pitch * obj_surface->y_cb_offset;
break;
- case VA_FOURCC('I', '4', '2', '0'):
+ case VA_FOURCC_I420:
+ case VA_FOURCC_422H:
+ case VA_FOURCC_IMC3:
+ case VA_FOURCC_444P:
+ case VA_FOURCC_422V:
+ case VA_FOURCC_411P:
image->num_planes = 3;
image->pitches[0] = w_pitch; /* Y */
image->offsets[0] = 0;
image->pitches[2] = obj_surface->cb_cr_pitch; /* V */
image->offsets[2] = w_pitch * obj_surface->y_cr_offset;
break;
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('U', 'Y', 'V', 'Y'):
+
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_UYVY:
+ case VA_FOURCC_Y800:
image->num_planes = 1;
- image->pitches[0] = obj_surface->width * 2; /* Y, width is aligned already */
+ image->pitches[0] = obj_surface->width; /* Y, width is aligned already */
image->offsets[0] = 0;
break;
- case VA_FOURCC('R', 'G', 'B', 'A'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
+ case VA_FOURCC_RGBA:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
image->num_planes = 1;
- image->pitches[0] = obj_surface->width * 4;
+ image->pitches[0] = obj_surface->width;
break;
default:
goto error;
static int
get_sampling_from_fourcc(unsigned int fourcc)
{
- int surface_sampling = -1;
-
- switch (fourcc) {
- case VA_FOURCC('N', 'V', '1', '2'):
- case VA_FOURCC('Y', 'V', '1', '2'):
- case VA_FOURCC('I', '4', '2', '0'):
- case VA_FOURCC('I', 'Y', 'U', 'V'):
- case VA_FOURCC('I', 'M', 'C', '1'):
- case VA_FOURCC('I', 'M', 'C', '3'):
- surface_sampling = SUBSAMPLE_YUV420;
- break;
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('U', 'Y', 'V', 'Y'):
- case VA_FOURCC('4', '2', '2', 'H'):
- surface_sampling = SUBSAMPLE_YUV422H;
- break;
- case VA_FOURCC('4', '2', '2', 'V'):
- surface_sampling = SUBSAMPLE_YUV422V;
- break;
-
- case VA_FOURCC('4', '4', '4', 'P'):
- surface_sampling = SUBSAMPLE_YUV444;
- break;
-
- case VA_FOURCC('4', '1', '1', 'P'):
- surface_sampling = SUBSAMPLE_YUV411;
- break;
-
- case VA_FOURCC('Y', '8', '0', '0'):
- surface_sampling = SUBSAMPLE_YUV400;
- break;
- case VA_FOURCC('R','G','B','A'):
- case VA_FOURCC('R','G','B','X'):
- case VA_FOURCC('B','G','R','A'):
- case VA_FOURCC('B','G','R','X'):
- surface_sampling = SUBSAMPLE_RGBX;
- break;
- default:
- /* Never get here */
- assert(0);
- break;
-
- }
+ const i965_fourcc_info *info = get_fourcc_info(fourcc);
- return surface_sampling;
+ if (info && (info->flag & I_S))
+ return info->subsampling;
+ else
+ return -1;
}
static inline void
}
}
-static void
+static VAStatus
get_image_i420(struct object_image *obj_image, uint8_t *image_data,
struct object_surface *obj_surface,
const VARectangle *rect)
const int U = obj_image->image.format.fourcc == obj_surface->fourcc ? 1 : 2;
const int V = obj_image->image.format.fourcc == obj_surface->fourcc ? 2 : 1;
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
if (!obj_surface->bo)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
- assert(obj_surface->fourcc);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
if (tiling != I915_TILING_NONE)
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Dest VA image has either I420 or YV12 format.
Source VA surface alway has I420 format */
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
-static void
+static VAStatus
get_image_nv12(struct object_image *obj_image, uint8_t *image_data,
struct object_surface *obj_surface,
const VARectangle *rect)
{
uint8_t *dst[2], *src[2];
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
if (!obj_surface->bo)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
assert(obj_surface->fourcc);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Both dest VA image and source surface have NV12 format */
dst[0] = image_data + obj_image->image.offsets[0];
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
-static void
+static VAStatus
get_image_yuy2(struct object_image *obj_image, uint8_t *image_data,
struct object_surface *obj_surface,
const VARectangle *rect)
{
uint8_t *dst, *src;
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
if (!obj_surface->bo)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
assert(obj_surface->fourcc);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Both dest VA image and source surface have YUYV format */
dst = image_data + obj_image->image.offsets[0];
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
static VAStatus
{
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct i965_render_state *render_state = &i965->render_state;
+ VAStatus va_status = VA_STATUS_SUCCESS;
struct object_surface *obj_surface = SURFACE(surface);
if (!obj_surface)
if (obj_surface->fourcc != obj_image->image.format.fourcc)
return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
- VAStatus va_status;
void *image_data = NULL;
va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data);
rect.height = height;
switch (obj_image->image.format.fourcc) {
- case VA_FOURCC('Y','V','1','2'):
- case VA_FOURCC('I','4','2','0'):
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_I420:
/* I420 is native format for MPEG-2 decoded surfaces */
if (render_state->interleaved_uv)
goto operation_failed;
get_image_i420(obj_image, image_data, obj_surface, &rect);
break;
- case VA_FOURCC('N','V','1','2'):
+ case VA_FOURCC_NV12:
/* NV12 is native format for H.264 decoded surfaces */
if (!render_state->interleaved_uv)
goto operation_failed;
get_image_nv12(obj_image, image_data, obj_surface, &rect);
break;
- case VA_FOURCC('Y','U','Y','2'):
+ case VA_FOURCC_YUY2:
/* YUY2 is the format supported by overlay plane */
get_image_yuy2(obj_image, image_data, obj_surface, &rect);
break;
break;
}
- i965_UnmapBuffer(ctx, obj_image->image.buf);
+ if (va_status != VA_STATUS_SUCCESS)
+ return va_status;
+
+ va_status = i965_UnmapBuffer(ctx, obj_image->image.buf);
return va_status;
}
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct i965_surface src_surface;
struct i965_surface dst_surface;
- VAStatus va_status;
+ VAStatus va_status = VA_STATUS_SUCCESS;
VARectangle rect;
struct object_surface *obj_surface = SURFACE(surface);
struct object_image *obj_image = IMAGE(image);
VAImageID image)
{
struct i965_driver_data * const i965 = i965_driver_data(ctx);
- VAStatus va_status;
+ VAStatus va_status = VA_STATUS_SUCCESS;
if (HAS_ACCELERATED_GETIMAGE(i965))
va_status = i965_hw_getimage(ctx,
return va_status;
}
-static void
+static VAStatus
put_image_i420(struct object_surface *obj_surface,
const VARectangle *dst_rect,
struct object_image *obj_image, uint8_t *image_data,
const int U = obj_image->image.format.fourcc == obj_surface->fourcc ? 1 : 2;
const int V = obj_image->image.format.fourcc == obj_surface->fourcc ? 2 : 1;
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
- if (!obj_surface->bo)
- return;
+ ASSERT_RET(obj_surface->bo, VA_STATUS_ERROR_INVALID_SURFACE);
- assert(obj_surface->fourcc);
- assert(dst_rect->width == src_rect->width);
- assert(dst_rect->height == src_rect->height);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(dst_rect->width == src_rect->width, VA_STATUS_ERROR_UNIMPLEMENTED);
+ ASSERT_RET(dst_rect->height == src_rect->height, VA_STATUS_ERROR_UNIMPLEMENTED);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
if (tiling != I915_TILING_NONE)
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Dest VA image has either I420 or YV12 format.
Source VA surface alway has I420 format */
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
-static void
+static VAStatus
put_image_nv12(struct object_surface *obj_surface,
const VARectangle *dst_rect,
struct object_image *obj_image, uint8_t *image_data,
{
uint8_t *dst[2], *src[2];
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
if (!obj_surface->bo)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
- assert(obj_surface->fourcc);
- assert(dst_rect->width == src_rect->width);
- assert(dst_rect->height == src_rect->height);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(dst_rect->width == src_rect->width, VA_STATUS_ERROR_UNIMPLEMENTED);
+ ASSERT_RET(dst_rect->height == src_rect->height, VA_STATUS_ERROR_UNIMPLEMENTED);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
if (tiling != I915_TILING_NONE)
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Both dest VA image and source surface have NV12 format */
dst[0] = (uint8_t *)obj_surface->bo->virtual;
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
-static void
+static VAStatus
put_image_yuy2(struct object_surface *obj_surface,
const VARectangle *dst_rect,
struct object_image *obj_image, uint8_t *image_data,
{
uint8_t *dst, *src;
unsigned int tiling, swizzle;
+ VAStatus va_status = VA_STATUS_SUCCESS;
- if (!obj_surface->bo)
- return;
-
- assert(obj_surface->fourcc);
- assert(dst_rect->width == src_rect->width);
- assert(dst_rect->height == src_rect->height);
+ ASSERT_RET(obj_surface->bo, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(dst_rect->width == src_rect->width, VA_STATUS_ERROR_UNIMPLEMENTED);
+ ASSERT_RET(dst_rect->height == src_rect->height, VA_STATUS_ERROR_UNIMPLEMENTED);
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
if (tiling != I915_TILING_NONE)
dri_bo_map(obj_surface->bo, 0);
if (!obj_surface->bo->virtual)
- return;
+ return VA_STATUS_ERROR_INVALID_SURFACE;
/* Both dest VA image and source surface have YUY2 format */
dst = (uint8_t *)obj_surface->bo->virtual;
drm_intel_gem_bo_unmap_gtt(obj_surface->bo);
else
dri_bo_unmap(obj_surface->bo);
+
+ return va_status;
}
{
struct i965_driver_data *i965 = i965_driver_data(ctx);
struct object_surface *obj_surface = SURFACE(surface);
-
- if (!obj_surface)
- return VA_STATUS_ERROR_INVALID_SURFACE;
-
struct object_image *obj_image = IMAGE(image);
- if (!obj_image)
- return VA_STATUS_ERROR_INVALID_IMAGE;
+ VAStatus va_status = VA_STATUS_SUCCESS;
+ void *image_data = NULL;
+
+ ASSERT_RET(obj_surface, VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(obj_image, VA_STATUS_ERROR_INVALID_IMAGE);
if (src_x < 0 || src_y < 0)
return VA_STATUS_ERROR_INVALID_PARAMETER;
else {
/* VA is surface not used for decoding, use same VA image format */
- i965_check_alloc_surface_bo(
+ va_status = i965_check_alloc_surface_bo(
ctx,
obj_surface,
0, /* XXX: don't use tiled surface */
get_sampling_from_fourcc (obj_image->image.format.fourcc));
}
- VAStatus va_status;
- void *image_data = NULL;
+ if (va_status != VA_STATUS_SUCCESS)
+ return va_status;
va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data);
if (va_status != VA_STATUS_SUCCESS)
dest_rect.height = dest_height;
switch (obj_image->image.format.fourcc) {
- case VA_FOURCC('Y','V','1','2'):
- case VA_FOURCC('I','4','2','0'):
- put_image_i420(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_I420:
+ va_status = put_image_i420(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
break;
- case VA_FOURCC('N','V','1','2'):
- put_image_nv12(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
+ case VA_FOURCC_NV12:
+ va_status = put_image_nv12(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
break;
- case VA_FOURCC('Y','U','Y','2'):
- put_image_yuy2(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
+ case VA_FOURCC_YUY2:
+ va_status = put_image_yuy2(obj_surface, &dest_rect, obj_image, image_data, &src_rect);
break;
default:
va_status = VA_STATUS_ERROR_OPERATION_FAILED;
break;
}
+ if (va_status != VA_STATUS_SUCCESS)
+ return va_status;
- i965_UnmapBuffer(ctx, obj_image->image.buf);
+ va_status = i965_UnmapBuffer(ctx, obj_image->image.buf);
return va_status;
}
VAStatus va_status = VA_STATUS_SUCCESS;
VARectangle src_rect, dst_rect;
- if (!obj_surface)
- return VA_STATUS_ERROR_INVALID_SURFACE;
-
- if (!obj_image || !obj_image->bo)
- return VA_STATUS_ERROR_INVALID_IMAGE;
+ ASSERT_RET(obj_surface,VA_STATUS_ERROR_INVALID_SURFACE);
+ ASSERT_RET(obj_image && obj_image->bo, VA_STATUS_ERROR_INVALID_IMAGE);
if (src_x < 0 ||
src_y < 0 ||
surface_sampling);
}
- assert(obj_surface->fourcc);
+ ASSERT_RET(obj_surface->fourcc, VA_STATUS_ERROR_INVALID_SURFACE);
src_surface.base = (struct object_base *)obj_image;
src_surface.type = I965_SURFACE_TYPE_IMAGE;
i965 = i965_driver_data(ctx);
obj_buffer = BUFFER(buf_id);
- assert(obj_buffer);
-
- if (!obj_buffer)
- return VA_STATUS_ERROR_INVALID_BUFFER;
+ ASSERT_RET(obj_buffer, VA_STATUS_ERROR_INVALID_BUFFER);
*type = obj_buffer->type;
*size = obj_buffer->size_element;
struct object_surface *obj_surface = NULL;
VAImage tmpImage;
- assert(fourcc);
- assert(luma_stride);
- assert(chroma_u_stride);
- assert(chroma_v_stride);
- assert(luma_offset);
- assert(chroma_u_offset);
- assert(chroma_v_offset);
- assert(buffer_name);
- assert(buffer);
+ ASSERT_RET(fourcc, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(luma_stride, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(chroma_u_stride, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(chroma_v_stride, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(luma_offset, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(chroma_u_offset, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(chroma_v_offset, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(buffer_name, VA_STATUS_ERROR_INVALID_PARAMETER);
+ ASSERT_RET(buffer, VA_STATUS_ERROR_INVALID_PARAMETER);
tmpImage.image_id = VA_INVALID_ID;
attrib_list[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
if (attrib_list[i].value.value.i == 0) {
- if (IS_G4X(i965->intel.device_id)) {
+ if (IS_G4X(i965->intel.device_info)) {
if (obj_config->profile == VAProfileMPEG2Simple ||
obj_config->profile == VAProfileMPEG2Main) {
- attrib_list[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attrib_list[i].value.value.i = VA_FOURCC_I420;
} else {
assert(0);
attrib_list[i].flags = VA_SURFACE_ATTRIB_NOT_SUPPORTED;
}
- } else if (IS_IRONLAKE(i965->intel.device_id)) {
+ } else if (IS_IRONLAKE(i965->intel.device_info)) {
if (obj_config->profile == VAProfileMPEG2Simple ||
obj_config->profile == VAProfileMPEG2Main) {
- attrib_list[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
- } else if (obj_config->profile == VAProfileH264Baseline ||
+ attrib_list[i].value.value.i = VA_FOURCC_I420;
+ } else if (obj_config->profile == VAProfileH264ConstrainedBaseline ||
obj_config->profile == VAProfileH264Main ||
obj_config->profile == VAProfileH264High) {
- attrib_list[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attrib_list[i].value.value.i = VA_FOURCC_NV12;
} else if (obj_config->profile == VAProfileNone) {
- attrib_list[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attrib_list[i].value.value.i = VA_FOURCC_NV12;
} else {
assert(0);
attrib_list[i].flags = VA_SURFACE_ATTRIB_NOT_SUPPORTED;
}
- } else if (IS_GEN6(i965->intel.device_id)) {
- attrib_list[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
- } else if (IS_GEN7(i965->intel.device_id)) {
+ } else if (IS_GEN6(i965->intel.device_info)) {
+ attrib_list[i].value.value.i = VA_FOURCC_NV12;
+ } else if (IS_GEN7(i965->intel.device_info) ||
+ IS_GEN8(i965->intel.device_info)) {
if (obj_config->profile == VAProfileJPEGBaseline)
attrib_list[i].value.value.i = 0; /* internal format */
else
- attrib_list[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attrib_list[i].value.value.i = VA_FOURCC_NV12;
}
} else {
- if (IS_G4X(i965->intel.device_id)) {
+ if (IS_G4X(i965->intel.device_info)) {
if (obj_config->profile == VAProfileMPEG2Simple ||
obj_config->profile == VAProfileMPEG2Main) {
- if (attrib_list[i].value.value.i != VA_FOURCC('I', '4', '2', '0')) {
+ if (attrib_list[i].value.value.i != VA_FOURCC_I420) {
attrib_list[i].value.value.i = 0;
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
}
assert(0);
attrib_list[i].flags = VA_SURFACE_ATTRIB_NOT_SUPPORTED;
}
- } else if (IS_IRONLAKE(i965->intel.device_id)) {
+ } else if (IS_IRONLAKE(i965->intel.device_info)) {
if (obj_config->profile == VAProfileMPEG2Simple ||
obj_config->profile == VAProfileMPEG2Main) {
- if (attrib_list[i].value.value.i != VA_FOURCC('I', '4', '2', '0')) {
+ if (attrib_list[i].value.value.i != VA_FOURCC_I420) {
attrib_list[i].value.value.i = 0;
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
}
- } else if (obj_config->profile == VAProfileH264Baseline ||
+ } else if (obj_config->profile == VAProfileH264ConstrainedBaseline ||
obj_config->profile == VAProfileH264Main ||
obj_config->profile == VAProfileH264High) {
- if (attrib_list[i].value.value.i != VA_FOURCC('N', 'V', '1', '2')) {
+ if (attrib_list[i].value.value.i != VA_FOURCC_NV12) {
attrib_list[i].value.value.i = 0;
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
}
} else if (obj_config->profile == VAProfileNone) {
switch (attrib_list[i].value.value.i) {
- case VA_FOURCC('N', 'V', '1', '2'):
- case VA_FOURCC('I', '4', '2', '0'):
- case VA_FOURCC('Y', 'V', '1', '2'):
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('R', 'G', 'B', 'A'):
+ case VA_FOURCC_NV12:
+ case VA_FOURCC_I420:
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_RGBA:
break;
default:
attrib_list[i].value.value.i = 0;
assert(0);
attrib_list[i].flags = VA_SURFACE_ATTRIB_NOT_SUPPORTED;
}
- } else if (IS_GEN6(i965->intel.device_id)) {
+ } else if (IS_GEN6(i965->intel.device_info)) {
if (obj_config->entrypoint == VAEntrypointEncSlice ||
obj_config->entrypoint == VAEntrypointVideoProc) {
switch (attrib_list[i].value.value.i) {
- case VA_FOURCC('N', 'V', '1', '2'):
- case VA_FOURCC('I', '4', '2', '0'):
- case VA_FOURCC('Y', 'V', '1', '2'):
- case VA_FOURCC('Y', 'U', 'Y', '2'):
- case VA_FOURCC('B', 'G', 'R', 'A'):
- case VA_FOURCC('B', 'G', 'R', 'X'):
- case VA_FOURCC('R', 'G', 'B', 'X'):
- case VA_FOURCC('R', 'G', 'B', 'A'):
+ case VA_FOURCC_NV12:
+ case VA_FOURCC_I420:
+ case VA_FOURCC_YV12:
+ case VA_FOURCC_YUY2:
+ case VA_FOURCC_BGRA:
+ case VA_FOURCC_BGRX:
+ case VA_FOURCC_RGBX:
+ case VA_FOURCC_RGBA:
break;
default:
attrib_list[i].value.value.i = 0;
break;
}
} else {
- if (attrib_list[i].value.value.i != VA_FOURCC('N', 'V', '1', '2')) {
+ if (attrib_list[i].value.value.i != VA_FOURCC_NV12) {
attrib_list[i].value.value.i = 0;
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
}
}
- } else if (IS_GEN7(i965->intel.device_id)) {
+ } else if (IS_GEN7(i965->intel.device_info) ||
+ IS_GEN8(i965->intel.device_info)) {
if (obj_config->entrypoint == VAEntrypointEncSlice ||
obj_config->entrypoint == VAEntrypointVideoProc) {
switch (attrib_list[i].value.value.i) {
- case VA_FOURCC('N', 'V', '1', '2'):
- case VA_FOURCC('I', '4', '2', '0'):
- case VA_FOURCC('Y', 'V', '1', '2'):
+ case VA_FOURCC_NV12:
+ case VA_FOURCC_I420:
+ case VA_FOURCC_YV12:
break;
default:
attrib_list[i].value.value.i = 0;
attrib_list[i].value.value.i = 0; /* JPEG decoding always uses an internal format */
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
} else {
- if (attrib_list[i].value.value.i != VA_FOURCC('N', 'V', '1', '2')) {
+ if (attrib_list[i].value.value.i != VA_FOURCC_NV12) {
attrib_list[i].value.value.i = 0;
attrib_list[i].flags &= ~VA_SURFACE_ATTRIB_SETTABLE;
}
if (attribs == NULL)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
- if (IS_G4X(i965->intel.device_id)) {
+ if (IS_G4X(i965->intel.device_info)) {
if (obj_config->profile == VAProfileMPEG2Simple ||
obj_config->profile == VAProfileMPEG2Main) {
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attribs[i].value.value.i = VA_FOURCC_I420;
i++;
}
- } else if (IS_IRONLAKE(i965->intel.device_id)) {
+ } else if (IS_IRONLAKE(i965->intel.device_info)) {
switch (obj_config->profile) {
case VAProfileMPEG2Simple:
case VAProfileMPEG2Main:
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attribs[i].value.value.i = VA_FOURCC_I420;
i++;
break;
- case VAProfileH264Baseline:
+ case VAProfileH264ConstrainedBaseline:
case VAProfileH264Main:
case VAProfileH264High:
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
case VAProfileNone:
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attribs[i].value.value.i = VA_FOURCC_I420;
i++;
break;
default:
break;
}
- } else if (IS_GEN6(i965->intel.device_id)) {
+ } else if (IS_GEN6(i965->intel.device_info)) {
if (obj_config->entrypoint == VAEntrypointVLD) { /* decode */
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
} else if (obj_config->entrypoint == VAEntrypointEncSlice || /* encode */
obj_config->entrypoint == VAEntrypointVideoProc) { /* vpp */
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attribs[i].value.value.i = VA_FOURCC_I420;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('Y', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_YV12;
i++;
if (obj_config->entrypoint == VAEntrypointVideoProc) {
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('Y', 'U', 'Y', '2');
+ attribs[i].value.value.i = VA_FOURCC_YUY2;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('R', 'G', 'B', 'A');
+ attribs[i].value.value.i = VA_FOURCC_RGBA;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('R', 'G', 'B', 'X');
+ attribs[i].value.value.i = VA_FOURCC_RGBX;
i++;
}
}
- } else if (IS_GEN7(i965->intel.device_id)) {
+ } else if (IS_GEN7(i965->intel.device_info)) {
if (obj_config->entrypoint == VAEntrypointVLD) { /* decode */
if (obj_config->profile == VAProfileJPEGBaseline) {
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', 'M', 'C', '3');
+ attribs[i].value.value.i = VA_FOURCC_IMC3;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', 'M', 'C', '1');
+ attribs[i].value.value.i = VA_FOURCC_IMC1;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('Y', '8', '0', '0');
+ attribs[i].value.value.i = VA_FOURCC_Y800;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('4', '1', '1', 'P');
+ attribs[i].value.value.i = VA_FOURCC_411P;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('4', '2', '2', 'H');
+ attribs[i].value.value.i = VA_FOURCC_422H;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('4', '2', '2', 'V');
+ attribs[i].value.value.i = VA_FOURCC_422V;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('4', '4', '4', 'P');
+ attribs[i].value.value.i = VA_FOURCC_444P;
i++;
} else {
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
}
} else if (obj_config->entrypoint == VAEntrypointEncSlice || /* encode */
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('N', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_NV12;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_I420;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_YV12;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_IMC3;
+ i++;
+
+ if (obj_config->entrypoint == VAEntrypointVideoProc) {
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_YUY2;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_RGBA;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_RGBX;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_YV16;
+ i++;
+ }
+ }
+ } else if (IS_GEN8(i965->intel.device_info)) {
+ if (obj_config->entrypoint == VAEntrypointVLD) { /* decode */
+ if (obj_config->profile == VAProfileJPEGBaseline) {
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_IMC3;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_IMC1;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_Y800;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_411P;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_422H;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_422V;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_444P;
+ i++;
+ } else {
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_NV12;
+ i++;
+ }
+ } else if (obj_config->entrypoint == VAEntrypointEncSlice || /* encode */
+ obj_config->entrypoint == VAEntrypointVideoProc) { /* vpp */
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_NV12;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', '4', '2', '0');
+ attribs[i].value.value.i = VA_FOURCC_I420;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('Y', 'V', '1', '2');
+ attribs[i].value.value.i = VA_FOURCC_YV12;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('I', 'M', 'C', '3');
+ attribs[i].value.value.i = VA_FOURCC_IMC3;
i++;
if (obj_config->entrypoint == VAEntrypointVideoProc) {
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('Y', 'U', 'Y', '2');
+ attribs[i].value.value.i = VA_FOURCC_YUY2;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_RGBA;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_RGBX;
+ i++;
+
+ attribs[i].type = VASurfaceAttribPixelFormat;
+ attribs[i].value.type = VAGenericValueTypeInteger;
+ attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
+ attribs[i].value.value.i = VA_FOURCC_BGRA;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('R', 'G', 'B', 'A');
+ attribs[i].value.value.i = VA_FOURCC_BGRX;
i++;
attribs[i].type = VASurfaceAttribPixelFormat;
attribs[i].value.type = VAGenericValueTypeInteger;
attribs[i].flags = VA_SURFACE_ATTRIB_GETTABLE | VA_SURFACE_ATTRIB_SETTABLE;
- attribs[i].value.value.i = VA_FOURCC('R', 'G', 'B', 'X');
+ attribs[i].value.value.i = VA_FOURCC_YV16;
i++;
}
}
return vaStatus;
}
+/* Acquires buffer handle for external API usage (internal implementation) */
+static VAStatus
+i965_acquire_buffer_handle(struct object_buffer *obj_buffer,
+ uint32_t mem_type, VABufferInfo *out_buf_info)
+{
+ struct buffer_store *buffer_store;
+
+ buffer_store = obj_buffer->buffer_store;
+ if (!buffer_store || !buffer_store->bo)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+
+ /* Synchronization point */
+ drm_intel_bo_wait_rendering(buffer_store->bo);
+
+ if (obj_buffer->export_refcount > 0) {
+ if (obj_buffer->export_state.mem_type != mem_type)
+ return VA_STATUS_ERROR_INVALID_PARAMETER;
+ }
+ else {
+ VABufferInfo * const buf_info = &obj_buffer->export_state;
+
+ switch (mem_type) {
+ case VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM: {
+ uint32_t name;
+ if (drm_intel_bo_flink(buffer_store->bo, &name) != 0)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+ buf_info->handle = name;
+ break;
+ }
+ case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME: {
+ int fd;
+ if (drm_intel_bo_gem_export_to_prime(buffer_store->bo, &fd) != 0)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+ buf_info->handle = (intptr_t)fd;
+ break;
+ }
+ }
+
+ buf_info->type = obj_buffer->type;
+ buf_info->mem_type = mem_type;
+ buf_info->mem_size =
+ obj_buffer->num_elements * obj_buffer->size_element;
+ }
+
+ obj_buffer->export_refcount++;
+ *out_buf_info = obj_buffer->export_state;
+ return VA_STATUS_SUCCESS;
+}
+
+/* Releases buffer handle after usage (internal implementation) */
+static VAStatus
+i965_release_buffer_handle(struct object_buffer *obj_buffer)
+{
+ if (obj_buffer->export_refcount == 0)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+
+ if (--obj_buffer->export_refcount == 0) {
+ VABufferInfo * const buf_info = &obj_buffer->export_state;
+
+ switch (buf_info->mem_type) {
+ case VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME: {
+ close((intptr_t)buf_info->handle);
+ break;
+ }
+ }
+ buf_info->mem_type = 0;
+ }
+ return VA_STATUS_SUCCESS;
+}
+
+/** Acquires buffer handle for external API usage */
+static VAStatus
+i965_AcquireBufferHandle(VADriverContextP ctx, VABufferID buf_id,
+ VABufferInfo *buf_info)
+{
+ struct i965_driver_data * const i965 = i965_driver_data(ctx);
+ struct object_buffer * const obj_buffer = BUFFER(buf_id);
+ uint32_t i, mem_type;
+
+ /* List of supported memory types, in preferred order */
+ static const uint32_t mem_types[] = {
+ VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
+ VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM,
+ 0
+ };
+
+ if (!obj_buffer)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+ /* XXX: only VA surface|image like buffers are supported for now */
+ if (obj_buffer->type != VAImageBufferType)
+ return VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+
+ if (!buf_info)
+ return VA_STATUS_ERROR_INVALID_PARAMETER;
+
+ if (!buf_info->mem_type)
+ mem_type = mem_types[0];
+ else {
+ mem_type = 0;
+ for (i = 0; mem_types[i] != 0; i++) {
+ if (buf_info->mem_type & mem_types[i]) {
+ mem_type = buf_info->mem_type;
+ break;
+ }
+ }
+ if (!mem_type)
+ return VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE;
+ }
+ return i965_acquire_buffer_handle(obj_buffer, mem_type, buf_info);
+}
+
+/** Releases buffer handle after usage from external API */
+static VAStatus
+i965_ReleaseBufferHandle(VADriverContextP ctx, VABufferID buf_id)
+{
+ struct i965_driver_data * const i965 = i965_driver_data(ctx);
+ struct object_buffer * const obj_buffer = BUFFER(buf_id);
+
+ if (!obj_buffer)
+ return VA_STATUS_ERROR_INVALID_BUFFER;
+
+ return i965_release_buffer_handle(obj_buffer);
+}
+
static int
i965_os_has_ring_support(VADriverContextP ctx,
int ring)
} else if (base->type == VAProcFilterDeinterlacing) {
VAProcFilterParameterBufferDeinterlacing *deint = (VAProcFilterParameterBufferDeinterlacing *)base;
- assert(deint->algorithm == VAProcDeinterlacingBob ||
+ ASSERT_RET(deint->algorithm == VAProcDeinterlacingBob ||
deint->algorithm == VAProcDeinterlacingMotionAdaptive ||
- deint->algorithm == VAProcDeinterlacingMotionCompensated);
+ deint->algorithm == VAProcDeinterlacingMotionCompensated,
+ VA_STATUS_ERROR_INVALID_PARAMETER);
if (deint->algorithm == VAProcDeinterlacingMotionAdaptive ||
deint->algorithm == VAProcDeinterlacingMotionCompensated);
pipeline_cap->num_forward_references++;
+ } else if (base->type == VAProcFilterSkinToneEnhancement) {
+ VAProcFilterParameterBuffer *stde = (VAProcFilterParameterBuffer *)base;
+ (void)stde;
}
}
return VA_STATUS_SUCCESS;
}
+extern struct hw_codec_info *i965_get_codec_info(int devid);
+
static bool
i965_driver_data_init(VADriverContextP ctx)
{
struct i965_driver_data *i965 = i965_driver_data(ctx);
- if (IS_HASWELL(i965->intel.device_id))
- i965->codec_info = &gen75_hw_codec_info;
- else if (IS_G4X(i965->intel.device_id))
- i965->codec_info = &g4x_hw_codec_info;
- else if (IS_IRONLAKE(i965->intel.device_id))
- i965->codec_info = &ironlake_hw_codec_info;
- else if (IS_GEN6(i965->intel.device_id))
- i965->codec_info = &gen6_hw_codec_info;
- else if (IS_GEN7(i965->intel.device_id))
- i965->codec_info = &gen7_hw_codec_info;
- else
+ i965->codec_info = i965_get_codec_info(i965->intel.device_id);
+
+ if (!i965->codec_info)
return false;
if (object_heap_init(&i965->config_heap,
{
struct i965_driver_data *i965 = i965_driver_data(ctx);
int i;
+ const char *chipset;
for (i = 0; i < ARRAY_ELEMS(i965_sub_ops); i++) {
if ((i965_sub_ops[i].display_type == 0 ||
break;
}
+ if (i965->codec_info->preinit_hw_codec)
+ i965->codec_info->preinit_hw_codec(ctx, i965->codec_info);
+
if (i == ARRAY_ELEMS(i965_sub_ops)) {
- sprintf(i965->va_vendor, "%s %s driver - %d.%d.%d",
+ switch (i965->intel.device_id) {
+#undef CHIPSET
+#define CHIPSET(id, family, dev, str) case id: chipset = str; break;
+#include "i965_pciids.h"
+ default:
+ chipset = "Unknown Intel Chipset";
+ break;
+ }
+
+ sprintf(i965->va_vendor, "%s %s driver for %s - %d.%d.%d",
INTEL_STR_DRIVER_VENDOR,
INTEL_STR_DRIVER_NAME,
+ chipset,
INTEL_DRIVER_MAJOR_VERSION,
INTEL_DRIVER_MINOR_VERSION,
INTEL_DRIVER_MICRO_VERSION);
vtable->vaTerminate = i965_Terminate;
vtable->vaQueryConfigEntrypoints = i965_QueryConfigEntrypoints;
vtable->vaQueryConfigProfiles = i965_QueryConfigProfiles;
- vtable->vaQueryConfigEntrypoints = i965_QueryConfigEntrypoints;
vtable->vaQueryConfigAttributes = i965_QueryConfigAttributes;
vtable->vaCreateConfig = i965_CreateConfig;
vtable->vaDestroyConfig = i965_DestroyConfig;
vtable->vaQuerySurfaceAttributes = i965_QuerySurfaceAttributes;
vtable->vaCreateSurfaces2 = i965_CreateSurfaces2;
+ /* 0.36.0 */
+ vtable->vaAcquireBufferHandle = i965_AcquireBufferHandle;
+ vtable->vaReleaseBufferHandle = i965_ReleaseBufferHandle;
+
vtable_vpp->vaQueryVideoProcFilters = i965_QueryVideoProcFilters;
vtable_vpp->vaQueryVideoProcFilterCaps = i965_QueryVideoProcFilterCaps;
vtable_vpp->vaQueryVideoProcPipelineCaps = i965_QueryVideoProcPipelineCaps;
projects / platform / upstream / libva-intel-driver.git / blobdiff