514 lines
16 KiB
C
514 lines
16 KiB
C
/*
|
|
* Copyright (c) 2009 Intel Corporation. All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#ifndef VA_TRACE_H
|
|
#define VA_TRACE_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern int va_trace_flag;
|
|
|
|
#define VA_TRACE_FLAG_LOG 0x1
|
|
#define VA_TRACE_FLAG_BUFDATA 0x2
|
|
#define VA_TRACE_FLAG_CODEDBUF 0x4
|
|
#define VA_TRACE_FLAG_SURFACE_DECODE 0x8
|
|
#define VA_TRACE_FLAG_SURFACE_ENCODE 0x10
|
|
#define VA_TRACE_FLAG_SURFACE_JPEG 0x20
|
|
#define VA_TRACE_FLAG_SURFACE (VA_TRACE_FLAG_SURFACE_DECODE | \
|
|
VA_TRACE_FLAG_SURFACE_ENCODE | \
|
|
VA_TRACE_FLAG_SURFACE_JPEG)
|
|
#define VA_TRACE_FLAG_FTRACE 0x40
|
|
#define VA_TRACE_FLAG_FTRACE_BUFDATA (VA_TRACE_FLAG_FTRACE | \
|
|
VA_TRACE_FLAG_BUFDATA)
|
|
|
|
#define VA_TRACE_LOG(trace_func,...) \
|
|
if (va_trace_flag & VA_TRACE_FLAG_LOG) { \
|
|
trace_func(__VA_ARGS__); \
|
|
}
|
|
#define VA_TRACE_ALL(trace_func,...) \
|
|
if (va_trace_flag) { \
|
|
trace_func(__VA_ARGS__); \
|
|
}
|
|
#define VA_TRACE_RET(dpy,ret) \
|
|
if (va_trace_flag){ \
|
|
va_TraceStatus(dpy, __func__, ret); \
|
|
}
|
|
|
|
/** \brief event id definition
|
|
* identifier of trace event, coresponding the task value in the manifest, located in libva-util/tracetool
|
|
* the trace tool will translate this id to event name, also the trace data carried along.
|
|
* Note: make sure event id definition backward compatible */
|
|
enum {
|
|
INVALIDE_ID = 0,
|
|
CREATE_CONFIG = 1,
|
|
DESTROY_CONFIG,
|
|
CREATE_CONTEXT,
|
|
DESTROY_CONTEXT,
|
|
CREATE_BUFFER,
|
|
DESTROY_BUFFER,
|
|
CREATE_SURFACE,
|
|
DESTROY_SURFACE,
|
|
BEGIN_PICTURE,
|
|
RENDER_PICTURE,
|
|
END_PICTURE,
|
|
BUFFER_DATA,
|
|
SYNC_SURFACE,
|
|
SYNC_SURFACE2,
|
|
QUERY_SURFACE_ATTR,
|
|
};
|
|
|
|
/** \brief event opcode definition
|
|
* identifier of trace event operation, coresponding the opcode value in the manifest.
|
|
* 4 predefined opcode */
|
|
#define TRACE_INFO 0
|
|
#define TRACE_BEGIN 1
|
|
#define TRACE_END 2
|
|
#define TRACE_DATA 3
|
|
|
|
/** \brief event data structure
|
|
* structure list to pass event data without copy, each entry contain the event data address and size.
|
|
* va_TraceEvent will write these raw data into ftrace entry */
|
|
typedef struct va_event_data {
|
|
void *buf;
|
|
unsigned int size;
|
|
} VAEventData;
|
|
|
|
|
|
/** \brief VA_TRACE
|
|
* trace interface to send out trace event with empty event data. */
|
|
#define VA_TRACE(dpy,id,op) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
va_TraceEvent(dpy, id, op, 0, NULL); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_V
|
|
* trace interface to send out trace event with 1 data element from variable. the variable data type could be 8/16/32/64 bitsize */
|
|
#define VA_TRACE_V(dpy,id,op,v) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
VAEventData desc[1] = {{&v, sizeof(v)}}; \
|
|
va_TraceEvent(dpy, id, op, 1, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_PV
|
|
* trace interface to send out trace event with 2 data element, from pointer and variable. their data size could be 8/16/32/64 bitsize */
|
|
#define VA_TRACE_PV(dpy,id,op,p,v) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
VAEventData desc[2] = {{p, sizeof(*p)}, \
|
|
{&v, sizeof(v)}}; \
|
|
va_TraceEvent(dpy, id, op, 2, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VV
|
|
* trace interface to send out trace event with 2 data element, both from variable. their data size could be 8/16/32/64 bitsize */
|
|
#define VA_TRACE_VV(dpy,id,op,v1,v2) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
VAEventData desc[2] = {{&v1, sizeof(v1)}, \
|
|
{&v2, sizeof(v2)}}; \
|
|
va_TraceEvent(dpy, id, op, 2, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VVVV
|
|
* trace interface to send out trace event with 4 data element, all from variable. their data size could be 8/16/32/64 bitsize */
|
|
#define VA_TRACE_VVVV(dpy,id,op,v1,v2,v3,v4) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
VAEventData desc[4] = { {&v1, sizeof(v1)}, \
|
|
{&v2, sizeof(v2)}, \
|
|
{&v3, sizeof(v3)}, \
|
|
{&v4, sizeof(v4)}}; \
|
|
va_TraceEvent(dpy, id, op, 4, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VA
|
|
* trace interface to send out trace event with a dynamic length array data element, array length from variable.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_VA(dpy,id,op,n,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = n | sizeof(*a) << 16; \
|
|
VAEventData desc[2] = {{&num, sizeof(num)}, \
|
|
{a, n * sizeof(*a)}}; \
|
|
va_TraceEvent(dpy, id, op, 2, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_PA
|
|
* trace interface to send out trace event with a dynamic length array data element, array length from pointer. need check null before set.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_PA(dpy,id,op,pn,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = sizeof(*a) << 16; \
|
|
VAEventData desc[2] = {{&num, sizeof(num)}, \
|
|
{a, 0}}; \
|
|
if (pn) { \
|
|
num |= *pn; \
|
|
desc[1].size = (*pn) * sizeof(*a); \
|
|
} \
|
|
va_TraceEvent(dpy, id, op, 2, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VVA
|
|
* trace interface to send out trace event with 1 data element and a dynamic length array data element, array length from variable.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_VVA(dpy,id,op,v,n,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = n | (sizeof(*a) << 16); \
|
|
VAEventData desc[3] = {{&v, sizeof(v)}, \
|
|
{&num, sizeof(num)}, \
|
|
{a, n*sizeof(*a)}}; \
|
|
va_TraceEvent(dpy, id, op, 3, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VVVA
|
|
* trace interface to send out trace event with 2 data element and a dynamic length array data element, array length from variable.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_VVVA(dpy,id,op,v1,v2,n,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = n | (sizeof(*a) << 16); \
|
|
VAEventData desc[4] = {{&v1, sizeof(v1)}, \
|
|
{&v2, sizeof(v2)}, \
|
|
{&num, sizeof(num)}, \
|
|
{a, n*sizeof(*a)}}; \
|
|
va_TraceEvent(dpy, id, op, 4, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VVVVA
|
|
* trace interface to send out trace event with 3 data element and a dynamic length array data element, array length from variable.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_VVVVA(dpy,id,op,v1,v2,v3,n,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = n | (sizeof(*a) << 16); \
|
|
VAEventData desc[5] = {{&v1, sizeof(v1)}, \
|
|
{&v2, sizeof(v2)}, \
|
|
{&v3, sizeof(v3)}, \
|
|
{&num, sizeof(num)}, \
|
|
{a, n*sizeof(*a)}}; \
|
|
va_TraceEvent(dpy, id, op, 5, desc); \
|
|
} \
|
|
} while (0)
|
|
/** \brief VA_TRACE_VVVVVA
|
|
* trace interface to send out trace event with 4 data elsement and a dynamic length array data element, array length from variable.
|
|
* high 16bits of array length is used to set bitssize of array element. */
|
|
#define VA_TRACE_VVVVVA(dpy,id,op,v1,v2,v3,v4,n,a) do { \
|
|
if (va_trace_flag & VA_TRACE_FLAG_FTRACE) { \
|
|
int num = n | (sizeof(*a) << 16); \
|
|
VAEventData desc[6] = {{&v1, sizeof(v1)}, \
|
|
{&v2, sizeof(v2)}, \
|
|
{&v3, sizeof(v3)}, \
|
|
{&v4, sizeof(v4)}, \
|
|
{&num, sizeof(num)}, \
|
|
{a, n*sizeof(*a)}}; \
|
|
va_TraceEvent(dpy, id, op, 6, desc); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* add macro interface to support new data type combination */
|
|
|
|
|
|
/** \brief VA_TRACE_BUFFERS
|
|
* trace interface to dump all data in va buffer ids into trace.
|
|
* libva-utils will parse buffer into fields according to buffer type */
|
|
#define VA_TRACE_BUFFERS(dpy,ctx,num,buffers) do { \
|
|
if ((va_trace_flag & VA_TRACE_FLAG_FTRACE_BUFDATA) == VA_TRACE_FLAG_FTRACE_BUFDATA) { \
|
|
va_TraceEventBuffers(dpy, ctx, num, buffers); \
|
|
} \
|
|
} while (0)
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceInit(VADisplay dpy);
|
|
DLL_HIDDEN
|
|
void va_TraceEnd(VADisplay dpy);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceInitialize(
|
|
VADisplay dpy,
|
|
int *major_version, /* out */
|
|
int *minor_version /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceTerminate(
|
|
VADisplay dpy
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceCreateConfig(
|
|
VADisplay dpy,
|
|
VAProfile profile,
|
|
VAEntrypoint entrypoint,
|
|
VAConfigAttrib *attrib_list,
|
|
int num_attribs,
|
|
VAConfigID *config_id /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceDestroyConfig(
|
|
VADisplay dpy,
|
|
VAConfigID config_id
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceCreateSurfaces(
|
|
VADisplay dpy,
|
|
int width,
|
|
int height,
|
|
int format,
|
|
int num_surfaces,
|
|
VASurfaceID *surfaces, /* out */
|
|
VASurfaceAttrib *attrib_list,
|
|
unsigned int num_attribs
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceDestroySurfaces(
|
|
VADisplay dpy,
|
|
VASurfaceID *surface_list,
|
|
int num_surfaces
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceCreateContext(
|
|
VADisplay dpy,
|
|
VAConfigID config_id,
|
|
int picture_width,
|
|
int picture_height,
|
|
int flag,
|
|
VASurfaceID *render_targets,
|
|
int num_render_targets,
|
|
VAContextID *context /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceDestroyContext(
|
|
VADisplay dpy,
|
|
VAContextID context
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceCreateMFContext(
|
|
VADisplay dpy,
|
|
VAContextID *mf_context /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceMFAddContext(
|
|
VADisplay dpy,
|
|
VAMFContextID mf_context,
|
|
VAContextID context
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceMFReleaseContext(
|
|
VADisplay dpy,
|
|
VAMFContextID mf_context,
|
|
VAContextID context
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceMFSubmit(
|
|
VADisplay dpy,
|
|
VAMFContextID mf_context,
|
|
VAContextID *contexts,
|
|
int num_contexts
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceCreateBuffer(
|
|
VADisplay dpy,
|
|
VAContextID context, /* in */
|
|
VABufferType type, /* in */
|
|
unsigned int size, /* in */
|
|
unsigned int num_elements, /* in */
|
|
void *data, /* in */
|
|
VABufferID *buf_id /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceDestroyBuffer(
|
|
VADisplay dpy,
|
|
VABufferID buf_id /* in */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceMapBuffer(
|
|
VADisplay dpy,
|
|
VABufferID buf_id, /* in */
|
|
void **pbuf, /* out */
|
|
uint32_t flags /* in */
|
|
);
|
|
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceBeginPicture(
|
|
VADisplay dpy,
|
|
VAContextID context,
|
|
VASurfaceID render_target
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceRenderPicture(
|
|
VADisplay dpy,
|
|
VAContextID context,
|
|
VABufferID *buffers,
|
|
int num_buffers
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceEndPicture(
|
|
VADisplay dpy,
|
|
VAContextID context,
|
|
int endpic_done
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceEndPictureExt(
|
|
VADisplay dpy,
|
|
VAContextID context,
|
|
int endpic_done
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceSyncSurface(
|
|
VADisplay dpy,
|
|
VASurfaceID render_target
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceSyncSurface2(
|
|
VADisplay dpy,
|
|
VASurfaceID surface,
|
|
uint64_t timeout_ns
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceQuerySurfaceAttributes(
|
|
VADisplay dpy,
|
|
VAConfigID config,
|
|
VASurfaceAttrib *attrib_list,
|
|
unsigned int *num_attribs
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceQuerySurfaceStatus(
|
|
VADisplay dpy,
|
|
VASurfaceID render_target,
|
|
VASurfaceStatus *status /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceQuerySurfaceError(
|
|
VADisplay dpy,
|
|
VASurfaceID surface,
|
|
VAStatus error_status,
|
|
void **error_info /*out*/
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceSyncBuffer(
|
|
VADisplay dpy,
|
|
VABufferID buf_id,
|
|
uint64_t timeout_ns
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceMaxNumDisplayAttributes(
|
|
VADisplay dpy,
|
|
int number
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceQueryDisplayAttributes(
|
|
VADisplay dpy,
|
|
VADisplayAttribute *attr_list, /* out */
|
|
int *num_attributes /* out */
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceGetDisplayAttributes(
|
|
VADisplay dpy,
|
|
VADisplayAttribute *attr_list,
|
|
int num_attributes
|
|
);
|
|
|
|
DLL_HIDDEN
|
|
void va_TraceSetDisplayAttributes(
|
|
VADisplay dpy,
|
|
VADisplayAttribute *attr_list,
|
|
int num_attributes
|
|
);
|
|
|
|
/* extern function called by display side */
|
|
void va_TracePutSurface(
|
|
VADisplay dpy,
|
|
VASurfaceID surface,
|
|
void *draw, /* the target Drawable */
|
|
short srcx,
|
|
short srcy,
|
|
unsigned short srcw,
|
|
unsigned short srch,
|
|
short destx,
|
|
short desty,
|
|
unsigned short destw,
|
|
unsigned short desth,
|
|
VARectangle *cliprects, /* client supplied clip list */
|
|
unsigned int number_cliprects, /* number of clip rects in the clip list */
|
|
unsigned int flags /* de-interlacing flags */
|
|
);
|
|
|
|
void va_TraceStatus(VADisplay dpy, const char * funcName, VAStatus status);
|
|
|
|
/** \brief va_TraceEvent
|
|
* common trace interface to send out trace event with scatterd event data. */
|
|
DLL_HIDDEN
|
|
void va_TraceEvent(
|
|
VADisplay dpy,
|
|
unsigned short id,
|
|
unsigned short opcode,
|
|
unsigned int num,
|
|
VAEventData *desc);
|
|
|
|
/** \brief va_TraceEventBuffers
|
|
* trace buffer interface to send out data in buffers. */
|
|
DLL_HIDDEN
|
|
void va_TraceEventBuffers(
|
|
VADisplay dpy,
|
|
VAContextID context,
|
|
int num_buffers,
|
|
VABufferID *buffers);
|
|
|
|
/** \brief va_TraceExportSurfaceHandle
|
|
* trace exported surface handle. */
|
|
DLL_HIDDEN
|
|
void va_TraceExportSurfaceHandle(
|
|
VADisplay dpy,
|
|
VASurfaceID surfaceId,
|
|
uint32_t memType,
|
|
uint32_t flags,
|
|
void *descriptor);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
#endif /* VA_TRACE_H */
|