#include "va.h"
#include "va_enc_h264.h"
#include "va_backend.h"
+#include "va_internal.h"
#include "va_trace.h"
#include "va_enc_h264.h"
#include "va_enc_jpeg.h"
#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)
pthread_mutex_t resource_mutex;
pthread_mutex_t context_mutex;
+ VADisplay dpy;
};
#define LOCK_RESOURCE(pva_trace) \
va_TraceMsg(trace_ctx, "") ; \
} while (0)
-/* Prototype declarations (functions defined in va.c) */
-
-void va_errorMessage(const char *msg, ...);
-void va_infoMessage(const char *msg, ...);
-
-int va_parseConfig(char *env, char *env_value);
VAStatus vaBufferInfo(
VADisplay dpy,
struct trace_buf_manager *pbuf_mgr = &pva_trace->buf_manager;
struct trace_buf_info *pbuf_info = pbuf_mgr->pbuf_info[0];
VAContextID context = VA_INVALID_ID;
- int i = 0, idx = 0, valid = 0;
+ int i = 0, idx = 0;
LOCK_RESOURCE(pva_trace);
}
if(i >= MAX_TRACE_BUF_INFO_HASH_LEVEL)
- va_errorMessage("Add buf info failed\n");
+ va_errorMessage(pva_trace->dpy, "Add buf info failed\n");
UNLOCK_RESOURCE(pva_trace);
}
int size = 0;
if (suffix_str)
- strlen(suffix_str);
+ size = strlen(suffix_str);
if(left < (size + 8 + 10))
return;
FILE *fp = NULL;
strncpy(env_value, fn_env, 1024);
+ env_value[1023] = '\0';
FILE_NAME_SUFFIX(env_value, 1024,
"ctx-", (unsigned int)ptra_ctx->trace_context);
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);
}
int new_fn_flag = 0;
if(plog_file->used && plog_file->thread_id != thd_id) {
- va_errorMessage("Try to open a busy log file occupied by other thread\n");
+ va_errorMessage(pva_trace->dpy, "Try to open a busy log file occupied by other thread\n");
return -1;
}
char env_value[1024];
strncpy(env_value, pva_trace->fn_log_env, 1024);
+ env_value[1023] = '\0';
FILE_NAME_SUFFIX(env_value, 1024,
"thd-", (unsigned int)thd_id);
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);
void va_TraceInit(VADisplay dpy)
{
char env_value[1024];
- unsigned short suffix = 0xffff & ((unsigned int)time(NULL));
- int trace_index = 0;
- FILE *tmp;
struct va_trace *pva_trace = calloc(sizeof(struct va_trace), 1);
struct trace_context *trace_ctx = calloc(sizeof(struct trace_context), 1);
return;
}
+ pva_trace->dpy = dpy;
+
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("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n");
+ 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;
p = q+1; /* skip "+" */
trace_ctx->trace_surface_yoff = strtod(p, &q);
- va_infoMessage("LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
+ va_infoMessage(dpy, "LIBVA_TRACE_SURFACE_GEOMETRY is on, only dump surface %dx%d+%d+%d content\n",
trace_ctx->trace_surface_width,
trace_ctx->trace_surface_height,
trace_ctx->trace_surface_xoff,
((VADisplayContextP)dpy)->vatrace = (void *)pva_trace;
- if(!trace_flag)
+ if(!va_trace_flag)
va_TraceEnd(dpy);
}
void va_TraceEnd(VADisplay dpy)
{
struct va_trace *pva_trace = NULL;
- int i = 0, j = 0;
+ int i = 0;
pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace);
if(!pva_trace)
}
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;
if(!context
|| *context == VA_INVALID_ID
|| !pva_trace) {
- va_errorMessage("Invalid context id 0x%08x\n",
+ va_errorMessage(dpy, "Invalid context id 0x%08x\n",
context == NULL ? 0 : (int)*context);
return;
}
tra_ctx_id = get_free_ctx_idx(pva_trace, *context);
if(tra_ctx_id >= MAX_TRACE_CTX_NUM) {
- va_errorMessage("Can't get trace context for ctx 0x%08x\n",
+ va_errorMessage(dpy, "Can't get trace context for ctx 0x%08x\n",
*context);
goto FAIL;
trace_ctx = calloc(sizeof(struct trace_context), 1);
if(trace_ctx == NULL) {
- va_errorMessage("Allocate trace context failed for ctx 0x%08x\n",
+ va_errorMessage(dpy, "Allocate trace context failed for ctx 0x%08x\n",
*context);
goto FAIL;
i = get_valid_config_idx(pva_trace, config_id);
if(i >= MAX_TRACE_CTX_NUM) {
- va_errorMessage("Can't get trace config id for ctx 0x%08x cfg %x\n",
+ va_errorMessage(dpy, "Can't get trace config id for ctx 0x%08x cfg %x\n",
*context, config_id);
goto FAIL;
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("Can't get trace log file for ctx 0x%08x\n",
+ va_errorMessage(dpy, "Can't get trace log file for ctx 0x%08x\n",
*context);
goto FAIL;
}
else
- va_infoMessage("Save context 0x%08x into log file %s\n", *context,
+ va_infoMessage(dpy, "Save context 0x%08x into log file %s\n", *context,
trace_ctx->plog_file->fn_log);
trace_ctx->plog_file_list[0] = trace_ctx->plog_file;
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("Open surface fail failed for ctx 0x%08x\n", *context);
+ 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("Open codedbuf fail failed for ctx 0x%08x\n", *context);
+ 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,"*VAHuffmanTableBufferJPEG\n");
for (i = 0; i < 2; ++i) {
- va_TraceMsg(trace_ctx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[0]);
+ va_TraceMsg(trace_ctx,"\tload_huffman_table[%d] =%u\n", i, p->load_huffman_table[i]);
va_TraceMsg(trace_ctx,"\thuffman_table[%d] =\n", i);
memset(tmp, 0, sizeof tmp);
for (j = 0; j < 16; ++j) {
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);
{
VAEncPackedHeaderParameterBuffer* p = (VAEncPackedHeaderParameterBuffer*)data;
DPY2TRACECTX(dpy, context, VA_INVALID_ID);
- int i;
if (!p)
return;
va_TraceMsg(trace_ctx, "\trc_flags.reset = %d \n", p->rc_flags.bits.reset);
va_TraceMsg(trace_ctx, "\trc_flags.disable_frame_skip = %d\n", p->rc_flags.bits.disable_frame_skip);
va_TraceMsg(trace_ctx, "\trc_flags.disable_bit_stuffing = %d\n", p->rc_flags.bits.disable_bit_stuffing);
+ va_TraceMsg(trace_ctx, "\trc_flags.mb_rate_control = %d\n", p->rc_flags.bits.mb_rate_control);
+ va_TraceMsg(trace_ctx, "\trc_flags.temporal_id = %d\n", p->rc_flags.bits.temporal_id);
break;
}
case VAEncMiscParameterTypeMaxSliceSize:
va_TraceMsg(trace_ctx, "\tmax_frame_size = %d\n", p->max_frame_size);
break;
}
+ case VAEncMiscParameterTypeQualityLevel:
+ {
+ VAEncMiscParameterBufferQualityLevel *p = (VAEncMiscParameterBufferQualityLevel *)tmp->data;
+
+ va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterBufferQualityLevel\n");
+ va_TraceMsg(trace_ctx, "\tquality_level = %d\n", p->quality_level);
+ break;
+ }
default:
va_TraceMsg(trace_ctx, "Unknown VAEncMiscParameterBuffer(type = %d):\n", tmp->type);
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, data);
return;
}
+static void va_TraceVAEncSequenceParameterBufferVP9(
+ VADisplay dpy,
+ VAContextID context,
+ VABufferID buffer,
+ VABufferType type,
+ unsigned int size,
+ unsigned int num_elements,
+ void *data)
+{
+ VAEncSequenceParameterBufferVP9 *p = (VAEncSequenceParameterBufferVP9 *)data;
+ DPY2TRACECTX(dpy, context, VA_INVALID_ID);
+
+ va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferVP9\n");
+
+ va_TraceMsg(trace_ctx, "\tmax_frame_height = %d\n", p->max_frame_height);
+ va_TraceMsg(trace_ctx, "\tmax_frame_width = %d\n", p->max_frame_width);
+ va_TraceMsg(trace_ctx, "\tkf_auto = %d\n", p->kf_auto);
+ va_TraceMsg(trace_ctx, "\tkf_min_dist = %d\n", p->kf_min_dist);
+ va_TraceMsg(trace_ctx, "\tkf_max_dist = %d\n", p->kf_max_dist);
+ va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second);
+ va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period);
+
+ va_TraceMsg(trace_ctx, NULL);
+
+ return;
+}
+
static void va_TraceVAPictureParameterBufferVP9(
VADisplay dpy,
VAContextID context,
{
VADecPictureParameterBufferVP9 *p = (VADecPictureParameterBufferVP9 *)data;
DPY2TRACECTX(dpy, context, VA_INVALID_ID);
- int i,j;
+ int i;
va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVP9\n");
return;
}
+static void va_TraceVAEncPictureParameterBufferVP9(
+ VADisplay dpy,
+ VAContextID context,
+ VABufferID buffer,
+ VABufferType type,
+ unsigned int size,
+ unsigned int num_elements,
+ void *data)
+{
+ VAEncPictureParameterBufferVP9 *p = (VAEncPictureParameterBufferVP9 *)data;
+ DPY2TRACECTX(dpy, context, VA_INVALID_ID);
+ int i;
+
+ va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferVP9\n");
+ va_TraceMsg(trace_ctx, "\tframe_width_src = %d\n", p->frame_width_src);
+ va_TraceMsg(trace_ctx, "\tframe_height_src = %d\n", p->frame_height_src);
+ va_TraceMsg(trace_ctx, "\tframe_width_dst = %d\n", p->frame_width_dst);
+ va_TraceMsg(trace_ctx, "\tframe_height_dst = %d\n", p->frame_height_dst);
+ va_TraceMsg(trace_ctx, "\treconstructed_frame = 0x%08x\n", p->reconstructed_frame);
+
+ for(i=0;i<8;i++)
+ va_TraceMsg(trace_ctx, "\treference_frames[%d] = 0x%08x\n", i, p->reference_frames[i]);
+
+ va_TraceMsg(trace_ctx, "\tcoded_buf = 0x%x\n", p->coded_buf);
+
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.force_kf = %d\n", p->ref_flags.bits.force_kf);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_frame_ctrl_l0 = %d\n", p->ref_flags.bits.ref_frame_ctrl_l0);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_frame_ctrl_l1 = %d\n", p->ref_flags.bits.ref_frame_ctrl_l1);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_last_idx = %d\n", p->ref_flags.bits.ref_last_idx);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_last_sign_bias = %d\n", p->ref_flags.bits.ref_last_sign_bias);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_gf_idx = %d\n", p->ref_flags.bits.ref_gf_idx);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_gf_sign_bias = %d\n", p->ref_flags.bits.ref_gf_sign_bias);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_arf_idx = %d\n", p->ref_flags.bits.ref_arf_idx);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.ref_arf_sign_bias = %d\n", p->ref_flags.bits.ref_arf_sign_bias);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.temporal_id = %d\n", p->ref_flags.bits.temporal_id);
+ va_TraceMsg(trace_ctx, "\tref_flags.bits.reserved = %d\n", p->ref_flags.bits.reserved);
+
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.frame_type = %d\n", p->pic_flags.bits.frame_type);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.show_frame = %d\n", p->pic_flags.bits.show_frame);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.error_resilient_mode = %d\n", p->pic_flags.bits.error_resilient_mode);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.intra_only = %d\n", p->pic_flags.bits.intra_only);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.allow_high_precision_mv = %d\n", p->pic_flags.bits.allow_high_precision_mv);
+
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.mcomp_filter_type = %d\n", p->pic_flags.bits.mcomp_filter_type);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.frame_parallel_decoding_mode = %d\n", p->pic_flags.bits.frame_parallel_decoding_mode);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.reset_frame_context = %d\n", p->pic_flags.bits.reset_frame_context);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_frame_context = %d\n", p->pic_flags.bits.refresh_frame_context);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.frame_context_idx = %d\n", p->pic_flags.bits.frame_context_idx);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.segmentation_enabled = %d\n", p->pic_flags.bits.segmentation_enabled);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.segmentation_temporal_update = %d\n", p->pic_flags.bits.segmentation_temporal_update);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.segmentation_update_map = %d\n", p->pic_flags.bits.segmentation_update_map);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.lossless_mode = %d\n", p->pic_flags.bits.lossless_mode);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.comp_prediction_mode = %d\n", p->pic_flags.bits.comp_prediction_mode);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.auto_segmentation = %d\n", p->pic_flags.bits.auto_segmentation);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.super_frame_flag = %d\n", p->pic_flags.bits.super_frame_flag);
+ va_TraceMsg(trace_ctx, "\tpic_flags.bits.reserved = %d\n", p->pic_flags.bits.reserved);
+
+ va_TraceMsg(trace_ctx, "\trefresh_frame_flags = %d\n", p->refresh_frame_flags);
+ va_TraceMsg(trace_ctx, "\tluma_ac_qindex = %d\n", p->luma_ac_qindex);
+ va_TraceMsg(trace_ctx, "\tluma_dc_qindex_delta = %d\n", p->luma_dc_qindex_delta);
+ va_TraceMsg(trace_ctx, "\tchroma_ac_qindex_delta = %d\n", p->chroma_ac_qindex_delta);
+ va_TraceMsg(trace_ctx, "\tchroma_dc_qindex_delta = %d\n", p->chroma_dc_qindex_delta);
+ va_TraceMsg(trace_ctx, "\tfilter_level = %d\n", p->filter_level);
+ va_TraceMsg(trace_ctx, "\tsharpness_level = %d\n", p->sharpness_level);
+
+ for(i=0;i<4;i++)
+ va_TraceMsg(trace_ctx, "\tref_lf_delta[%d] = %d\n", i, p->ref_lf_delta[i]);
+ for(i=0;i<2;i++)
+ va_TraceMsg(trace_ctx, "\tmode_lf_delta[%d] = %d\n", i, p->mode_lf_delta[i]);
+
+
+ va_TraceMsg(trace_ctx, "\tbit_offset_ref_lf_delta = %d\n", p->bit_offset_ref_lf_delta);
+ va_TraceMsg(trace_ctx, "\tbit_offset_mode_lf_delta = %d\n", p->bit_offset_mode_lf_delta);
+ va_TraceMsg(trace_ctx, "\tbit_offset_lf_level = %d\n", p->bit_offset_lf_level);
+ va_TraceMsg(trace_ctx, "\tbit_offset_qindex = %d\n", p->bit_offset_qindex);
+ va_TraceMsg(trace_ctx, "\tbit_offset_first_partition_size = %d\n", p->bit_offset_first_partition_size);
+ va_TraceMsg(trace_ctx, "\tbit_offset_segmentation = %d\n", p->bit_offset_segmentation);
+ va_TraceMsg(trace_ctx, "\tbit_size_segmentation = %d\n", p->bit_size_segmentation);
+ va_TraceMsg(trace_ctx, "\tlog2_tile_rows = %d\n", p->log2_tile_rows);
+ va_TraceMsg(trace_ctx, "\tlog2_tile_columns = %d\n", p->log2_tile_columns);
+ va_TraceMsg(trace_ctx, "\tskip_frame_flag = %d\n", p->skip_frame_flag);
+ va_TraceMsg(trace_ctx, "\tnumber_skip_frames = %d\n", p->number_skip_frames);
+ va_TraceMsg(trace_ctx, "\tskip_frames_size = %d\n", p->skip_frames_size);
+
+ va_TraceMsg(trace_ctx, NULL);
+
+ return;
+}
+
static void va_TraceVASliceParameterBufferVP9(
VADisplay dpy,
VAContextID context,
case VAPictureParameterBufferType:
va_TraceVAPictureParameterBufferVP9(dpy, context, buffer, type, size, num_elements, pbuf);
break;
+ case VAEncSequenceParameterBufferType:
+ va_TraceVAEncSequenceParameterBufferVP9(dpy, context, buffer, type, size, num_elements, pbuf);
+ break;
+ case VAEncPictureParameterBufferType:
+ va_TraceVAEncPictureParameterBufferVP9(dpy, context, buffer, type, size, num_elements, pbuf);
+ break;
case VASliceParameterBufferType:
va_TraceVASliceParameterBufferVP9(dpy, context, buffer, type, size, num_elements, pbuf);
break;
+ case VAEncMiscParameterBufferType:
+ va_TraceVAEncMiscParameterBuffer(dpy, context, buffer, type, size, num_elements, pbuf);
+ break;
default:
va_TraceVABuffers(dpy, context, buffer, type, size, num_elements, pbuf);
break;
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);
}