#include "va_dec_vp8.h"
#include "va_dec_vp9.h"
#include "va_dec_hevc.h"
+#include "va_str.h"
#include "va_vpp.h"
#include <assert.h>
#include <stdarg.h>
/* global settings */
/* LIBVA_TRACE */
-int trace_flag = 0;
+int va_trace_flag = 0;
#define MAX_TRACE_CTX_NUM 64
#define TRACE_CTX_ID_MASK (MAX_TRACE_CTX_NUM - 1)
struct va_trace *pva_trace,
VAConfigID config_id)
{
- struct trace_config_info *pconfig_info;
int idx = MAX_TRACE_CTX_NUM;
LOCK_RESOURCE(pva_trace);
- pconfig_info = pva_trace->config_info;
- idx = config_id & TRACE_CTX_ID_MASK;
- if(!pconfig_info[idx].valid
- || pconfig_info[idx].config_id != config_id)
- idx = MAX_TRACE_CTX_NUM;
+ for (idx = 0;idx < MAX_TRACE_CTX_NUM;idx++) {
+ if (pva_trace->config_info[idx].valid &&
+ pva_trace->config_info[idx].config_id == config_id)
+ break;
+ }
UNLOCK_RESOURCE(pva_trace);
LOCK_RESOURCE(pva_trace);
- idx = config_id & TRACE_CTX_ID_MASK;
- pconfig_info = &pva_trace->config_info[idx];
- if(!pconfig_info->valid ||
- pconfig_info->config_id == config_id) {
+ for (idx = 0;idx < MAX_TRACE_CTX_NUM;idx++) {
+ if (!pva_trace->config_info[idx].valid ||
+ pva_trace->config_info[idx].config_id == config_id)
+ break;
+ }
+
+ if (idx < MAX_TRACE_CTX_NUM) {
+ pconfig_info = &pva_trace->config_info[idx];
+
pconfig_info->valid = 1;
pconfig_info->config_id = config_id;
pconfig_info->trace_profile = profile;
{
struct trace_config_info *pconfig_info;
int idx = 0;
- pid_t thd_id = syscall(__NR_gettid);
LOCK_RESOURCE(pva_trace);
- idx = config_id & TRACE_CTX_ID_MASK;
- pconfig_info = &pva_trace->config_info[idx];
- if(pconfig_info->valid &&
- pconfig_info->config_id == config_id &&
- pconfig_info->created_thd_id == thd_id) {
+ for (idx = 0;idx < MAX_TRACE_CTX_NUM;idx++) {
+ if (pva_trace->config_info[idx].valid &&
+ pva_trace->config_info[idx].config_id == config_id)
+ break;
+ }
+
+ if (idx < MAX_TRACE_CTX_NUM) {
+ pconfig_info = &pva_trace->config_info[idx];
+
pconfig_info->valid = 0;
+ pconfig_info->config_id = -1;
}
UNLOCK_RESOURCE(pva_trace);
struct va_trace *pva_trace,
VAContextID context)
{
- int idx = MAX_TRACE_CTX_NUM;
- int i = 0;
+ int idx;
LOCK_RESOURCE(pva_trace);
- i = context & TRACE_CTX_ID_MASK;
- if(!pva_trace->ptra_ctx[i]
- || pva_trace->ptra_ctx[i]->trace_context == context)
- idx = i;
+ for (idx = 0;idx < MAX_TRACE_CTX_NUM;idx++)
+ if (!pva_trace->ptra_ctx[idx] ||
+ pva_trace->ptra_ctx[idx]->trace_context == context)
+ break;
UNLOCK_RESOURCE(pva_trace);
struct va_trace *pva_trace,
VAContextID context)
{
- int idx = MAX_TRACE_CTX_NUM;
- int i = 0;
+ int idx;
LOCK_RESOURCE(pva_trace);
- i = context & TRACE_CTX_ID_MASK;
- if(pva_trace->ptra_ctx[i]
- && pva_trace->ptra_ctx[i]->trace_context == context)
- idx = i;
+ for (idx = 0;idx < MAX_TRACE_CTX_NUM;idx++)
+ if (pva_trace->ptra_ctx[idx] &&
+ pva_trace->ptra_ctx[idx]->trace_context == context)
+ break;
UNLOCK_RESOURCE(pva_trace);
if(type == 0) {
ptra_ctx->trace_codedbuf_fn = fn_env;
ptra_ctx->trace_fp_codedbuf = fp;
- va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save codedbuf into %s\n",
+ va_infoMessage(pva_trace->dpy, "LIBVA_TRACE_CODEDBUF is on, save codedbuf into %s\n",
fn_env);
}
else {
ptra_ctx->trace_surface_fn = fn_env;
ptra_ctx->trace_fp_surface = fp;
- va_infoMessage("LIBVA_TRACE_SURFACE is on, save surface into %s\n",
+ va_infoMessage(pva_trace->dpy, "LIBVA_TRACE_SURFACE is on, save surface into %s\n",
fn_env);
}
if(!pfp)
goto FAIL;
- va_infoMessage("%s %s for the thread 0x%08x\n",
+ va_infoMessage(pva_trace->dpy, "%s %s for the thread 0x%08x\n",
new_fn_flag ? "Open new log file" : "Append to log file",
plog_file->fn_log, thd_id);
return;
}
+ pva_trace->dpy = dpy;
+
+ pthread_mutex_init(&pva_trace->resource_mutex, NULL);
+ pthread_mutex_init(&pva_trace->context_mutex, NULL);
+
if (va_parseConfig("LIBVA_TRACE", &env_value[0]) == 0) {
pva_trace->fn_log_env = strdup(env_value);
trace_ctx->plog_file = start_tracing2log_file(pva_trace);
if(trace_ctx->plog_file) {
trace_ctx->plog_file_list[0] = trace_ctx->plog_file;
- trace_flag = VA_TRACE_FLAG_LOG;
+ va_trace_flag = VA_TRACE_FLAG_LOG;
- va_infoMessage("LIBVA_TRACE is on, save log into %s\n",
+ va_infoMessage(dpy, "LIBVA_TRACE is on, save log into %s\n",
trace_ctx->plog_file->fn_log);
}
else
- va_errorMessage("Open file %s failed (%s)\n", env_value, strerror(errno));
+ va_errorMessage(dpy, "Open file %s failed (%s)\n", env_value, strerror(errno));
}
/* may re-get the global settings for multiple context */
- if ((trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
- trace_flag |= VA_TRACE_FLAG_BUFDATA;
+ if ((va_trace_flag & VA_TRACE_FLAG_LOG) && (va_parseConfig("LIBVA_TRACE_BUFDATA", NULL) == 0)) {
+ va_trace_flag |= VA_TRACE_FLAG_BUFDATA;
va_infoMessage(dpy, "LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
}
/* per-context setting */
if (va_parseConfig("LIBVA_TRACE_CODEDBUF", &env_value[0]) == 0) {
pva_trace->fn_codedbuf_env = strdup(env_value);
- trace_flag |= VA_TRACE_FLAG_CODEDBUF;
+ va_trace_flag |= VA_TRACE_FLAG_CODEDBUF;
}
if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) {
* if no dec/enc in file name, set both
*/
if (strstr(env_value, "dec"))
- trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
+ va_trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE;
if (strstr(env_value, "enc"))
- trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
+ va_trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE;
if (strstr(env_value, "jpeg") || strstr(env_value, "jpg"))
- trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
+ va_trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG;
if (va_parseConfig("LIBVA_TRACE_SURFACE_GEOMETRY", &env_value[0]) == 0) {
char *p = env_value, *q;
}
}
- pthread_mutex_init(&pva_trace->resource_mutex, NULL);
- pthread_mutex_init(&pva_trace->context_mutex, NULL);
-
trace_ctx->trace_context = VA_INVALID_ID;
pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM] = trace_ctx;
((VADisplayContextP)dpy)->vatrace = (void *)pva_trace;
- pva_trace->dpy = dpy;
- if(!trace_flag)
+ if(!va_trace_flag)
va_TraceEnd(dpy);
}
}
free(pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM]);
+ pva_trace->dpy = NULL;
free(pva_trace);
((VADisplayContextP)dpy)->vatrace = NULL;
}
{
FILE *fp = NULL;
- if (!(trace_flag & VA_TRACE_FLAG_LOG)
+ if (!(va_trace_flag & VA_TRACE_FLAG_LOG)
|| !trace_ctx->plog_file)
return;
trace_ctx->trace_profile = pva_trace->config_info[i].trace_profile;
trace_ctx->trace_entrypoint = pva_trace->config_info[i].trace_entrypoint;
- if(trace_flag & VA_TRACE_FLAG_LOG) {
+ if(va_trace_flag & VA_TRACE_FLAG_LOG) {
trace_ctx->plog_file = start_tracing2log_file(pva_trace);
if(!trace_ctx->plog_file) {
va_errorMessage(dpy, "Can't get trace log file for ctx 0x%08x\n",
trace_ctx->trace_context = *context;
TRACE_FUNCNAME(idx);
- va_TraceMsg(trace_ctx, "\tcontext = 0x%08x trace_flag 0x%x\n", *context, trace_flag);
+ va_TraceMsg(trace_ctx, "\tcontext = 0x%08x va_trace_flag 0x%x\n", *context, va_trace_flag);
va_TraceMsg(trace_ctx, "\tprofile = %d entrypoint = %d\n", trace_ctx->trace_profile,
trace_ctx->trace_entrypoint);
va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config_id);
encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice);
decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD);
jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
- if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
- (decode && (trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
- (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
+ if ((encode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE)) ||
+ (decode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_DECODE)) ||
+ (jpeg && (va_trace_flag & VA_TRACE_FLAG_SURFACE_JPEG))) {
if(open_tracing_specil_file(pva_trace, trace_ctx, 1) < 0) {
va_errorMessage(dpy, "Open surface fail failed for ctx 0x%08x\n", *context);
- trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
+ va_trace_flag &= ~(VA_TRACE_FLAG_SURFACE);
}
}
- if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
+ if (encode && (va_trace_flag & VA_TRACE_FLAG_CODEDBUF)) {
if(open_tracing_specil_file(pva_trace, trace_ctx, 0) < 0) {
va_errorMessage(dpy, "Open codedbuf fail failed for ctx 0x%08x\n", *context);
- trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF);
+ va_trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF);
}
}
UNLOCK_CONTEXT(pva_trace);
}
-static char * buffer_type_to_string(int type)
+void va_TraceCreateMFContext (
+ VADisplay dpy,
+ VAMFContextID *mf_context /* out */
+)
{
- switch (type) {
- case VAPictureParameterBufferType: return "VAPictureParameterBufferType";
- case VAIQMatrixBufferType: return "VAIQMatrixBufferType";
- case VABitPlaneBufferType: return "VABitPlaneBufferType";
- case VASliceGroupMapBufferType: return "VASliceGroupMapBufferType";
- case VASliceParameterBufferType: return "VASliceParameterBufferType";
- case VASliceDataBufferType: return "VASliceDataBufferType";
- case VAProtectedSliceDataBufferType: return "VAProtectedSliceDataBufferType";
- case VAMacroblockParameterBufferType: return "VAMacroblockParameterBufferType";
- case VAResidualDataBufferType: return "VAResidualDataBufferType";
- case VADeblockingParameterBufferType: return "VADeblockingParameterBufferType";
- case VAImageBufferType: return "VAImageBufferType";
- case VAQMatrixBufferType: return "VAQMatrixBufferType";
- case VAHuffmanTableBufferType: return "VAHuffmanTableBufferType";
-/* Following are encode buffer types */
- case VAEncCodedBufferType: return "VAEncCodedBufferType";
- case VAEncSequenceParameterBufferType: return "VAEncSequenceParameterBufferType";
- case VAEncPictureParameterBufferType: return "VAEncPictureParameterBufferType";
- case VAEncSliceParameterBufferType: return "VAEncSliceParameterBufferType";
- case VAEncPackedHeaderParameterBufferType: return "VAEncPackedHeaderParameterBufferType";
- case VAEncPackedHeaderDataBufferType: return "VAEncPackedHeaderDataBufferType";
- case VAEncMiscParameterBufferType: return "VAEncMiscParameterBufferType";
- case VAEncMacroblockParameterBufferType: return "VAEncMacroblockParameterBufferType";
- case VAProcPipelineParameterBufferType: return "VAProcPipelineParameterBufferType";
- case VAProcFilterParameterBufferType: return "VAProcFilterParameterBufferType";
- default: return "UnknowBuffer";
+ DPY2TRACECTX(dpy, VA_INVALID_ID, VA_INVALID_ID);
+ TRACE_FUNCNAME(idx);
+ if (mf_context) {
+ va_TraceMsg(trace_ctx, "\tmf_context = 0x%08x\n", *mf_context);
+ trace_ctx->trace_context = *mf_context;
+ } else
+ trace_ctx->trace_context = VA_INVALID_ID;
+}
+
+void va_TraceMFAddContext (
+ VADisplay dpy,
+ VAMFContextID mf_context,
+ VAContextID context
+)
+{
+ DPY2TRACECTX(dpy, mf_context, VA_INVALID_ID);
+
+ TRACE_FUNCNAME(idx);
+ va_TraceMsg(trace_ctx, "\tmf_context = 0x%08x\n", mf_context);
+ va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
+}
+
+void va_TraceMFReleaseContext (
+ VADisplay dpy,
+ VAMFContextID mf_context,
+ VAContextID context
+)
+{
+ DPY2TRACECTX(dpy, mf_context, VA_INVALID_ID);
+
+ TRACE_FUNCNAME(idx);
+ va_TraceMsg(trace_ctx, "\tmf_context = 0x%08x\n", mf_context);
+ va_TraceMsg(trace_ctx, "\tcontext = 0x%08x\n", context);
+}
+
+void va_TraceMFSubmit (
+ VADisplay dpy,
+ VAMFContextID mf_context,
+ VAContextID *contexts,
+ int num_contexts
+)
+{
+ int i;
+
+ DPY2TRACECTX(dpy, mf_context, VA_INVALID_ID);
+
+ TRACE_FUNCNAME(idx);
+ va_TraceMsg(trace_ctx, "\tmf_context = 0x%08x\n", mf_context);
+
+ for(i = 0; i < num_contexts; i++){
+ va_TraceMsg(trace_ctx, "\t\tcontext[%d] = 0x%08x\n", i, contexts[i]);
}
}
return;
TRACE_FUNCNAME(idx);
- va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
+ va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", vaBufferTypeStr(type));
if (buf_id)
va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", *buf_id);
va_TraceMsg(trace_ctx, "\tsize=%u\n", size);
return;
TRACE_FUNCNAME(idx);
- va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
+ va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", vaBufferTypeStr(type));
va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
va_TraceMsg(trace_ctx, "\tsize=%u\n", size);
va_TraceMsg(trace_ctx, "\tnum_elements=%u\n", num_elements);
TRACE_FUNCNAME(idx);
va_TraceMsg(trace_ctx, "\tbuf_id=0x%x\n", buf_id);
- va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", buffer_type_to_string(type));
+ va_TraceMsg(trace_ctx, "\tbuf_type=%s\n", vaBufferTypeStr(type));
if ((pbuf == NULL) || (*pbuf == NULL))
return;
DPY2TRACECTX(dpy, context, VA_INVALID_ID);
- va_TracePrint(trace_ctx, "--%s\n", buffer_type_to_string(type));
+ va_TracePrint(trace_ctx, "--%s\n", vaBufferTypeStr(type));
if(trace_ctx->plog_file)
fp = trace_ctx->plog_file->fp_log;
- if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && fp) {
+ if ((va_trace_flag & VA_TRACE_FLAG_BUFDATA) && fp) {
for (i=0; i<size; i++) {
unsigned char value = p[i];
va_TraceMsg(trace_ctx, "\tmb_adaptive_frame_field_flag = %d\n", p->seq_fields.bits.mb_adaptive_frame_field_flag);
va_TraceMsg(trace_ctx, "\tdirect_8x8_inference_flag = %d\n", p->seq_fields.bits.direct_8x8_inference_flag);
va_TraceMsg(trace_ctx, "\tMinLumaBiPredSize8x8 = %d\n", p->seq_fields.bits.MinLumaBiPredSize8x8);
- va_TraceMsg(trace_ctx, "\tnum_slice_groups_minus1 = %d\n", p->num_slice_groups_minus1);
- va_TraceMsg(trace_ctx, "\tslice_group_map_type = %d\n", p->slice_group_map_type);
- va_TraceMsg(trace_ctx, "\tslice_group_change_rate_minus1 = %d\n", p->slice_group_change_rate_minus1);
va_TraceMsg(trace_ctx, "\tpic_init_qp_minus26 = %d\n", p->pic_init_qp_minus26);
va_TraceMsg(trace_ctx, "\tpic_init_qs_minus26 = %d\n", p->pic_init_qs_minus26);
va_TraceMsg(trace_ctx, "\tchroma_qp_index_offset = %d\n", p->chroma_qp_index_offset);
va_TraceMsg(trace_ctx, "\t---------------------------\n");
va_TraceMsg(trace_ctx, "\tbuffers[%d] = 0x%08x\n", i, buffers[i]);
- va_TraceMsg(trace_ctx, "\t type = %s\n", buffer_type_to_string(type));
+ va_TraceMsg(trace_ctx, "\t type = %s\n", vaBufferTypeStr(type));
va_TraceMsg(trace_ctx, "\t size = %d\n", size);
va_TraceMsg(trace_ctx, "\t num_elements = %d\n", num_elements);
va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j);
}
break;
- case VAProfileH264Baseline:
case VAProfileH264Main:
case VAProfileH264High:
case VAProfileH264ConstrainedBaseline:
jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture);
/* trace encode source surface, can do it before HW completes rendering */
- if ((encode && (trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
- (jpeg && (trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
+ if ((encode && (va_trace_flag & VA_TRACE_FLAG_SURFACE_ENCODE))||
+ (jpeg && (va_trace_flag & VA_TRACE_FLAG_SURFACE_JPEG)))
va_TraceSurface(dpy, context);
/* trace decoded surface, do it after HW completes rendering */
- if (decode && ((trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
+ if (decode && ((va_trace_flag & VA_TRACE_FLAG_SURFACE_DECODE))) {
vaSyncSurface(dpy, trace_ctx->trace_rendertarget);
va_TraceSurface(dpy, context);
}
OSDN Git Service
