X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=va%2Fva_trace.c;h=7a714a59883cf5677002cf416c41048b97acf431;hb=refs%2Ftags%2Fandroid-x86-8.1-r1;hp=c98a1720afcb3a7a3b3b6c46cb25f89de0ff8e54;hpb=2420d6aaf183a60e6124a2754171a2cdeedaa6e6;p=android-x86%2Fhardware-intel-common-libva.git diff --git a/va/va_trace.c b/va/va_trace.c old mode 100644 new mode 100755 index c98a172..7a714a5 --- a/va/va_trace.c +++ b/va/va_trace.c @@ -28,13 +28,16 @@ #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_enc_vp8.h" #include "va_dec_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 #include @@ -45,6 +48,8 @@ #include #include #include +#include +#include #include #include #include @@ -63,18 +68,51 @@ /* 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) + +#define MAX_TRACE_THREAD_NUM 64 + +#define MAX_TRACE_BUF_INFO_HASH_SIZE 1024 // 1<<10 +#define MAX_TRACE_BUF_INFO_HASH_LEVEL 3 +#define TRACE_BUF_INFO_HASH_ID_MASK (MAX_TRACE_BUF_INFO_HASH_SIZE - 1) + +struct trace_buf_info { + int valid; + + VABufferID buf_id; + VAContextID ctx_id; +}; + +struct trace_buf_manager { + struct trace_buf_info *pbuf_info[MAX_TRACE_BUF_INFO_HASH_LEVEL]; +}; + +struct trace_log_file { + pid_t thread_id; + int used; + + char *fn_log; + FILE *fp_log; +}; + +struct trace_log_files_manager { + int num; + + struct trace_log_file log_file[MAX_TRACE_THREAD_NUM]; +}; /* per context settings */ struct trace_context { - /* LIBVA_TRACE */ - FILE *trace_fp_log; /* save the log into a file */ - char *trace_log_fn; /* file name */ - + struct trace_log_file *plog_file; + struct trace_log_file *plog_file_list[MAX_TRACE_THREAD_NUM]; + /* LIBVA_TRACE_CODEDBUF */ FILE *trace_fp_codedbuf; /* save the encode result into a file */ char *trace_codedbuf_fn; /* file name */ - + /* LIBVA_TRACE_SURFACE */ FILE *trace_fp_surface; /* save the surface YUV into a file */ char *trace_surface_fn; /* file name */ @@ -96,24 +134,108 @@ struct trace_context { unsigned int trace_frame_width; /* current frame width */ unsigned int trace_frame_height; /* current frame height */ + + unsigned int pts; /* IVF header information */ + + pid_t created_thd_id; }; -#define TRACE_CTX(dpy) ((struct trace_context *)((VADisplayContextP)dpy)->vatrace) +struct trace_config_info { + int valid; + VAConfigID config_id; -#define DPY2TRACECTX(dpy) \ - struct trace_context *trace_ctx = TRACE_CTX(dpy); \ - \ - if (trace_ctx == NULL) \ - return; \ + VAProfile trace_profile; + VAEntrypoint trace_entrypoint; -#define TRACE_FUNCNAME(idx) va_TraceMsg(trace_ctx, "==========%s\n", __func__); + pid_t created_thd_id; +}; -/* Prototype declarations (functions defined in va.c) */ +struct va_trace { + struct trace_context *ptra_ctx[MAX_TRACE_CTX_NUM + 1]; + int context_num; + struct trace_buf_manager buf_manager; + struct trace_log_files_manager log_files_manager; + struct trace_config_info config_info[MAX_TRACE_CTX_NUM]; -void va_errorMessage(const char *msg, ...); -void va_infoMessage(const char *msg, ...); + char *fn_log_env; + char *fn_codedbuf_env; + char *fn_surface_env; + + pthread_mutex_t resource_mutex; + pthread_mutex_t context_mutex; + VADisplay dpy; +}; + +#define LOCK_RESOURCE(pva_trace) \ + if(pva_trace) \ + pthread_mutex_lock(&pva_trace->resource_mutex) + +#define UNLOCK_RESOURCE(pva_trace) \ + if(pva_trace) \ + pthread_mutex_unlock(&pva_trace->resource_mutex) + +#define LOCK_CONTEXT(pva_trace) \ + if(pva_trace) \ + pthread_mutex_lock(&pva_trace->context_mutex) + +#define UNLOCK_CONTEXT(pva_trace) \ + if(pva_trace) \ + pthread_mutex_unlock(&pva_trace->context_mutex) + +#define DPY2TRACECTX(dpy, context, buf_id) \ + struct va_trace *pva_trace = NULL; \ + struct trace_context *trace_ctx = NULL; \ + VAContextID ctx_id = context; \ + \ + pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace); \ + if(!pva_trace) \ + return; \ + \ + if(ctx_id == VA_INVALID_ID) { \ + if(buf_id != VA_INVALID_ID) \ + ctx_id = get_ctx_by_buf(pva_trace, buf_id); \ + else \ + return; \ + } \ + \ + if (ctx_id != VA_INVALID_ID) { \ + int temp_idx = get_valid_ctx_idx(pva_trace, ctx_id); \ + if(temp_idx < MAX_TRACE_CTX_NUM) \ + trace_ctx = pva_trace->ptra_ctx[temp_idx]; \ + } \ + \ + if(!trace_ctx \ + || trace_ctx->trace_context != context) { \ + return; \ + } \ + refresh_log_file(pva_trace, trace_ctx) + +#define DPY2TRACE_VIRCTX(dpy) \ + struct va_trace *pva_trace = NULL; \ + struct trace_context *trace_ctx = NULL; \ + \ + pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace); \ + if(!pva_trace) \ + return; \ + \ + LOCK_CONTEXT(pva_trace); \ + trace_ctx = pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM]; \ + if(!trace_ctx) { \ + UNLOCK_CONTEXT(pva_trace); \ + return; \ + } \ + refresh_log_file(pva_trace, trace_ctx) + +#define DPY2TRACE_VIRCTX_EXIT(pva_trace) \ + UNLOCK_CONTEXT(pva_trace) + +#define TRACE_FUNCNAME(idx) va_TraceMsg(trace_ctx, "==========%s\n", __func__); + +#define TRACE_NEWLINE() do { \ + va_TracePrint(trace_ctx, "\n"); \ + va_TraceMsg(trace_ctx, "") ; \ +} while (0) -int va_parseConfig(char *env, char *env_value); VAStatus vaBufferInfo( VADisplay dpy, @@ -141,63 +263,524 @@ VAStatus vaUnlockSurface(VADisplay dpy, VASurfaceID surface ); -#define FILE_NAME_SUFFIX(env_value) \ -do { \ - int tmp = strnlen(env_value, sizeof(env_value)); \ - int left = sizeof(env_value) - tmp; \ - \ - snprintf(env_value+tmp, \ - left, \ - ".%04d.%08lx", \ - suffix, \ - (unsigned long)trace_ctx); \ -} while (0) +static int get_valid_config_idx( + struct va_trace *pva_trace, + VAConfigID config_id) +{ + int idx = MAX_TRACE_CTX_NUM; + + LOCK_RESOURCE(pva_trace); + + 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); + + return idx; +} + +static void add_trace_config_info( + struct va_trace *pva_trace, + VAConfigID config_id, + VAProfile profile, + VAEntrypoint entrypoint) +{ + struct trace_config_info *pconfig_info; + int idx = 0; + pid_t thd_id = syscall(__NR_gettid); + + LOCK_RESOURCE(pva_trace); + + 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; + pconfig_info->trace_entrypoint = entrypoint; + pconfig_info->created_thd_id = thd_id; + } + + UNLOCK_RESOURCE(pva_trace); +} + +static void delete_trace_config_info( + struct va_trace *pva_trace, + VAConfigID config_id) +{ + struct trace_config_info *pconfig_info; + int idx = 0; + + LOCK_RESOURCE(pva_trace); + + 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); +} + +static VAContextID get_ctx_by_buf( + struct va_trace *pva_trace, + VABufferID buf_id) +{ + 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; + + LOCK_RESOURCE(pva_trace); + + idx = buf_id & TRACE_BUF_INFO_HASH_ID_MASK; + for(i = 0;i < MAX_TRACE_BUF_INFO_HASH_LEVEL;i++) { + pbuf_info = pbuf_mgr->pbuf_info[i]; + if(!pbuf_info) + break; + + if(pbuf_info[idx].valid + && pbuf_info[idx].buf_id == buf_id) { + context = pbuf_info[idx].ctx_id; + break; + } + } + + UNLOCK_RESOURCE(pva_trace); + + return context; +} + +static void add_trace_buf_info( + struct va_trace *pva_trace, + VAContextID context, + VABufferID buf_id) +{ + struct trace_buf_manager *pbuf_mgr = &pva_trace->buf_manager; + struct trace_buf_info *pbuf_info = NULL; + int i = 0, idx = 0; + + LOCK_RESOURCE(pva_trace); + + idx = buf_id & TRACE_BUF_INFO_HASH_ID_MASK; + for(i = 0;i < MAX_TRACE_BUF_INFO_HASH_LEVEL;i++) { + pbuf_info = pbuf_mgr->pbuf_info[i]; + if(!pbuf_info) { + pbuf_info = (struct trace_buf_info *)calloc( + sizeof(struct trace_buf_info) * MAX_TRACE_BUF_INFO_HASH_SIZE, + 1); + if(!pbuf_info) + break; + + pbuf_mgr->pbuf_info[i] = pbuf_info; + } + + if(pbuf_info[idx].valid + && pbuf_info[idx].buf_id != buf_id) + continue; + + pbuf_info[idx].buf_id = buf_id; + pbuf_info[idx].ctx_id = context; + pbuf_info[idx].valid = 1; + break; + } + + if(i >= MAX_TRACE_BUF_INFO_HASH_LEVEL) + va_errorMessage(pva_trace->dpy, "Add buf info failed\n"); + + UNLOCK_RESOURCE(pva_trace); +} + +static void delete_trace_buf_info( + struct va_trace *pva_trace, + VABufferID buf_id) +{ + struct trace_buf_manager *pbuf_mgr = &pva_trace->buf_manager; + struct trace_buf_info *pbuf_info = NULL; + int i = 0, idx = 0; + + LOCK_RESOURCE(pva_trace); + + idx = buf_id & TRACE_BUF_INFO_HASH_ID_MASK; + for(i = 0;i < MAX_TRACE_BUF_INFO_HASH_LEVEL;i++) { + pbuf_info = pbuf_mgr->pbuf_info[i]; + if(!pbuf_info) + break; + + if(pbuf_info[idx].valid + && pbuf_info[idx].buf_id == buf_id) { + pbuf_info[idx].valid = 0; + break; + } + } + + UNLOCK_RESOURCE(pva_trace); +} + +/* +static void delete_trace_all_context_buf( + struct va_trace *pva_trace, + VAContextID context) +{ + struct trace_buf_manager *pbuf_mgr = &pva_trace->buf_manager; + struct trace_buf_info *pbuf_info = NULL; + int i = 0, j = 0; + + LOCK_RESOURCE(pva_trace); + + for(i = 0;i < MAX_TRACE_BUF_INFO_HASH_LEVEL;i++) { + pbuf_info = pbuf_mgr->pbuf_info[i]; + if(!pbuf_info) + break; + + for(j = 0;j < MAX_TRACE_BUF_INFO_HASH_SIZE;j++) + if(pbuf_info[j].valid + && pbuf_info[j].ctx_id == context) + pbuf_info[j].valid = 0; + } + + UNLOCK_RESOURCE(pva_trace); +} +*/ + +static int get_free_ctx_idx( + struct va_trace *pva_trace, + VAContextID context) +{ + int idx; + + LOCK_RESOURCE(pva_trace); + + 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); + + return idx; +} + +static int get_valid_ctx_idx( + struct va_trace *pva_trace, + VAContextID context) +{ + int idx; + + LOCK_RESOURCE(pva_trace); + + 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); + + return idx; +} + +static void FILE_NAME_SUFFIX( + char *env_value, + int max_size, + char *suffix_str, + unsigned int suffix_handle) +{ + int tmp = strnlen(env_value, max_size); + int left = max_size - tmp; + struct timeval tv; + int size = 0; + + if (suffix_str) + size = strlen(suffix_str); + + if(left < (size + 8 + 10)) + return; + + if(gettimeofday(&tv, NULL) == 0) { + sprintf(env_value + tmp, + ".%02d%02d%02d.", + (unsigned int)(tv.tv_sec/3600)%24, + (unsigned int)(tv.tv_sec/60)%60, + (unsigned int)tv.tv_sec%60); + + tmp += 8; + left -= 8; + } + + if(suffix_str) { + strcat(env_value + tmp, + suffix_str); + + tmp += size; + left -= size; + } + + if(suffix_handle) { + sprintf(env_value + tmp, + "0x%08x", + suffix_handle); + } +} + +static int open_tracing_specil_file( + struct va_trace *pva_trace, + struct trace_context *ptra_ctx, + int type) // 0: codedbuf, 1: surface +{ + char *fn_env = type == 0 ? + pva_trace->fn_codedbuf_env : pva_trace->fn_surface_env; + char env_value[1024]; + 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); + + fn_env = strdup(env_value); + if(!fn_env) + return -1; + + fp = fopen(fn_env, "w"); + if(!fp) { + free(fn_env); + + return -1; + } + + if(type == 0) { + ptra_ctx->trace_codedbuf_fn = fn_env; + ptra_ctx->trace_fp_codedbuf = fp; + 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(pva_trace->dpy, "LIBVA_TRACE_SURFACE is on, save surface into %s\n", + fn_env); + } + + return 0; +} + +static int open_tracing_log_file( + struct va_trace *pva_trace, + struct trace_log_file *plog_file, + pid_t thd_id) +{ + FILE *pfp = NULL; + int new_fn_flag = 0; + + if(plog_file->used && plog_file->thread_id != thd_id) { + va_errorMessage(pva_trace->dpy, "Try to open a busy log file occupied by other thread\n"); + + return -1; + } + + if(plog_file->thread_id != thd_id) { + 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(plog_file->fn_log) + free(plog_file->fn_log); + + plog_file->fn_log = strdup(env_value); + if(!plog_file->fn_log) + goto FAIL; + + new_fn_flag = 1; + } + + if(!plog_file->used) { + if(new_fn_flag) + pfp = fopen(plog_file->fn_log, "w"); + else + pfp = fopen(plog_file->fn_log, "a"); + + if(!pfp) + goto FAIL; + + 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); + + plog_file->fp_log = pfp; + plog_file->thread_id = thd_id; + } + + plog_file->used++; + return 0; + +FAIL: + if(plog_file->fn_log) { + free(plog_file->fn_log); + plog_file->fn_log = NULL; + } + + return -1; +} + +static int get_log_file_idx_by_thd( + struct trace_log_files_manager *plog_files_mgr, + pid_t thd_id) +{ + struct trace_log_file *plog_file = plog_files_mgr->log_file; + int first_free_idx = MAX_TRACE_THREAD_NUM; + int i = 0; + + for(i = 0;i < MAX_TRACE_THREAD_NUM;i++) { + if(plog_file[i].thread_id == thd_id) + break; + else if(!plog_file[i].used && + first_free_idx >= MAX_TRACE_THREAD_NUM) + first_free_idx = i; + } + + if(i >= MAX_TRACE_THREAD_NUM) + i = first_free_idx; + + return i; +} + +static struct trace_log_file *start_tracing2log_file( + struct va_trace *pva_trace) +{ + struct trace_log_files_manager *plog_files_mgr = NULL; + struct trace_log_file *plog_file = NULL; + pid_t thd_id = syscall(__NR_gettid); + int i = 0; + + LOCK_RESOURCE(pva_trace); + + plog_files_mgr = &pva_trace->log_files_manager; + i = get_log_file_idx_by_thd(plog_files_mgr, thd_id); + if(i < MAX_TRACE_THREAD_NUM) { + plog_file = &plog_files_mgr->log_file[i]; + if(open_tracing_log_file(pva_trace, plog_file, thd_id) < 0) { + plog_file = NULL; + } + } + + UNLOCK_RESOURCE(pva_trace); + return plog_file; +} + +static void stop_tracing2log_file( + struct va_trace *pva_trace, + struct trace_log_file *plog_file) +{ + LOCK_RESOURCE(pva_trace); + + if(--plog_file->used <= 0) { + if(plog_file->fp_log) { + fclose(plog_file->fp_log); + plog_file->fp_log = NULL; + } + } + + UNLOCK_RESOURCE(pva_trace); +} + +static void refresh_log_file( + struct va_trace *pva_trace, + struct trace_context *ptra_ctx) +{ + struct trace_log_file *plog_file = NULL; + pid_t thd_id = syscall(__NR_gettid); + int i = 0; + + plog_file = ptra_ctx->plog_file; + if(plog_file && plog_file->thread_id != thd_id) { + plog_file = start_tracing2log_file(pva_trace); + if(plog_file) { + int first_free_idx = -1; + + ptra_ctx->plog_file = plog_file; + + for(i = 0;i < MAX_TRACE_THREAD_NUM;i++) { + if(!ptra_ctx->plog_file_list[i]){ + if(first_free_idx < 0) + first_free_idx = i; + } + else if(ptra_ctx->plog_file_list[i]->thread_id == thd_id) + break; + } + + if(i > MAX_TRACE_THREAD_NUM + && first_free_idx >= 0) + ptra_ctx->plog_file_list[first_free_idx] = plog_file; + } + } +} 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); - if (trace_ctx == NULL) + if (pva_trace == NULL || trace_ctx == NULL) { + free(pva_trace); + free(trace_ctx); + 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) { - FILE_NAME_SUFFIX(env_value); - trace_ctx->trace_log_fn = strdup(env_value); - - tmp = fopen(env_value, "w"); - if (tmp) { - trace_ctx->trace_fp_log = tmp; - va_infoMessage("LIBVA_TRACE is on, save log into %s\n", trace_ctx->trace_log_fn); - trace_flag = VA_TRACE_FLAG_LOG; - } else - va_errorMessage("Open file %s failed (%s)\n", env_value, strerror(errno)); + 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; + va_trace_flag = VA_TRACE_FLAG_LOG; + + va_infoMessage(dpy, "LIBVA_TRACE is on, save log into %s\n", + trace_ctx->plog_file->fn_log); + } + else + 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; - va_infoMessage("LIBVA_TRACE_BUFDATA is on, dump buffer into log file\n"); + 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) { - FILE_NAME_SUFFIX(env_value); - trace_ctx->trace_codedbuf_fn = strdup(env_value); - va_infoMessage("LIBVA_TRACE_CODEDBUF is on, save codedbuf into log file %s\n", - trace_ctx->trace_codedbuf_fn); - trace_flag |= VA_TRACE_FLAG_CODEDBUF; + pva_trace->fn_codedbuf_env = strdup(env_value); + va_trace_flag |= VA_TRACE_FLAG_CODEDBUF; } if (va_parseConfig("LIBVA_TRACE_SURFACE", &env_value[0]) == 0) { - FILE_NAME_SUFFIX(env_value); - trace_ctx->trace_surface_fn = strdup(env_value); - - va_infoMessage("LIBVA_TRACE_SURFACE is on, save surface into %s\n", - trace_ctx->trace_surface_fn); + pva_trace->fn_surface_env = strdup(env_value); /* for surface data dump, it is time-consume, and may * cause some side-effect, so only trace the needed surfaces @@ -206,11 +789,11 @@ void va_TraceInit(VADisplay dpy) * 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; @@ -223,7 +806,7 @@ void va_TraceInit(VADisplay dpy) 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, @@ -231,60 +814,137 @@ void va_TraceInit(VADisplay dpy) } } - ((VADisplayContextP)dpy)->vatrace = trace_ctx; -} + trace_ctx->trace_context = VA_INVALID_ID; + pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM] = trace_ctx; + + ((VADisplayContextP)dpy)->vatrace = (void *)pva_trace; + if(!va_trace_flag) + va_TraceEnd(dpy); +} void va_TraceEnd(VADisplay dpy) { - DPY2TRACECTX(dpy); - - if (trace_ctx->trace_fp_log) - fclose(trace_ctx->trace_fp_log); - - if (trace_ctx->trace_fp_codedbuf) - fclose(trace_ctx->trace_fp_codedbuf); - - if (trace_ctx->trace_fp_surface) - fclose(trace_ctx->trace_fp_surface); + struct va_trace *pva_trace = NULL; + int i = 0; - if (trace_ctx->trace_log_fn) - free(trace_ctx->trace_log_fn); - - if (trace_ctx->trace_codedbuf_fn) - free(trace_ctx->trace_codedbuf_fn); - - if (trace_ctx->trace_surface_fn) - free(trace_ctx->trace_surface_fn); - - free(trace_ctx); + pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace); + if(!pva_trace) + return; + + if(pva_trace->fn_log_env) + free(pva_trace->fn_log_env); + + if(pva_trace->fn_codedbuf_env) + free(pva_trace->fn_codedbuf_env); + + if(pva_trace->fn_surface_env) + free(pva_trace->fn_surface_env); + + for(i = 0;i < MAX_TRACE_BUF_INFO_HASH_LEVEL;i++) + if(pva_trace->buf_manager.pbuf_info[i]) + free(pva_trace->buf_manager.pbuf_info[i]); + + for(i = 0;i < MAX_TRACE_THREAD_NUM;i++) { + struct trace_log_file *plog_file = NULL; + + if(pva_trace->log_files_manager.num <= 0) + break; + + plog_file = &pva_trace->log_files_manager.log_file[i]; + if(plog_file) { + if(plog_file->fn_log) + free(plog_file->fn_log); + + if(plog_file->fp_log) + fclose(plog_file->fp_log); + + pva_trace->log_files_manager.num--; + } + } + + for(i = 0;i < MAX_TRACE_CTX_NUM;i++) { + struct trace_context *trace_ctx = NULL; + + if(pva_trace->context_num <= 0) + break; + + trace_ctx = pva_trace->ptra_ctx[i]; + if(trace_ctx) { + if(trace_ctx->trace_codedbuf_fn) + free(trace_ctx->trace_codedbuf_fn); + + if(trace_ctx->trace_fp_codedbuf) + fclose(trace_ctx->trace_fp_codedbuf); + + if(trace_ctx->trace_surface_fn) + free(trace_ctx->trace_surface_fn); + + if(trace_ctx->trace_fp_surface) + fclose(trace_ctx->trace_fp_surface); + + free(pva_trace->ptra_ctx[i]); + pva_trace->context_num--; + } + } + free(pva_trace->ptra_ctx[MAX_TRACE_CTX_NUM]); + + pva_trace->dpy = NULL; + free(pva_trace); ((VADisplayContextP)dpy)->vatrace = NULL; } -static void va_TraceMsg(struct trace_context *trace_ctx, const char *msg, ...) +static void va_TraceVPrint(struct trace_context *trace_ctx, const char *msg, va_list args) { - va_list args; + FILE *fp = NULL; - if (!(trace_flag & VA_TRACE_FLAG_LOG)) + if (!(va_trace_flag & VA_TRACE_FLAG_LOG) + || !trace_ctx->plog_file) return; + fp = trace_ctx->plog_file->fp_log; if (msg) { - struct timeval tv; - - if (gettimeofday(&tv, NULL) == 0) - fprintf(trace_ctx->trace_fp_log, "[%04d.%06d] ", - (unsigned int)tv.tv_sec & 0xffff, (unsigned int)tv.tv_usec); - va_start(args, msg); - vfprintf(trace_ctx->trace_fp_log, msg, args); - va_end(args); + vfprintf(fp, msg, args); } else - fflush(trace_ctx->trace_fp_log); + fflush(fp); +} + +static void va_TracePrint(struct trace_context *trace_ctx, const char *msg, ...) +{ + va_list args; + va_start(args, msg); + va_TraceVPrint(trace_ctx, msg, args); + va_end(args); } +static void va_TraceMsg(struct trace_context *trace_ctx, const char *msg, ...) +{ + va_list args; + struct timeval tv; + + if (!msg) { + va_TracePrint(trace_ctx, msg); + return; + } + + if (gettimeofday(&tv, NULL) == 0) + va_TracePrint(trace_ctx, "[%04d.%06d]", + (unsigned int)tv.tv_sec & 0xffff, (unsigned int)tv.tv_usec); + + if(trace_ctx->trace_context != VA_INVALID_ID) + va_TracePrint(trace_ctx, + "[ctx 0x%08x]", trace_ctx->trace_context); + else + va_TracePrint(trace_ctx, "[ctx none]"); + + va_start(args, msg); + va_TraceVPrint(trace_ctx, msg, args); + va_end(args); +} -static void va_TraceSurface(VADisplay dpy) +static void va_TraceSurface(VADisplay dpy, VAContextID context) { - unsigned int i, j; + unsigned int i; unsigned int fourcc; /* following are output argument */ unsigned int luma_stride; unsigned int chroma_u_stride; @@ -295,9 +955,9 @@ static void va_TraceSurface(VADisplay dpy) unsigned int buffer_name; void *buffer = NULL; unsigned char *Y_data, *UV_data, *tmp; + unsigned int pixel_byte; VAStatus va_status; - unsigned char check_sum = 0; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); if (!trace_ctx->trace_fp_surface) return; @@ -342,25 +1002,34 @@ static void va_TraceSurface(VADisplay dpy) Y_data = (unsigned char*)buffer; UV_data = (unsigned char*)buffer + chroma_u_offset; + if (fourcc == VA_FOURCC_P010) + pixel_byte = 2; + else + pixel_byte = 1; + tmp = Y_data + luma_stride * trace_ctx->trace_surface_yoff; + for (i=0; itrace_surface_height; i++) { fwrite(tmp + trace_ctx->trace_surface_xoff, trace_ctx->trace_surface_width, - 1, trace_ctx->trace_fp_surface); + pixel_byte, trace_ctx->trace_fp_surface); tmp += luma_stride; } + tmp = UV_data + chroma_u_stride * trace_ctx->trace_surface_yoff / 2; - if (fourcc == VA_FOURCC_NV12) { + if (fourcc == VA_FOURCC_NV12 || fourcc == VA_FOURCC_P010) { for (i=0; itrace_surface_height/2; i++) { fwrite(tmp + trace_ctx->trace_surface_xoff, trace_ctx->trace_surface_width, - 1, trace_ctx->trace_fp_surface); + pixel_byte, trace_ctx->trace_fp_surface); tmp += chroma_u_stride; } } + fflush(trace_ctx->trace_fp_surface); + vaUnlockSurface(dpy, trace_ctx->trace_rendertarget); va_TraceMsg(trace_ctx, NULL); @@ -373,16 +1042,19 @@ void va_TraceInitialize ( int *minor_version /* out */ ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); + DPY2TRACE_VIRCTX_EXIT(pva_trace); } void va_TraceTerminate ( VADisplay dpy ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); + va_TraceMsg(trace_ctx, NULL); + DPY2TRACE_VIRCTX_EXIT(pva_trace); } @@ -396,8 +1068,8 @@ void va_TraceCreateConfig( ) { int i; - int encode, decode, jpeg; - DPY2TRACECTX(dpy); + + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); @@ -412,42 +1084,26 @@ void va_TraceCreateConfig( } va_TraceMsg(trace_ctx, NULL); - trace_ctx->trace_profile = profile; - trace_ctx->trace_entrypoint = entrypoint; + add_trace_config_info(pva_trace, *config_id, profile, entrypoint); - /* avoid to create so many empty files */ - 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))) { - FILE *tmp = fopen(trace_ctx->trace_surface_fn, "w"); - - if (tmp) - trace_ctx->trace_fp_surface = tmp; - else { - va_errorMessage("Open file %s failed (%s)\n", - trace_ctx->trace_surface_fn, - strerror(errno)); - trace_ctx->trace_fp_surface = NULL; - trace_flag &= ~(VA_TRACE_FLAG_SURFACE); - } - } + DPY2TRACE_VIRCTX_EXIT(pva_trace); +} - if (encode && (trace_flag & VA_TRACE_FLAG_CODEDBUF)) { - FILE *tmp = fopen(trace_ctx->trace_codedbuf_fn, "w"); - - if (tmp) - trace_ctx->trace_fp_codedbuf = tmp; - else { - va_errorMessage("Open file %s failed (%s)\n", - trace_ctx->trace_codedbuf_fn, - strerror(errno)); - trace_ctx->trace_fp_codedbuf = NULL; - trace_flag &= ~VA_TRACE_FLAG_CODEDBUF; - } - } +void va_TraceDestroyConfig ( + VADisplay dpy, + VAConfigID config_id +) +{ + DPY2TRACE_VIRCTX(dpy); + + TRACE_FUNCNAME(idx); + + va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config_id); + va_TraceMsg(trace_ctx, NULL); + + delete_trace_config_info(pva_trace, config_id); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } static void va_TraceSurfaceAttributes( @@ -486,7 +1142,7 @@ static void va_TraceSurfaceAttributes( va_TraceMsg(trace_ctx, "\t\tvalue.value.p = %p\n", p->value.value.p); if ((p->type == VASurfaceAttribExternalBufferDescriptor) && p->value.value.p) { VASurfaceAttribExternalBuffers *tmp = (VASurfaceAttribExternalBuffers *) p->value.value.p; - int j; + uint32_t j; va_TraceMsg(trace_ctx, "\t\t--VASurfaceAttribExternalBufferDescriptor\n"); va_TraceMsg(trace_ctx, "\t\t pixel_format=0x%08x\n", tmp->pixel_format); @@ -529,7 +1185,7 @@ void va_TraceCreateSurfaces( ) { int i; - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); @@ -546,8 +1202,9 @@ void va_TraceCreateSurfaces( va_TraceSurfaceAttributes(trace_ctx, attrib_list, &num_attribs); va_TraceMsg(trace_ctx, NULL); -} + DPY2TRACE_VIRCTX_EXIT(pva_trace); +} void va_TraceDestroySurfaces( VADisplay dpy, @@ -556,7 +1213,7 @@ void va_TraceDestroySurfaces( ) { int i; - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); @@ -566,25 +1223,146 @@ void va_TraceDestroySurfaces( } va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); +} + + +static void internal_TraceUpdateContext ( + struct va_trace *pva_trace, + int tra_ctx_idx, + struct trace_context *new_trace_ctx, + VAContextID context, + int destroy_flag +) +{ + struct trace_context *trace_ctx = NULL; + int i = 0, delete = 1; + pid_t thd_id = syscall(__NR_gettid); + + if(tra_ctx_idx >= MAX_TRACE_CTX_NUM) + return; + + LOCK_RESOURCE(pva_trace); + + trace_ctx = pva_trace->ptra_ctx[tra_ctx_idx]; + if(trace_ctx) { + if(!new_trace_ctx && + trace_ctx->created_thd_id != thd_id + && !destroy_flag) { + delete = 0; + } + else { + pva_trace->context_num--; + pva_trace->ptra_ctx[tra_ctx_idx] = NULL; + } + } + + if(new_trace_ctx) { + new_trace_ctx->created_thd_id = thd_id; + pva_trace->ptra_ctx[tra_ctx_idx] = new_trace_ctx; + pva_trace->context_num++; + } + + UNLOCK_RESOURCE(pva_trace); + + if(trace_ctx && delete) { + for(i = 0;i < MAX_TRACE_THREAD_NUM;i++) + if(trace_ctx->plog_file_list[i]) + stop_tracing2log_file(pva_trace, trace_ctx->plog_file_list[i]); + + if(trace_ctx->trace_codedbuf_fn) + free(trace_ctx->trace_codedbuf_fn); + + if(trace_ctx->trace_fp_codedbuf) + fclose(trace_ctx->trace_fp_codedbuf); + + if(trace_ctx->trace_surface_fn) + free(trace_ctx->trace_surface_fn); + + if(trace_ctx->trace_fp_surface) + fclose(trace_ctx->trace_fp_surface); + + //delete_trace_all_context_buf(pva_trace, context); + + free(trace_ctx); + } } +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 */ +) +{ + struct va_trace *pva_trace = NULL; + struct trace_context *trace_ctx = NULL; + int tra_ctx_id = 0; + int encode = 0, decode = 0, jpeg = 0; + int i; + + pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace); + if(!context + || *context == VA_INVALID_ID + || !pva_trace) { + va_errorMessage(dpy, "Invalid context id 0x%08x\n", + context == NULL ? 0 : (int)*context); + return; + } + + LOCK_CONTEXT(pva_trace); + + tra_ctx_id = get_free_ctx_idx(pva_trace, *context); + if(tra_ctx_id >= MAX_TRACE_CTX_NUM) { + 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(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(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(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", + *context); + + goto FAIL; + } + else + va_infoMessage(dpy, "Save context 0x%08x into log file %s\n", *context, + trace_ctx->plog_file->fn_log); -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 */ -) -{ - int i; - DPY2TRACECTX(dpy); + 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 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); va_TraceMsg(trace_ctx, "\twidth = %d\n", picture_width); va_TraceMsg(trace_ctx, "\theight = %d\n", picture_height); @@ -594,12 +1372,7 @@ void va_TraceCreateContext( for (i=0; itrace_context = *context; - } else - trace_ctx->trace_context = VA_INVALID_ID; - + trace_ctx->trace_frame_no = 0; trace_ctx->trace_slice_no = 0; @@ -610,37 +1383,131 @@ void va_TraceCreateContext( trace_ctx->trace_surface_width = picture_width; if (trace_ctx->trace_surface_height == 0) trace_ctx->trace_surface_height = picture_height; + + /* avoid to create so many empty files */ + encode = (trace_ctx->trace_entrypoint == VAEntrypointEncSlice); + decode = (trace_ctx->trace_entrypoint == VAEntrypointVLD); + jpeg = (trace_ctx->trace_entrypoint == VAEntrypointEncPicture); + 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); + + va_trace_flag &= ~(VA_TRACE_FLAG_SURFACE); + } + } + + 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); + + va_trace_flag &= ~(VA_TRACE_FLAG_CODEDBUF); + } + } + + internal_TraceUpdateContext(pva_trace, tra_ctx_id, trace_ctx, *context, 0); + + UNLOCK_CONTEXT(pva_trace); + return; + +FAIL: + internal_TraceUpdateContext(pva_trace, tra_ctx_id, NULL, *context, 1); + + UNLOCK_CONTEXT(pva_trace); + + if(trace_ctx) + free(trace_ctx); +} + +void va_TraceDestroyContext ( + VADisplay dpy, + VAContextID context +) +{ + struct va_trace *pva_trace = NULL; + struct trace_context *trace_ctx = NULL; + int ctx_id = 0; + + pva_trace = (struct va_trace *)(((VADisplayContextP)dpy)->vatrace); + + if(!pva_trace) + return; + + LOCK_CONTEXT(pva_trace); + + ctx_id = get_valid_ctx_idx(pva_trace, context); + if(ctx_id < MAX_TRACE_CTX_NUM) { + trace_ctx = pva_trace->ptra_ctx[ctx_id]; + + if(trace_ctx) { + refresh_log_file(pva_trace, trace_ctx); + + internal_TraceUpdateContext(pva_trace, + get_valid_ctx_idx(pva_trace, context), + NULL, context, 0); + } + } + + UNLOCK_CONTEXT(pva_trace); } +void va_TraceCreateMFContext ( + VADisplay dpy, + VAMFContextID *mf_context /* out */ +) +{ + 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; +} -static char * buffer_type_to_string(int type) +void va_TraceMFAddContext ( + VADisplay dpy, + VAMFContextID mf_context, + VAContextID context +) { - 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, 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]); } } @@ -654,18 +1521,23 @@ void va_TraceCreateBuffer ( VABufferID *buf_id /* out */ ) { - DPY2TRACECTX(dpy); + if (!buf_id || *buf_id == VA_INVALID_ID) + return; + + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + + add_trace_buf_info(pva_trace, context, *buf_id); /* only trace CodedBuffer */ if (type != VAEncCodedBufferType) 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=%d\n", size); - va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements); + va_TraceMsg(trace_ctx, "\tsize=%u\n", size); + va_TraceMsg(trace_ctx, "\tnum_elements=%u\n", num_elements); va_TraceMsg(trace_ctx, NULL); } @@ -678,28 +1550,84 @@ void va_TraceDestroyBuffer ( VABufferType type; unsigned int size; unsigned int num_elements; - - VACodedBufferSegment *buf_list; - int i = 0; - - DPY2TRACECTX(dpy); + + if (buf_id == VA_INVALID_ID) + return; + + DPY2TRACECTX(dpy, VA_INVALID_ID, buf_id); vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements); - + + delete_trace_buf_info(pva_trace, buf_id); + /* only trace CodedBuffer */ if (type != VAEncCodedBufferType) 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=%d\n", size); - va_TraceMsg(trace_ctx, "\tnum_elements=%d\n", num_elements); + va_TraceMsg(trace_ctx, "\tsize=%u\n", size); + va_TraceMsg(trace_ctx, "\tnum_elements=%u\n", num_elements); va_TraceMsg(trace_ctx, NULL); } +static void mem_put_le16(char *mem, unsigned int val) +{ + mem[0] = val; + mem[1] = val>>8; +} + +static void mem_put_le32(char *mem, unsigned int val) +{ + mem[0] = val; + mem[1] = val>>8; + mem[2] = val>>16; + mem[3] = val>>24; +} + +static void va_TraceCodedBufferIVFHeader(struct trace_context *trace_ctx, void **pbuf) +{ + VACodedBufferSegment *buf_list; + unsigned int frame_length = 0; + char header[32]; + + buf_list = (VACodedBufferSegment *)(*pbuf); + + if (ftell(trace_ctx->trace_fp_codedbuf) == 0) { /* write ivf header */ + header[0] = 'D'; + header[1] = 'K'; + header[2] = 'I'; + header[3] = 'F'; + mem_put_le16(header+4, 0); /* version */ + mem_put_le16(header+6, 32); /* headersize */ + mem_put_le32(header+8, 0x30385056); /* headersize */ + /* write width and height of the first rc_param to IVF file header */ + mem_put_le16(header+12, trace_ctx->trace_frame_width); /* width */ + mem_put_le16(header+14, trace_ctx->trace_frame_height); /* height */ + mem_put_le32(header+16, 30); /* rate */ + mem_put_le32(header+20, 1); /* scale */ + mem_put_le32(header+24, 0xffffffff); /* length */ + mem_put_le32(header+28, 0); /* unused */ + fwrite(header, 1, 32, trace_ctx->trace_fp_codedbuf); + } + + /* write frame header */ + while (buf_list != NULL) { + frame_length += buf_list->size; + buf_list = (VACodedBufferSegment *) buf_list->next; + } + mem_put_le32(header, frame_length); + mem_put_le32(header+4, trace_ctx->pts&0xFFFFFFFF); + mem_put_le32(header+8, 0); + fwrite(header, 1, 12, trace_ctx->trace_fp_codedbuf); + trace_ctx->pts++; + + fflush(trace_ctx->trace_fp_codedbuf); +} + void va_TraceMapBuffer ( VADisplay dpy, VABufferID buf_id, /* in */ @@ -712,27 +1640,32 @@ void va_TraceMapBuffer ( VACodedBufferSegment *buf_list; int i = 0; - - DPY2TRACECTX(dpy); + + DPY2TRACECTX(dpy, VA_INVALID_ID, buf_id); vaBufferInfo(dpy, trace_ctx->trace_context, buf_id, &type, &size, &num_elements); - + /* only trace CodedBuffer */ if (type != VAEncCodedBufferType) return; 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; - + + if (trace_ctx->trace_profile == VAProfileVP8Version0_3) { + va_TraceMsg(trace_ctx, "\tAdd IVF header information\n"); + va_TraceCodedBufferIVFHeader(trace_ctx, pbuf); + } + buf_list = (VACodedBufferSegment *)(*pbuf); while (buf_list != NULL) { va_TraceMsg(trace_ctx, "\tCodedbuf[%d] =\n", i++); - va_TraceMsg(trace_ctx, "\t size = %d\n", buf_list->size); - va_TraceMsg(trace_ctx, "\t bit_offset = %d\n", buf_list->bit_offset); + va_TraceMsg(trace_ctx, "\t size = %u\n", buf_list->size); + va_TraceMsg(trace_ctx, "\t bit_offset = %u\n", buf_list->bit_offset); va_TraceMsg(trace_ctx, "\t status = 0x%08x\n", buf_list->status); va_TraceMsg(trace_ctx, "\t reserved = 0x%08x\n", buf_list->reserved); va_TraceMsg(trace_ctx, "\t buf = 0x%08x\n", buf_list->buf); @@ -740,6 +1673,8 @@ void va_TraceMapBuffer ( if (trace_ctx->trace_fp_codedbuf) { va_TraceMsg(trace_ctx, "\tDump the content to file\n"); fwrite(buf_list->buf, buf_list->size, 1, trace_ctx->trace_fp_codedbuf); + + fflush(trace_ctx->trace_fp_codedbuf); } buf_list = buf_list->next; @@ -759,23 +1694,27 @@ static void va_TraceVABuffers( { unsigned int i; unsigned char *p = pbuf; + FILE *fp = NULL; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); - va_TraceMsg(trace_ctx, "--%s\n", buffer_type_to_string(type)); + va_TracePrint(trace_ctx, "--%s\n", vaBufferTypeStr(type)); - if ((trace_flag & VA_TRACE_FLAG_BUFDATA) && trace_ctx->trace_fp_log) { + if(trace_ctx->plog_file) + fp = trace_ctx->plog_file->fp_log; + + if ((va_trace_flag & VA_TRACE_FLAG_BUFDATA) && fp) { for (i=0; itrace_fp_log, "\t\t0x%04x:", i); + fprintf(fp, "\t\t0x%04x:", i); else if ((i%16) == 0) - fprintf(trace_ctx->trace_fp_log, "\n\t\t0x%04x:", i); + fprintf(fp, "\n\t\t0x%04x:", i); - fprintf(trace_ctx->trace_fp_log, " %02x", value); + fprintf(fp, " %02x", value); } - fprintf(trace_ctx->trace_fp_log, "\n"); + fprintf(fp, "\n"); } va_TraceMsg(trace_ctx, NULL); @@ -794,7 +1733,7 @@ static void va_TraceVAPictureParameterBufferMPEG2( void *data) { VAPictureParameterBufferMPEG2 *p=(VAPictureParameterBufferMPEG2 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"VAPictureParameterBufferMPEG2\n"); @@ -833,7 +1772,7 @@ static void va_TraceVAIQMatrixBufferMPEG2( void *data) { VAIQMatrixBufferMPEG2 *p=(VAIQMatrixBufferMPEG2 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG2\n"); @@ -862,7 +1801,7 @@ static void va_TraceVASliceParameterBufferMPEG2( { VASliceParameterBufferMPEG2 *p=(VASliceParameterBufferMPEG2 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); trace_ctx->trace_slice_no++; @@ -894,7 +1833,7 @@ static void va_TraceVAPictureParameterBufferJPEG( { int i; VAPictureParameterBufferJPEGBaseline *p=(VAPictureParameterBufferJPEGBaseline *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"*VAPictureParameterBufferJPEG\n"); va_TraceMsg(trace_ctx,"\tpicture_width = %u\n", p->picture_width); @@ -920,7 +1859,7 @@ static void va_TraceVAIQMatrixBufferJPEG( int i, j; static char tmp[1024]; VAIQMatrixBufferJPEGBaseline *p=(VAIQMatrixBufferJPEGBaseline *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"*VAIQMatrixParameterBufferJPEG\n"); va_TraceMsg(trace_ctx,"\tload_quantiser_table =\n"); for (i = 0; i < 4; ++i) { @@ -947,7 +1886,7 @@ static void va_TraceVASliceParameterBufferJPEG( { int i; VASliceParameterBufferJPEGBaseline *p=(VASliceParameterBufferJPEGBaseline *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"*VASliceParameterBufferJPEG\n"); va_TraceMsg(trace_ctx,"\tslice_data_size = %u\n", p->slice_data_size); va_TraceMsg(trace_ctx,"\tslice_data_offset = %u\n", p->slice_data_offset); @@ -976,11 +1915,11 @@ static void va_TraceVAHuffmanTableBufferJPEG( int i, j; static char tmp[1024]; VAHuffmanTableBufferJPEGBaseline *p=(VAHuffmanTableBufferJPEGBaseline *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); 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) { @@ -996,17 +1935,17 @@ static void va_TraceVAHuffmanTableBufferJPEG( for (j = 0; j < 16; ++j) { sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].num_ac_codes[j]); } - va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp); + va_TraceMsg(trace_ctx,"\t\tnum_ac_codes =%s\n", tmp); memset(tmp, 0, sizeof tmp); for (j = 0; j < 162; ++j) { sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].ac_values[j]); } - va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp); + va_TraceMsg(trace_ctx,"\t\tac_values =%s\n", tmp); memset(tmp, 0, sizeof tmp); for (j = 0; j < 2; ++j) { sprintf(tmp + strlen(tmp), "%u ", p->huffman_table[i].pad[j]); } - va_TraceMsg(trace_ctx,"\t\tnum_dc_codes =%s\n", tmp); + va_TraceMsg(trace_ctx,"\t\tpad =%s\n", tmp); } } @@ -1022,7 +1961,7 @@ static void va_TraceVAPictureParameterBufferMPEG4( int i; VAPictureParameterBufferMPEG4 *p=(VAPictureParameterBufferMPEG4 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"*VAPictureParameterBufferMPEG4\n"); va_TraceMsg(trace_ctx,"\tvop_width = %d\n", p->vop_width); @@ -1081,7 +2020,7 @@ static void va_TraceVAIQMatrixBufferMPEG4( { int i; VAIQMatrixBufferMPEG4 *p=(VAIQMatrixBufferMPEG4 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx,"VAIQMatrixBufferMPEG4\n"); @@ -1109,7 +2048,7 @@ static void va_TraceVAEncSequenceParameterBufferMPEG4( void *data) { VAEncSequenceParameterBufferMPEG4 *p = (VAEncSequenceParameterBufferMPEG4 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferMPEG4\n"); @@ -1139,7 +2078,7 @@ static void va_TraceVAEncPictureParameterBufferMPEG4( void *data) { VAEncPictureParameterBufferMPEG4 *p = (VAEncPictureParameterBufferMPEG4 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferMPEG4\n"); va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture); @@ -1167,7 +2106,7 @@ static void va_TraceVASliceParameterBufferMPEG4( { VASliceParameterBufferMPEG4 *p=(VASliceParameterBufferMPEG4 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); trace_ctx->trace_slice_no++; @@ -1211,9 +2150,9 @@ static void va_TraceVAPictureParameterBufferHEVC( int i; VAPictureParameterBufferHEVC *p = (VAPictureParameterBufferHEVC*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); - va_TraceMsg(trace_ctx, "VAPictureParameterBufferHEVC\n"); + va_TracePrint(trace_ctx, "VAPictureParameterBufferHEVC\n"); va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id); va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.pic_order_cnt); @@ -1281,19 +2220,21 @@ static void va_TraceVAPictureParameterBufferHEVC( va_TraceMsg(trace_ctx, "\tnum_tile_rows_minus1 = %d\n", p->num_tile_rows_minus1); va_TraceMsg(trace_ctx, "\tcolumn_width_minus1[19]=\n"); + va_TraceMsg(trace_ctx, ""); for (i = 0; i < 19; i++) { - va_TraceMsg(trace_ctx, "\t%d", p->column_width_minus1[i]); + va_TracePrint(trace_ctx, "\t%d", p->column_width_minus1[i]); if ((i + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); + TRACE_NEWLINE(); } - va_TraceMsg(trace_ctx, "\n"); + va_TracePrint(trace_ctx, "\n"); va_TraceMsg(trace_ctx, "\trow_height_minus1[21]=\n"); + va_TraceMsg(trace_ctx, ""); for (i = 0; i < 21; i++) { - va_TraceMsg(trace_ctx, "\t%d", p->row_height_minus1[i]); + va_TracePrint(trace_ctx, "\t%d", p->row_height_minus1[i]); if ((i + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); + TRACE_NEWLINE(); } - va_TraceMsg(trace_ctx, "\n"); + va_TracePrint(trace_ctx, "\n"); va_TraceMsg(trace_ctx, "\tslice_parsing_fields = %d\n", p->slice_parsing_fields.value); va_TraceMsg(trace_ctx, "\tlists_modification_present_flag = %d\n", p->slice_parsing_fields.bits.lists_modification_present_flag); @@ -1337,12 +2278,12 @@ static void va_TraceVASliceParameterBufferHEVC( int i,j; VASliceParameterBufferHEVC* p = (VASliceParameterBufferHEVC*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); trace_ctx->trace_slice_no++; trace_ctx->trace_slice_size = p->slice_data_size; - va_TraceMsg(trace_ctx, "VASliceParameterBufferHEVC\n"); + va_TracePrint(trace_ctx, "VASliceParameterBufferHEVC\n"); va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size); va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset); va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag); @@ -1350,16 +2291,17 @@ static void va_TraceVASliceParameterBufferHEVC( va_TraceMsg(trace_ctx, "\tslice_segment_address = %d\n", p->slice_segment_address); va_TraceMsg(trace_ctx, "\tRefPicList[2][15]=\n"); + va_TraceMsg(trace_ctx, ""); for (i = 0; i < 2; i++) { for (j = 0; j < 15; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->RefPicList[i][j]); - if ((i*8 + j + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); + va_TracePrint(trace_ctx, "\t%d", p->RefPicList[i][j]); + if ((j + 1) % 8 == 0) + TRACE_NEWLINE(); } + TRACE_NEWLINE(); } - va_TraceMsg(trace_ctx, "\n"); - va_TraceMsg(trace_ctx, "\tLongSliceFlags.value = %d\n", p->LongSliceFlags.value); + va_TracePrint(trace_ctx, "\tLongSliceFlags.value = %d\n", p->LongSliceFlags.value); va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.LastSliceOfPic = %d\n", p->LongSliceFlags.fields.LastSliceOfPic); va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.dependent_slice_segment_flag = %d\n", p->LongSliceFlags.fields.dependent_slice_segment_flag); va_TraceMsg(trace_ctx, "\tLongSliceFlags.fields.slice_type = %d\n", p->LongSliceFlags.fields.slice_type); @@ -1386,94 +2328,343 @@ static void va_TraceVASliceParameterBufferHEVC( va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1); for (i = 0; i <= p->num_ref_idx_l0_active_minus1; i++) { - va_TraceMsg(trace_ctx, "\t%d ", p->delta_luma_weight_l0[i]); - va_TraceMsg(trace_ctx, "\t%d ", p->luma_offset_l0[i]); - va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l0[i][0]); - va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l0[i][1]); - va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL0[i][0]); - va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL0[i][1]); - va_TraceMsg(trace_ctx, "\n"); + va_TraceMsg(trace_ctx, "\t% d ", p->delta_luma_weight_l0[i]); + va_TracePrint(trace_ctx, "\t% d ", p->luma_offset_l0[i]); + va_TracePrint(trace_ctx, "\t% d ", p->delta_chroma_weight_l0[i][0]); + va_TracePrint(trace_ctx, "\t% d ", p->delta_chroma_weight_l0[i][1]); + va_TracePrint(trace_ctx, "\t% d ", p->ChromaOffsetL0[i][0]); + va_TracePrint(trace_ctx, "\t% d ", p->ChromaOffsetL0[i][1]); + va_TracePrint(trace_ctx, "\n"); } va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1); for (i = 0; i <= p->num_ref_idx_l1_active_minus1; i++) { - va_TraceMsg(trace_ctx, "\t%d ", p->delta_luma_weight_l1[i]); - va_TraceMsg(trace_ctx, "\t%d ", p->luma_offset_l1[i]); - va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l1[i][0]); - va_TraceMsg(trace_ctx, "\t%d ", p->delta_chroma_weight_l1[i][1]); - va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL1[i][0]); - va_TraceMsg(trace_ctx, "\t%d ", p->ChromaOffsetL1[i][1]); - va_TraceMsg(trace_ctx, "\n"); + va_TraceMsg(trace_ctx, "\t% d ", p->delta_luma_weight_l1[i]); + va_TracePrint(trace_ctx, "\t% d ", p->luma_offset_l1[i]); + va_TracePrint(trace_ctx, "\t% d ", p->delta_chroma_weight_l1[i][0]); + va_TracePrint(trace_ctx, "\t% d ", p->delta_chroma_weight_l1[i][1]); + va_TracePrint(trace_ctx, "\t% d ", p->ChromaOffsetL1[i][0]); + va_TracePrint(trace_ctx, "\t% d ", p->ChromaOffsetL1[i][1]); + va_TracePrint(trace_ctx, "\n"); + } + + va_TraceMsg(trace_ctx, "\tfive_minus_max_num_merge_cand = %d\n", p->five_minus_max_num_merge_cand); + + va_TraceMsg(trace_ctx, NULL); +} + +static void va_TraceVAIQMatrixBufferHEVC( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data +) +{ + int i, j; + VAIQMatrixBufferHEVC* p = (VAIQMatrixBufferHEVC* )data; + + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + + va_TracePrint(trace_ctx, "VAIQMatrixBufferHEVC\n"); + + va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n"); + va_TraceMsg(trace_ctx, ""); + for (i = 0; i < 6; i++) { + for (j = 0; j < 16; j++) { + va_TracePrint(trace_ctx, "\t%d\t", p->ScalingList4x4[i][j]); + if ((j + 1) % 8 == 0) + TRACE_NEWLINE(); + } + } + + va_TracePrint(trace_ctx, "\tScalingList8x8[6][64]=\n"); + va_TraceMsg(trace_ctx, ""); + for (i = 0; i < 6; i++) { + for (j = 0; j < 64; j++) { + va_TracePrint(trace_ctx, "\t%d", p->ScalingList8x8[i][j]); + if ((j + 1) % 8 == 0) + TRACE_NEWLINE(); + } + } + + va_TracePrint(trace_ctx, "\tScalingList16x16[6][64]=\n"); + va_TraceMsg(trace_ctx, ""); + for (i = 0; i < 6; i++) { + for (j = 0; j < 64; j++) { + va_TracePrint(trace_ctx, "\t%d", p->ScalingList16x16[i][j]); + if ((j + 1) % 8 == 0) + TRACE_NEWLINE(); + } + } + + va_TracePrint(trace_ctx, "\tScalingList32x32[2][64]=\n"); + va_TraceMsg(trace_ctx, ""); + for (i = 0; i < 2; i++) { + for (j = 0; j < 64; j++) { + va_TracePrint(trace_ctx, "\t%d", p->ScalingList32x32[i][j]); + if ((j + 1) % 8 == 0) + TRACE_NEWLINE(); + } + } + + va_TracePrint(trace_ctx, "\tScalingListDC16x16[6]=\n"); + va_TraceMsg(trace_ctx, ""); + for (j = 0; j < 6; j++) { + va_TracePrint(trace_ctx, "\t%d", p->ScalingListDC16x16[j]); + } + va_TracePrint(trace_ctx, "\n"); + va_TraceMsg(trace_ctx, "\tScalingListDC32x32[2]=\n"); + va_TraceMsg(trace_ctx, ""); + for (j = 0; j < 2; j++) { + va_TracePrint(trace_ctx, "\t%d", p->ScalingListDC32x32[j]); + } + va_TracePrint(trace_ctx, "\n"); + + va_TraceMsg(trace_ctx, NULL); +} + +static void va_TraceVAEncSequenceParameterBufferHEVC( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VAEncSequenceParameterBufferHEVC *p = (VAEncSequenceParameterBufferHEVC *)data; + + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + + if(!p) + return; + + va_TracePrint(trace_ctx, "\t--VAEncSequenceParameterBufferHEVC\n"); + + va_TraceMsg(trace_ctx, "\tgeneral_profile_idc = %d\n", p->general_profile_idc); + va_TraceMsg(trace_ctx, "\tgeneral_level_idc = %d\n", p->general_level_idc); + va_TraceMsg(trace_ctx, "\tgeneral_tier_flag = %d\n", p->general_tier_flag); + va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period); + va_TraceMsg(trace_ctx, "\tintra_idr_period = %d\n", p->intra_idr_period); + va_TraceMsg(trace_ctx, "\tip_period = %d\n", p->ip_period); + va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second); + va_TraceMsg(trace_ctx, "\tpic_width_in_luma_samples = %d\n", p->pic_width_in_luma_samples); + va_TraceMsg(trace_ctx, "\tpic_height_in_luma_samples = %d\n", p->pic_height_in_luma_samples); + va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc); + va_TraceMsg(trace_ctx, "\tseparate_colour_plane_flag = %d\n", p->seq_fields.bits.separate_colour_plane_flag); + va_TraceMsg(trace_ctx, "\tbit_depth_luma_minus8 = %d\n", p->seq_fields.bits.bit_depth_luma_minus8); + va_TraceMsg(trace_ctx, "\tbit_depth_chroma_minus8 = %d\n", p->seq_fields.bits.bit_depth_chroma_minus8); + va_TraceMsg(trace_ctx, "\tscaling_list_enabled_flag = %d\n", p->seq_fields.bits.scaling_list_enabled_flag); + va_TraceMsg(trace_ctx, "\tstrong_intra_smoothing_enabled_flag = %d\n", p->seq_fields.bits.strong_intra_smoothing_enabled_flag); + va_TraceMsg(trace_ctx, "\tamp_enabled_flag = %d\n", p->seq_fields.bits.amp_enabled_flag); + va_TraceMsg(trace_ctx, "\tsample_adaptive_offset_enabled_flag = %d\n", p->seq_fields.bits.sample_adaptive_offset_enabled_flag); + va_TraceMsg(trace_ctx, "\tpcm_enabled_flag = %d\n", p->seq_fields.bits.pcm_enabled_flag); + va_TraceMsg(trace_ctx, "\tpcm_loop_filter_disabled_flag = %d\n", p->seq_fields.bits.pcm_loop_filter_disabled_flag); + va_TraceMsg(trace_ctx, "\tsps_temporal_mvp_enabled_flag = %d\n", p->seq_fields.bits.sps_temporal_mvp_enabled_flag); + va_TraceMsg(trace_ctx, "\treserved_bits = %d\n", p->seq_fields.bits.reserved_bits); + va_TraceMsg(trace_ctx, "\tlog2_min_luma_coding_block_size_minus3 = %d\n", p->log2_min_luma_coding_block_size_minus3); + va_TraceMsg(trace_ctx, "\tlog2_diff_max_min_luma_coding_block_size = %d\n", p->log2_diff_max_min_luma_coding_block_size); + va_TraceMsg(trace_ctx, "\tlog2_min_transform_block_size_minus2 = %d\n", p->log2_min_transform_block_size_minus2); + va_TraceMsg(trace_ctx, "\tlog2_diff_max_min_transform_block_size = %d\n", p->log2_diff_max_min_transform_block_size); + va_TraceMsg(trace_ctx, "\tmax_transform_hierarchy_depth_inter = %d\n", p->max_transform_hierarchy_depth_inter); + va_TraceMsg(trace_ctx, "\tmax_transform_hierarchy_depth_intra = %d\n", p->max_transform_hierarchy_depth_intra); + va_TraceMsg(trace_ctx, "\tpcm_sample_bit_depth_luma_minus1 = %d\n", p->pcm_sample_bit_depth_luma_minus1); + va_TraceMsg(trace_ctx, "\tpcm_sample_bit_depth_chroma_minus1 = %d\n", p->pcm_sample_bit_depth_chroma_minus1); + va_TraceMsg(trace_ctx, "\tlog2_min_pcm_luma_coding_block_size_minus3 = %d\n", p->log2_min_pcm_luma_coding_block_size_minus3); + va_TraceMsg(trace_ctx, "\tlog2_max_pcm_luma_coding_block_size_minus3 = %d\n", p->log2_max_pcm_luma_coding_block_size_minus3); + va_TraceMsg(trace_ctx, "\tvui_parameters_present_flag = %d\n", p->vui_parameters_present_flag); + va_TraceMsg(trace_ctx, "\taspect_ratio_info_present_flag = %d\n", p->vui_fields.bits.aspect_ratio_info_present_flag); + va_TraceMsg(trace_ctx, "\tneutral_chroma_indication_flag = %d\n", p->vui_fields.bits.neutral_chroma_indication_flag); + va_TraceMsg(trace_ctx, "\tfield_seq_flag = %d\n", p->vui_fields.bits.field_seq_flag); + va_TraceMsg(trace_ctx, "\tvui_timing_info_present_flag = %d\n", p->vui_fields.bits.vui_timing_info_present_flag); + va_TraceMsg(trace_ctx, "\tbitstream_restriction_flag = %d\n", p->vui_fields.bits.bitstream_restriction_flag); + va_TraceMsg(trace_ctx, "\ttiles_fixed_structure_flag = %d\n", p->vui_fields.bits.tiles_fixed_structure_flag); + va_TraceMsg(trace_ctx, "\tmotion_vectors_over_pic_boundaries_flag = %d\n", p->vui_fields.bits.motion_vectors_over_pic_boundaries_flag); + va_TraceMsg(trace_ctx, "\trestricted_ref_pic_lists_flag = %d\n", p->vui_fields.bits.restricted_ref_pic_lists_flag); + va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_horizontal = %d\n", p->vui_fields.bits.log2_max_mv_length_horizontal); + va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_vertical = %d\n", p->vui_fields.bits.log2_max_mv_length_vertical); + va_TraceMsg(trace_ctx, "\taspect_ratio_idc = %d\n", p->aspect_ratio_idc); + va_TraceMsg(trace_ctx, "\tsar_width = %d\n", p->sar_width); + va_TraceMsg(trace_ctx, "\tsar_height = %d\n", p->sar_height); + va_TraceMsg(trace_ctx, "\tvui_num_units_in_tick = %d\n", p->vui_num_units_in_tick); + va_TraceMsg(trace_ctx, "\tvui_time_scale = %d\n", p->vui_time_scale); + va_TraceMsg(trace_ctx, "\tmin_spatial_segmentation_idc = %d\n", p->min_spatial_segmentation_idc); + va_TraceMsg(trace_ctx, "\tmax_bytes_per_pic_denom = %d\n", p->max_bytes_per_pic_denom); + va_TraceMsg(trace_ctx, "\tmax_bits_per_min_cu_denom = %d\n", p->max_bits_per_min_cu_denom); + + return; +} + +static void va_TraceVAEncPictureParameterBufferHEVC( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + int i; + VAEncPictureParameterBufferHEVC *p = (VAEncPictureParameterBufferHEVC *)data; + + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + + if(!p) + return; + + va_TracePrint(trace_ctx, "\t--VAEncPictureParameterBufferHEVC\n"); + + va_TraceMsg(trace_ctx, "\tdecoded_curr_pic.picture_id = %d\n", p->decoded_curr_pic.picture_id); + va_TraceMsg(trace_ctx, "\tdecoded_curr_pic.pic_order_cnt = %d\n", p->decoded_curr_pic.pic_order_cnt); + va_TraceMsg(trace_ctx, "\tdecoded_curr_pic.flags = %d\n", p->decoded_curr_pic.flags); + + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\treference_frames[%d].picture_id = %d\n", i, p->reference_frames[i].picture_id); + va_TraceMsg(trace_ctx, "\treference_frames[%d].pic_order_cnt = %d\n", i, p->reference_frames[i].pic_order_cnt); + va_TraceMsg(trace_ctx, "\treference_frames[%d].flags = %d\n", i, p->reference_frames[i].flags); + } + + va_TraceMsg(trace_ctx, "\tcoded_buf = %d\n", p->coded_buf); + va_TraceMsg(trace_ctx, "\tcollocated_ref_pic_index = %d\n", p->collocated_ref_pic_index); + va_TraceMsg(trace_ctx, "\tlast_picture = %d\n", p->last_picture); + va_TraceMsg(trace_ctx, "\tpic_init_qp = %d\n", p->pic_init_qp); + va_TraceMsg(trace_ctx, "\tdiff_cu_qp_delta_depth = %d\n", p->diff_cu_qp_delta_depth); + va_TraceMsg(trace_ctx, "\tpps_cb_qp_offset = %d\n", p->pps_cb_qp_offset); + va_TraceMsg(trace_ctx, "\tpps_cr_qp_offset = %d\n", p->pps_cr_qp_offset); + va_TraceMsg(trace_ctx, "\tnum_tile_columns_minus1 = %d\n", p->num_tile_columns_minus1); + va_TraceMsg(trace_ctx, "\tnum_tile_rows_minus1 = %d\n", p->num_tile_rows_minus1); + + for(i = 0; i < 19; i ++) + { + va_TraceMsg(trace_ctx, "\tcolumn_width_minus1[%d] = %d\n", i, p->column_width_minus1[i]); + } + + for(i = 0; i < 21; i ++) + { + va_TraceMsg(trace_ctx, "\trow_height_minus1[%d] = %d\n", i, p->row_height_minus1[i]); } - va_TraceMsg(trace_ctx, "\tfive_minus_max_num_merge_cand = %d\n", p->five_minus_max_num_merge_cand); + va_TraceMsg(trace_ctx, "\tlog2_parallel_merge_level_minus2 = %d\n", p->log2_parallel_merge_level_minus2); + va_TraceMsg(trace_ctx, "\tctu_max_bitsize_allowed = %d\n", p->ctu_max_bitsize_allowed); + va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_default_active_minus1 = %d\n", p->num_ref_idx_l0_default_active_minus1); + va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_default_active_minus1 = %d\n", p->num_ref_idx_l1_default_active_minus1); + va_TraceMsg(trace_ctx, "\tslice_pic_parameter_set_id = %d\n", p->slice_pic_parameter_set_id); + va_TraceMsg(trace_ctx, "\tnal_unit_type = %d\n", p->nal_unit_type); + va_TraceMsg(trace_ctx, "\tidr_pic_flag = %d\n", p->pic_fields.bits.idr_pic_flag); + va_TraceMsg(trace_ctx, "\tcoding_type = %d\n", p->pic_fields.bits.coding_type); + va_TraceMsg(trace_ctx, "\treference_pic_flag = %d\n", p->pic_fields.bits.reference_pic_flag); + va_TraceMsg(trace_ctx, "\tdependent_slice_segments_enabled_flag = %d\n", p->pic_fields.bits.dependent_slice_segments_enabled_flag); + va_TraceMsg(trace_ctx, "\tsign_data_hiding_enabled_flag = %d\n", p->pic_fields.bits.sign_data_hiding_enabled_flag); + va_TraceMsg(trace_ctx, "\tconstrained_intra_pred_flag = %d\n", p->pic_fields.bits.constrained_intra_pred_flag); + va_TraceMsg(trace_ctx, "\ttransform_skip_enabled_flag = %d\n", p->pic_fields.bits.transform_skip_enabled_flag); + va_TraceMsg(trace_ctx, "\tcu_qp_delta_enabled_flag = %d\n", p->pic_fields.bits.cu_qp_delta_enabled_flag); + va_TraceMsg(trace_ctx, "\tweighted_pred_flag = %d\n", p->pic_fields.bits.weighted_pred_flag); + va_TraceMsg(trace_ctx, "\tweighted_bipred_flag = %d\n", p->pic_fields.bits.weighted_bipred_flag); + va_TraceMsg(trace_ctx, "\ttransquant_bypass_enabled_flag = %d\n", p->pic_fields.bits.transquant_bypass_enabled_flag); + va_TraceMsg(trace_ctx, "\ttiles_enabled_flag = %d\n", p->pic_fields.bits.tiles_enabled_flag); + va_TraceMsg(trace_ctx, "\tentropy_coding_sync_enabled_flag = %d\n", p->pic_fields.bits.entropy_coding_sync_enabled_flag); + va_TraceMsg(trace_ctx, "\tloop_filter_across_tiles_enabled_flag = %d\n", p->pic_fields.bits.loop_filter_across_tiles_enabled_flag); + va_TraceMsg(trace_ctx, "\tpps_loop_filter_across_slices_enabled_flag = %d\n", p->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag); + va_TraceMsg(trace_ctx, "\tscaling_list_data_present_flag = %d\n", p->pic_fields.bits.scaling_list_data_present_flag); + va_TraceMsg(trace_ctx, "\tscreen_content_flag = %d\n", p->pic_fields.bits.screen_content_flag); + va_TraceMsg(trace_ctx, "\tenable_gpu_weighted_prediction = %d\n", p->pic_fields.bits.enable_gpu_weighted_prediction); + va_TraceMsg(trace_ctx, "\tno_output_of_prior_pics_flag = %d\n", p->pic_fields.bits.no_output_of_prior_pics_flag); + va_TraceMsg(trace_ctx, "\treserved = %d\n", p->pic_fields.bits.reserved); - va_TraceMsg(trace_ctx, NULL); + return; } -static void va_TraceVAIQMatrixBufferHEVC( +static void va_TraceVAEncSliceParameterBufferHEVC( VADisplay dpy, VAContextID context, VABufferID buffer, VABufferType type, unsigned int size, unsigned int num_elements, - void *data -) + void *data) { - int i, j; - VAIQMatrixBufferHEVC* p = (VAIQMatrixBufferHEVC* )data; + int i; + VAEncSliceParameterBufferHEVC *p = (VAEncSliceParameterBufferHEVC *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); - va_TraceMsg(trace_ctx, "VAIQMatrixBufferHEVC\n"); + if(!p) + return; - va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n"); - for (i = 0; i < 6; i++) { - for (j = 0; j < 16; j++) { - va_TraceMsg(trace_ctx, "\t%d\t", p->ScalingList4x4[i][j]); - if ((j + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); - } - } + va_TracePrint(trace_ctx, "\t--VAEncSliceParameterBufferHEVC\n"); - va_TraceMsg(trace_ctx, "\tScalingList8x8[6][64]=\n"); - for (i = 0; i < 6; i++) { - for (j = 0; j < 64; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->ScalingList8x8[i][j]); - if ((j + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); - } + va_TraceMsg(trace_ctx, "\tslice_segment_address = %d\n", p->slice_segment_address); + va_TraceMsg(trace_ctx, "\tnum_ctu_in_slice = %d\n", p->num_ctu_in_slice); + va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type); + va_TraceMsg(trace_ctx, "\tslice_pic_parameter_set_id = %d\n", p->slice_pic_parameter_set_id); + va_TraceMsg(trace_ctx, "\tnum_ref_idx_l0_active_minus1 = %d\n", p->num_ref_idx_l0_active_minus1); + va_TraceMsg(trace_ctx, "\tnum_ref_idx_l1_active_minus1 = %d\n", p->num_ref_idx_l1_active_minus1); + + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\tref_pic_list0[%d].picture_id = %d\n", i, p->ref_pic_list0[i].picture_id); + va_TraceMsg(trace_ctx, "\tref_pic_list0[%d].pic_order_cnt = %d\n", i, p->ref_pic_list0[i].pic_order_cnt); + va_TraceMsg(trace_ctx, "\tref_pic_list0[%d].flags = %d\n", i, p->ref_pic_list0[i].flags); + va_TraceMsg(trace_ctx, "\tref_pic_list1[%d].picture_id = %d\n", i, p->ref_pic_list1[i].picture_id); + va_TraceMsg(trace_ctx, "\tref_pic_list1[%d].pic_order_cnt = %d\n", i, p->ref_pic_list1[i].pic_order_cnt); + va_TraceMsg(trace_ctx, "\tref_pic_list1[%d].flags = %d\n", i, p->ref_pic_list1[i].flags); } - va_TraceMsg(trace_ctx, "\tScalingList16x16[6][64]=\n"); - for (i = 0; i < 6; i++) { - for (j = 0; j < 64; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->ScalingList16x16[i][j]); - if ((j + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); - } + va_TraceMsg(trace_ctx, "\tluma_log2_weight_denom = %d\n", p->luma_log2_weight_denom); + va_TraceMsg(trace_ctx, "\tdelta_chroma_log2_weight_denom = %d\n", p->delta_chroma_log2_weight_denom); + + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\tdelta_luma_weight_l0[%d] = %d\n", i, p->delta_luma_weight_l0[i]); + va_TraceMsg(trace_ctx, "\tdelta_luma_weight_l1[%d] = %d\n", i, p->delta_luma_weight_l1[i]); } - va_TraceMsg(trace_ctx, "\tScalingList32x32[2][64]=\n"); - for (i = 0; i < 2; i++) { - for (j = 0; j < 64; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->ScalingList32x32[i][j]); - if ((j + 1) % 8 == 0) - va_TraceMsg(trace_ctx, "\n"); - } + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\tluma_offset_l0[%d] = %d\n", i, p->luma_offset_l0[i]); + va_TraceMsg(trace_ctx, "\tluma_offset_l1[%d] = %d\n", i, p->luma_offset_l1[i]); } - va_TraceMsg(trace_ctx, "\tScalingListDC16x16[6]=\n"); - for (j = 0; j < 6; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->ScalingListDC16x16[j]); + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\tdelta_chroma_weight_l0[%d][0] = %d\n", i, p->delta_chroma_weight_l0[i][0]); + va_TraceMsg(trace_ctx, "\tdelta_chroma_weight_l0[%d][1] = %d\n", i, p->delta_chroma_weight_l0[i][1]); + va_TraceMsg(trace_ctx, "\tdelta_chroma_weight_l1[%d][0] = %d\n", i, p->delta_chroma_weight_l1[i][0]); + va_TraceMsg(trace_ctx, "\tdelta_chroma_weight_l1[%d][1] = %d\n", i, p->delta_chroma_weight_l1[i][1]); } - va_TraceMsg(trace_ctx, "\tScalingListDC32x32[2]=\n"); - for (j = 0; j < 2; j++) { - va_TraceMsg(trace_ctx, "\t%d", p->ScalingListDC32x32[j]); + + for(i = 0; i < 15; i ++) + { + va_TraceMsg(trace_ctx, "\tchroma_offset_l0[%d][0] = %d\n", i, p->chroma_offset_l0[i][0]); + va_TraceMsg(trace_ctx, "\tchroma_offset_l0[%d][1] = %d\n", i, p->chroma_offset_l0[i][1]); + va_TraceMsg(trace_ctx, "\tchroma_offset_l1[%d][0] = %d\n", i, p->chroma_offset_l1[i][0]); + va_TraceMsg(trace_ctx, "\tchroma_offset_l1[%d][1] = %d\n", i, p->chroma_offset_l1[i][1]); } - va_TraceMsg(trace_ctx, NULL); + va_TraceMsg(trace_ctx, "\tmax_num_merge_cand = %d\n", p->max_num_merge_cand); + va_TraceMsg(trace_ctx, "\tslice_qp_delta = %d\n", p->slice_qp_delta); + va_TraceMsg(trace_ctx, "\tslice_cb_qp_offset = %d\n", p->slice_cb_qp_offset); + va_TraceMsg(trace_ctx, "\tslice_cr_qp_offset = %d\n", p->slice_cr_qp_offset); + va_TraceMsg(trace_ctx, "\tslice_beta_offset_div2 = %d\n", p->slice_beta_offset_div2); + va_TraceMsg(trace_ctx, "\tslice_tc_offset_div2 = %d\n", p->slice_tc_offset_div2); + va_TraceMsg(trace_ctx, "\tlast_slice_of_pic_flag = %d\n", p->slice_fields.bits.last_slice_of_pic_flag); + va_TraceMsg(trace_ctx, "\tdependent_slice_segment_flag = %d\n", p->slice_fields.bits.dependent_slice_segment_flag); + va_TraceMsg(trace_ctx, "\tcolour_plane_id = %d\n", p->slice_fields.bits.colour_plane_id); + va_TraceMsg(trace_ctx, "\tslice_temporal_mvp_enabled_flag = %d\n", p->slice_fields.bits.slice_temporal_mvp_enabled_flag); + va_TraceMsg(trace_ctx, "\tslice_sao_luma_flag = %d\n", p->slice_fields.bits.slice_sao_luma_flag); + va_TraceMsg(trace_ctx, "\tslice_sao_chroma_flag = %d\n", p->slice_fields.bits.slice_sao_chroma_flag); + va_TraceMsg(trace_ctx, "\tnum_ref_idx_active_override_flag = %d\n", p->slice_fields.bits.num_ref_idx_active_override_flag); + va_TraceMsg(trace_ctx, "\tmvd_l1_zero_flag = %d\n", p->slice_fields.bits.mvd_l1_zero_flag); + va_TraceMsg(trace_ctx, "\tcabac_init_flag = %d\n", p->slice_fields.bits.cabac_init_flag); + va_TraceMsg(trace_ctx, "\tslice_deblocking_filter_disabled_flag = %d\n", p->slice_fields.bits.slice_deblocking_filter_disabled_flag); + va_TraceMsg(trace_ctx, "\tslice_loop_filter_across_slices_enabled_flag = %d\n", p->slice_fields.bits.slice_loop_filter_across_slices_enabled_flag); + va_TraceMsg(trace_ctx, "\tcollocated_from_l0_flag = %d\n", p->slice_fields.bits.collocated_from_l0_flag); + + return; } static void va_TraceVAPictureParameterBufferH264( @@ -1488,13 +2679,13 @@ static void va_TraceVAPictureParameterBufferH264( int i; VAPictureParameterBufferH264 *p = (VAPictureParameterBufferH264*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferH264\n"); va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id); - va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx); - va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags); + va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %u\n", p->CurrPic.frame_idx); + va_TraceMsg(trace_ctx, "\tCurrPic.flags = 0x%08x\n", p->CurrPic.flags); va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt); va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt); @@ -1503,7 +2694,7 @@ static void va_TraceVAPictureParameterBufferH264( { if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) && ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) { - va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n", + va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08u-0x%08x\n", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt, p->ReferenceFrames[i].picture_id, @@ -1524,9 +2715,6 @@ static void va_TraceVAPictureParameterBufferH264( 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); @@ -1559,15 +2747,15 @@ static void va_TraceVASliceParameterBufferH264( { int i; VASliceParameterBufferH264* p = (VASliceParameterBufferH264*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); trace_ctx->trace_slice_no++; trace_ctx->trace_slice_size = p->slice_data_size; va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferH264\n"); - va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size); - va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset); - va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag); + va_TraceMsg(trace_ctx, "\tslice_data_size = %u\n", p->slice_data_size); + va_TraceMsg(trace_ctx, "\tslice_data_offset = %u\n", p->slice_data_offset); + va_TraceMsg(trace_ctx, "\tslice_data_flag = 0x%08x\n", p->slice_data_flag); va_TraceMsg(trace_ctx, "\tslice_data_bit_offset = %d\n", p->slice_data_bit_offset); va_TraceMsg(trace_ctx, "\tfirst_mb_in_slice = %d\n", p->first_mb_in_slice); va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type); @@ -1653,18 +2841,22 @@ static void va_TraceVAIQMatrixBufferH264( { int i, j; VAIQMatrixBufferH264* p = (VAIQMatrixBufferH264* )data; + FILE *fp = NULL; + + DPY2TRACECTX(dpy, context, VA_INVALID_ID); - DPY2TRACECTX(dpy); + if(trace_ctx->plog_file) + fp = trace_ctx->plog_file->fp_log; va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferH264\n"); va_TraceMsg(trace_ctx, "\tScalingList4x4[6][16]=\n"); for (i = 0; i < 6; i++) { for (j = 0; j < 16; j++) { - if (trace_ctx->trace_fp_log) { - fprintf(trace_ctx->trace_fp_log, "\t%d", p->ScalingList4x4[i][j]); + if (fp) { + fprintf(fp, "\t%d", p->ScalingList4x4[i][j]); if ((j + 1) % 8 == 0) - fprintf(trace_ctx->trace_fp_log, "\n"); + fprintf(fp, "\n"); } } } @@ -1672,10 +2864,10 @@ static void va_TraceVAIQMatrixBufferH264( va_TraceMsg(trace_ctx, "\tScalingList8x8[2][64]=\n"); for (i = 0; i < 2; i++) { for (j = 0; j < 64; j++) { - if (trace_ctx->trace_fp_log) { - fprintf(trace_ctx->trace_fp_log,"\t%d", p->ScalingList8x8[i][j]); + if (fp) { + fprintf(fp,"\t%d", p->ScalingList8x8[i][j]); if ((j + 1) % 8 == 0) - fprintf(trace_ctx->trace_fp_log, "\n"); + fprintf(fp, "\n"); } } } @@ -1695,18 +2887,18 @@ static void va_TraceVAEncSequenceParameterBufferH264( void *data) { VAEncSequenceParameterBufferH264 *p = (VAEncSequenceParameterBufferH264 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); unsigned int i; va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH264\n"); va_TraceMsg(trace_ctx, "\tseq_parameter_set_id = %d\n", p->seq_parameter_set_id); va_TraceMsg(trace_ctx, "\tlevel_idc = %d\n", p->level_idc); - va_TraceMsg(trace_ctx, "\tintra_period = %d\n", p->intra_period); - va_TraceMsg(trace_ctx, "\tintra_idr_period = %d\n", p->intra_idr_period); - va_TraceMsg(trace_ctx, "\tip_period = %d\n", p->ip_period); - va_TraceMsg(trace_ctx, "\tbits_per_second = %d\n", p->bits_per_second); - va_TraceMsg(trace_ctx, "\tmax_num_ref_frames = %d\n", p->max_num_ref_frames); + va_TraceMsg(trace_ctx, "\tintra_period = %u\n", p->intra_period); + va_TraceMsg(trace_ctx, "\tintra_idr_period = %u\n", p->intra_idr_period); + va_TraceMsg(trace_ctx, "\tip_period = %u\n", p->ip_period); + va_TraceMsg(trace_ctx, "\tbits_per_second = %u\n", p->bits_per_second); + va_TraceMsg(trace_ctx, "\tmax_num_ref_frames = %u\n", p->max_num_ref_frames); va_TraceMsg(trace_ctx, "\tpicture_width_in_mbs = %d\n", p->picture_width_in_mbs); va_TraceMsg(trace_ctx, "\tpicture_height_in_mbs = %d\n", p->picture_height_in_mbs); va_TraceMsg(trace_ctx, "\tchroma_format_idc = %d\n", p->seq_fields.bits.chroma_format_idc); @@ -1726,10 +2918,10 @@ static void va_TraceVAEncSequenceParameterBufferH264( for(i = 0; (i < p->max_num_ref_frames) && (i < 32); ++i) va_TraceMsg(trace_ctx, "\toffset_for_ref_frame[%d] = %d\n", i, p->offset_for_ref_frame[i]); va_TraceMsg(trace_ctx, "\tframe_cropping_flag = %d\n", p->frame_cropping_flag); - va_TraceMsg(trace_ctx, "\tframe_crop_left_offset = %d\n", p->frame_crop_left_offset); - va_TraceMsg(trace_ctx, "\tframe_crop_right_offset = %d\n", p->frame_crop_right_offset); - va_TraceMsg(trace_ctx, "\tframe_crop_top_offset = %d\n", p->frame_crop_top_offset); - va_TraceMsg(trace_ctx, "\tframe_crop_bottom_offset = %d\n", p->frame_crop_bottom_offset); + va_TraceMsg(trace_ctx, "\tframe_crop_left_offset = %u\n", p->frame_crop_left_offset); + va_TraceMsg(trace_ctx, "\tframe_crop_right_offset = %u\n", p->frame_crop_right_offset); + va_TraceMsg(trace_ctx, "\tframe_crop_top_offset = %u\n", p->frame_crop_top_offset); + va_TraceMsg(trace_ctx, "\tframe_crop_bottom_offset = %u\n", p->frame_crop_bottom_offset); va_TraceMsg(trace_ctx, "\tvui_parameters_present_flag = %d\n", p->vui_parameters_present_flag); va_TraceMsg(trace_ctx, "\taspect_ratio_info_present_flag = %d\n", p->vui_fields.bits.aspect_ratio_info_present_flag); va_TraceMsg(trace_ctx, "\ttiming_info_present_flag = %d\n", p->vui_fields.bits.timing_info_present_flag); @@ -1737,10 +2929,10 @@ static void va_TraceVAEncSequenceParameterBufferH264( va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_horizontal = %d\n", p->vui_fields.bits.log2_max_mv_length_horizontal); va_TraceMsg(trace_ctx, "\tlog2_max_mv_length_vertical = %d\n", p->vui_fields.bits.log2_max_mv_length_vertical); va_TraceMsg(trace_ctx, "\taspect_ratio_idc = %d\n", p->aspect_ratio_idc); - va_TraceMsg(trace_ctx, "\tsar_width = %d\n", p->sar_width); - va_TraceMsg(trace_ctx, "\tsar_height = %d\n", p->sar_height); - va_TraceMsg(trace_ctx, "\tnum_units_in_tick = %d\n", p->num_units_in_tick); - va_TraceMsg(trace_ctx, "\ttime_scale = %d\n", p->time_scale); + va_TraceMsg(trace_ctx, "\tsar_width = %u\n", p->sar_width); + va_TraceMsg(trace_ctx, "\tsar_height = %u\n", p->sar_height); + va_TraceMsg(trace_ctx, "\tnum_units_in_tick = %u\n", p->num_units_in_tick); + va_TraceMsg(trace_ctx, "\ttime_scale = %u\n", p->time_scale); va_TraceMsg(trace_ctx, NULL); @@ -1758,14 +2950,14 @@ static void va_TraceVAEncPictureParameterBufferH264( void *data) { VAEncPictureParameterBufferH264 *p = (VAEncPictureParameterBufferH264 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i; va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH264\n"); va_TraceMsg(trace_ctx, "\tCurrPic.picture_id = 0x%08x\n", p->CurrPic.picture_id); - va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %d\n", p->CurrPic.frame_idx); - va_TraceMsg(trace_ctx, "\tCurrPic.flags = %d\n", p->CurrPic.flags); + va_TraceMsg(trace_ctx, "\tCurrPic.frame_idx = %u\n", p->CurrPic.frame_idx); + va_TraceMsg(trace_ctx, "\tCurrPic.flags = 0x%08x\n", p->CurrPic.flags); va_TraceMsg(trace_ctx, "\tCurrPic.TopFieldOrderCnt = %d\n", p->CurrPic.TopFieldOrderCnt); va_TraceMsg(trace_ctx, "\tCurrPic.BottomFieldOrderCnt = %d\n", p->CurrPic.BottomFieldOrderCnt); va_TraceMsg(trace_ctx, "\tReferenceFrames (TopFieldOrderCnt-BottomFieldOrderCnt-picture_id-frame_idx-flags):\n"); @@ -1773,7 +2965,7 @@ static void va_TraceVAEncPictureParameterBufferH264( { if ((p->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE) && ((p->ReferenceFrames[i].flags & VA_PICTURE_H264_INVALID) == 0)) { - va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08d-0x%08x\n", + va_TraceMsg(trace_ctx, "\t\t%08d-%08d-0x%08x-%08u-0x%08x\n", p->ReferenceFrames[i].TopFieldOrderCnt, p->ReferenceFrames[i].BottomFieldOrderCnt, p->ReferenceFrames[i].picture_id, @@ -1821,7 +3013,7 @@ static void va_TraceVAEncSliceParameterBuffer( void *data) { VAEncSliceParameterBuffer* p = (VAEncSliceParameterBuffer*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBuffer\n"); @@ -1846,15 +3038,15 @@ static void va_TraceVAEncSliceParameterBufferH264( void *data) { VAEncSliceParameterBufferH264* p = (VAEncSliceParameterBufferH264*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i; if (!p) return; va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBufferH264\n"); - va_TraceMsg(trace_ctx, "\tmacroblock_address = %d\n", p->macroblock_address); - va_TraceMsg(trace_ctx, "\tnum_macroblocks = %d\n", p->num_macroblocks); + va_TraceMsg(trace_ctx, "\tmacroblock_address = %u\n", p->macroblock_address); + va_TraceMsg(trace_ctx, "\tnum_macroblocks = %u\n", p->num_macroblocks); va_TraceMsg(trace_ctx, "\tmacroblock_info = %08x\n", p->macroblock_info); va_TraceMsg(trace_ctx, "\tslice_type = %d\n", p->slice_type); va_TraceMsg(trace_ctx, "\tpic_parameter_set_id = %d\n", p->pic_parameter_set_id); @@ -1964,8 +3156,7 @@ static void va_TraceVAEncPackedHeaderParameterBufferType( void *data) { VAEncPackedHeaderParameterBuffer* p = (VAEncPackedHeaderParameterBuffer*)data; - DPY2TRACECTX(dpy); - int i; + DPY2TRACECTX(dpy, context, VA_INVALID_ID); if (!p) return; @@ -1988,7 +3179,7 @@ static void va_TraceVAEncMiscParameterBuffer( void *data) { VAEncMiscParameterBuffer* tmp = (VAEncMiscParameterBuffer*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (tmp->type) { case VAEncMiscParameterTypeFrameRate: @@ -1996,7 +3187,7 @@ static void va_TraceVAEncMiscParameterBuffer( VAEncMiscParameterFrameRate *p = (VAEncMiscParameterFrameRate *)tmp->data; va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterFrameRate\n"); va_TraceMsg(trace_ctx, "\tframerate = %d\n", p->framerate); - + va_TraceMsg(trace_ctx, "\tframerate_flags.temporal_id = %d\n", p->framerate_flags.bits.temporal_id); break; } case VAEncMiscParameterTypeRateControl: @@ -2013,6 +3204,14 @@ static void va_TraceVAEncMiscParameterBuffer( 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); + va_TraceMsg(trace_ctx, "\trc_flags.cfs_I_frames = %d\n", p->rc_flags.bits.cfs_I_frames); + va_TraceMsg(trace_ctx, "\trc_flags.enable_parallel_brc = %d\n", p->rc_flags.bits.enable_parallel_brc); + va_TraceMsg(trace_ctx, "\trc_flags.enable_dynamic_scaling = %d\n", p->rc_flags.bits.enable_dynamic_scaling); + va_TraceMsg(trace_ctx, "\trc_flags.frame_tolerance_mode = %d\n", p->rc_flags.bits.frame_tolerance_mode); + va_TraceMsg(trace_ctx, "\tICQ_quality_factor = %d\n", p->ICQ_quality_factor); + va_TraceMsg(trace_ctx, "\tmax_qp = %d\n", p->max_qp); break; } case VAEncMiscParameterTypeMaxSliceSize: @@ -2050,6 +3249,26 @@ static void va_TraceVAEncMiscParameterBuffer( va_TraceMsg(trace_ctx, "\tmax_frame_size = %d\n", p->max_frame_size); break; } + case VAEncMiscParameterTypeMultiPassFrameSize: + { + int i; + VAEncMiscParameterBufferMultiPassFrameSize *p = (VAEncMiscParameterBufferMultiPassFrameSize *)tmp->data; + + va_TraceMsg(trace_ctx, "\t--VAEncMiscParameterTypeMultiPassFrameSize\n"); + va_TraceMsg(trace_ctx, "\tmax_frame_size = %d\n", p->max_frame_size); + va_TraceMsg(trace_ctx, "\tnum_passes = %d\n", p->num_passes); + for(i = 0; inum_passes; ++i) + va_TraceMsg(trace_ctx, "\tdelta_qp[%d] = %d\n", i, p->delta_qp[i]); + 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); @@ -2072,7 +3291,7 @@ static void va_TraceVAPictureParameterBufferVC1( ) { VAPictureParameterBufferVC1* p = (VAPictureParameterBufferVC1*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVC1\n"); @@ -2177,7 +3396,7 @@ static void va_TraceVASliceParameterBufferVC1( ) { VASliceParameterBufferVC1 *p = (VASliceParameterBufferVC1*)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); trace_ctx->trace_slice_no++; trace_ctx->trace_slice_size = p->slice_data_size; @@ -2202,7 +3421,7 @@ static void va_TraceVAPictureParameterBufferVP8( { char tmp[1024]; VAPictureParameterBufferVP8 *p = (VAPictureParameterBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i,j; va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVP8\n"); @@ -2277,7 +3496,7 @@ static void va_TraceVASliceParameterBufferVP8( void *data) { VASliceParameterBufferVP8 *p = (VASliceParameterBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i; va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVP8\n"); @@ -2307,7 +3526,7 @@ static void va_TraceVAIQMatrixBufferVP8( { char tmp[1024]; VAIQMatrixBufferVP8 *p = (VAIQMatrixBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i,j; va_TraceMsg(trace_ctx, "\t--VAIQMatrixBufferVP8\n"); @@ -2335,7 +3554,7 @@ static void va_TraceVAProbabilityBufferVP8( { char tmp[1024]; VAProbabilityDataBufferVP8 *p = (VAProbabilityDataBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i,j,k,l; va_TraceMsg(trace_ctx, "\t--VAProbabilityDataBufferVP8\n"); @@ -2364,7 +3583,7 @@ static void va_TraceVAEncSequenceParameterBufferVP8( void *data) { VAEncSequenceParameterBufferVP8 *p = (VAEncSequenceParameterBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i; va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferVP8\n"); @@ -2388,6 +3607,99 @@ static void va_TraceVAEncSequenceParameterBufferVP8( 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, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + VADecPictureParameterBufferVP9 *p = (VADecPictureParameterBufferVP9 *)data; + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + int i; + + va_TraceMsg(trace_ctx, "\t--VAPictureParameterBufferVP9\n"); + + va_TraceMsg(trace_ctx, "\tframe_width = %d\n", p->frame_width); + va_TraceMsg(trace_ctx, "\tframe_height = %d\n", p->frame_height); + va_TraceMsg(trace_ctx, "\treference_frames[8] =\n"); + for (i = 0; i < 8; i++) { + va_TraceMsg(trace_ctx, "\t\t0x%x\n", p->reference_frames[i]); + } + va_TraceMsg(trace_ctx, "\tsubsampling_x = %d\n", p->pic_fields.bits.subsampling_x); + va_TraceMsg(trace_ctx, "\tsubsampling_y = %d\n", p->pic_fields.bits.subsampling_y); + va_TraceMsg(trace_ctx, "\tframe_type = %d\n", p->pic_fields.bits.frame_type); + va_TraceMsg(trace_ctx, "\tshow_frame = %d\n", p->pic_fields.bits.show_frame); + va_TraceMsg(trace_ctx, "\terror_resilient_mode = %d\n", p->pic_fields.bits.error_resilient_mode); + va_TraceMsg(trace_ctx, "\tintra_only = %d\n", p->pic_fields.bits.intra_only); + va_TraceMsg(trace_ctx, "\tallow_high_precision_mv = %d\n", p->pic_fields.bits.allow_high_precision_mv); + va_TraceMsg(trace_ctx, "\tmcomp_filter_type = %d\n", p->pic_fields.bits.mcomp_filter_type); + va_TraceMsg(trace_ctx, "\tframe_parallel_decoding_mode = %d\n", p->pic_fields.bits.frame_parallel_decoding_mode); + va_TraceMsg(trace_ctx, "\treset_frame_context = %d\n", p->pic_fields.bits.reset_frame_context); + va_TraceMsg(trace_ctx, "\trefresh_frame_context = %d\n", p->pic_fields.bits.refresh_frame_context); + va_TraceMsg(trace_ctx, "\tframe_context_idx = %d\n", p->pic_fields.bits.frame_context_idx); + va_TraceMsg(trace_ctx, "\tsegmentation_enabled = %d\n", p->pic_fields.bits.segmentation_enabled); + va_TraceMsg(trace_ctx, "\tsegmentation_temporal_update = %d\n", p->pic_fields.bits.segmentation_temporal_update); + va_TraceMsg(trace_ctx, "\tsegmentation_update_map = %d\n", p->pic_fields.bits.segmentation_update_map); + va_TraceMsg(trace_ctx, "\tlast_ref_frame = %d\n", p->pic_fields.bits.last_ref_frame); + va_TraceMsg(trace_ctx, "\tlast_ref_frame_sign_bias = %d\n", p->pic_fields.bits.last_ref_frame_sign_bias); + va_TraceMsg(trace_ctx, "\tgolden_ref_frame = %d\n", p->pic_fields.bits.golden_ref_frame); + va_TraceMsg(trace_ctx, "\tgolden_ref_frame_sign_bias = %d\n", p->pic_fields.bits.golden_ref_frame_sign_bias); + va_TraceMsg(trace_ctx, "\talt_ref_frame = %d\n", p->pic_fields.bits.alt_ref_frame); + va_TraceMsg(trace_ctx, "\talt_ref_frame_sign_bias = %d\n", p->pic_fields.bits.alt_ref_frame_sign_bias); + va_TraceMsg(trace_ctx, "\tlossless_flag = %d\n", p->pic_fields.bits.lossless_flag); + + va_TraceMsg(trace_ctx, "\tfilter_level = %d\n", p->filter_level); + va_TraceMsg(trace_ctx, "\tsharpness_level = %d\n", p->sharpness_level); + 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, "\tframe_header_length_in_bytes = %d\n", p->frame_header_length_in_bytes); + va_TraceMsg(trace_ctx, "\tfirst_partition_size = %d\n", p->first_partition_size); + + va_TraceMsg(trace_ctx, "\tmb_segment_tree_probs[7]: [0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x]\n", + p->mb_segment_tree_probs[0], p->mb_segment_tree_probs[1], + p->mb_segment_tree_probs[2], p->mb_segment_tree_probs[3], + p->mb_segment_tree_probs[4], p->mb_segment_tree_probs[5], + p->mb_segment_tree_probs[6]); + + va_TraceMsg(trace_ctx, "\tsegment_pred_probs[3]: [0x%02x, 0x%02x, 0x%02x]\n", p->segment_pred_probs[0], p->segment_pred_probs[1], p->segment_pred_probs[2]); + + va_TraceMsg(trace_ctx, "\tprofile = %d\n", p->profile); + + va_TraceMsg(trace_ctx, NULL); + + return; +} + static void va_TraceVAEncPictureParameterBufferVP8( VADisplay dpy, VAContextID context, @@ -2398,51 +3710,50 @@ static void va_TraceVAEncPictureParameterBufferVP8( void *data) { VAEncPictureParameterBufferVP8 *p = (VAEncPictureParameterBufferVP8 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); int i; va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferVP8\n"); + va_TraceMsg(trace_ctx, "\treconstructed_frame = 0x%08x\n", p->reconstructed_frame); + va_TraceMsg(trace_ctx, "\tref_last_frame = 0x%08x\n", p->ref_last_frame); + va_TraceMsg(trace_ctx, "\tref_gf_frame = 0x%08x\n", p->ref_gf_frame); + va_TraceMsg(trace_ctx, "\tref_arf_frame = 0x%08x\n", p->ref_arf_frame); + va_TraceMsg(trace_ctx, "\tcoded_buf = 0x%08x\n", p->coded_buf); - va_TraceMsg(trace_ctx, "\treconstructed_frame = 0x%08x\n", i, p->reconstructed_frame); - va_TraceMsg(trace_ctx, "\tref_last_frame = 0x%08x\n", i, p->ref_last_frame); - va_TraceMsg(trace_ctx, "\tref_gf_frame = 0x%08x\n", i, p->ref_gf_frame); - va_TraceMsg(trace_ctx, "\tref_arf_frame = 0x%08x\n", i, p->ref_arf_frame); - va_TraceMsg(trace_ctx, "\tcoded_buf = 0x%08x\n", i, p->coded_buf); - - va_TraceMsg(trace_ctx, "\tref_flags.bits.force_kf = %d\n", i, p->ref_flags.bits.force_kf); - va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_last = %d\n", i, p->ref_flags.bits.no_ref_last); - va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_gf = %d\n", i, p->ref_flags.bits.no_ref_gf); - va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_arf = %d\n", i, p->ref_flags.bits.no_ref_arf); - va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_arf = 0x%08x\n", i, p->ref_flags.bits.reserved); - - va_TraceMsg(trace_ctx, "\tpic_flags.bits.version = %d\n", i, p->pic_flags.bits.version); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.show_frame = %d\n", i, p->pic_flags.bits.show_frame); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.color_space = %d\n", i, p->pic_flags.bits.color_space); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.recon_filter_type = %d\n", i, p->pic_flags.bits.recon_filter_type); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.loop_filter_type = %d\n", i, p->pic_flags.bits.loop_filter_type); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.auto_partitions = %d\n", i, p->pic_flags.bits.auto_partitions); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.num_token_partitions = %d\n", i, p->pic_flags.bits.num_token_partitions); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.clamping_type = %d\n", i, p->pic_flags.bits.clamping_type); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.segmentation_enabled = %d\n", i, p->pic_flags.bits.segmentation_enabled); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.update_mb_segmentation_map = %d\n", i, p->pic_flags.bits.update_mb_segmentation_map); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.update_segment_feature_data = %d\n", i, p->pic_flags.bits.update_segment_feature_data); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.loop_filter_adj_enable = %d\n", i, p->pic_flags.bits.loop_filter_adj_enable); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_entropy_probs = %d\n", i, p->pic_flags.bits.refresh_entropy_probs); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_golden_frame = %d\n", i, p->pic_flags.bits.refresh_golden_frame); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_alternate_frame = %d\n", i, p->pic_flags.bits.refresh_alternate_frame); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_last = %d\n", i, p->pic_flags.bits.refresh_last); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.copy_buffer_to_golden = %d\n", i, p->pic_flags.bits.copy_buffer_to_golden); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.copy_buffer_to_alternate = %d\n", i, p->pic_flags.bits.copy_buffer_to_alternate); - - va_TraceMsg(trace_ctx, "\tpic_flags.bits.sign_bias_golden = %d\n", i, p->pic_flags.bits.sign_bias_golden); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.sign_bias_alternate = %d\n", i, p->pic_flags.bits.sign_bias_alternate); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.mb_no_coeff_skip = %d\n", i, p->pic_flags.bits.mb_no_coeff_skip); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.forced_lf_adjustment = %d\n", i, p->pic_flags.bits.forced_lf_adjustment); - va_TraceMsg(trace_ctx, "\tpic_flags.bits.reserved = %d\n", i, p->pic_flags.bits.reserved); - + va_TraceMsg(trace_ctx, "\tref_flags.bits.force_kf = %d\n", p->ref_flags.bits.force_kf); + va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_last = %d\n", p->ref_flags.bits.no_ref_last); + va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_gf = %d\n", p->ref_flags.bits.no_ref_gf); + va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_arf = %d\n", p->ref_flags.bits.no_ref_arf); + va_TraceMsg(trace_ctx, "\tref_flags.bits.no_ref_arf = 0x%08x\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.version = %d\n", p->pic_flags.bits.version); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.show_frame = %d\n", p->pic_flags.bits.show_frame); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.color_space = %d\n", p->pic_flags.bits.color_space); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.recon_filter_type = %d\n", p->pic_flags.bits.recon_filter_type); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.loop_filter_type = %d\n", p->pic_flags.bits.loop_filter_type); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.auto_partitions = %d\n", p->pic_flags.bits.auto_partitions); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.num_token_partitions = %d\n", p->pic_flags.bits.num_token_partitions); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.clamping_type = %d\n", p->pic_flags.bits.clamping_type); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.segmentation_enabled = %d\n", p->pic_flags.bits.segmentation_enabled); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.update_mb_segmentation_map = %d\n", p->pic_flags.bits.update_mb_segmentation_map); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.update_segment_feature_data = %d\n", p->pic_flags.bits.update_segment_feature_data); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.loop_filter_adj_enable = %d\n", p->pic_flags.bits.loop_filter_adj_enable); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_entropy_probs = %d\n", p->pic_flags.bits.refresh_entropy_probs); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_golden_frame = %d\n", p->pic_flags.bits.refresh_golden_frame); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_alternate_frame = %d\n", p->pic_flags.bits.refresh_alternate_frame); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.refresh_last = %d\n", p->pic_flags.bits.refresh_last); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.copy_buffer_to_golden = %d\n", p->pic_flags.bits.copy_buffer_to_golden); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.copy_buffer_to_alternate = %d\n", p->pic_flags.bits.copy_buffer_to_alternate); + + va_TraceMsg(trace_ctx, "\tpic_flags.bits.sign_bias_golden = %d\n", p->pic_flags.bits.sign_bias_golden); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.sign_bias_alternate = %d\n", p->pic_flags.bits.sign_bias_alternate); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.mb_no_coeff_skip = %d\n", p->pic_flags.bits.mb_no_coeff_skip); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.forced_lf_adjustment = %d\n", p->pic_flags.bits.forced_lf_adjustment); + va_TraceMsg(trace_ctx, "\tpic_flags.bits.reserved = %d\n", p->pic_flags.bits.reserved); for(i=0;i<4;i++) - va_TraceMsg(trace_ctx, "\tloop_filter_level[%d] = %d\n", p->loop_filter_level[i]); + va_TraceMsg(trace_ctx, "\tloop_filter_level[%d] = %d\n", i, p->loop_filter_level[i]); 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<4;i++) @@ -2457,13 +3768,143 @@ static void va_TraceVAEncPictureParameterBufferVP8( 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, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *data) +{ + + VASliceParameterBufferVP9 *p = (VASliceParameterBufferVP9 *)data; + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + int i, j; + + va_TraceMsg(trace_ctx, "\t--VASliceParameterBufferVP9\n"); + + va_TraceMsg(trace_ctx, "\tslice_data_size = %d\n", p->slice_data_size); + va_TraceMsg(trace_ctx, "\tslice_data_offset = %d\n", p->slice_data_offset); + va_TraceMsg(trace_ctx, "\tslice_data_flag = %d\n", p->slice_data_flag); + + for (i = 0; i < 8; i++) { + VASegmentParameterVP9* seg = p->seg_param + i; + va_TraceMsg(trace_ctx, "\tseg_param[%d] = \n", i); + va_TraceMsg(trace_ctx, "\t\tsegment_reference_enabled = %d\n", seg->segment_flags.fields.segment_reference_enabled); + va_TraceMsg(trace_ctx, "\t\tsegment_reference = %d\n", seg->segment_flags.fields.segment_reference); + va_TraceMsg(trace_ctx, "\t\tsegment_reference_skipped = %d\n", seg->segment_flags.fields.segment_reference_skipped); + va_TraceMsg(trace_ctx, "\t\tfilter_level[4][2] = \n"); + for (j = 0; j < 4; j++) { + va_TraceMsg(trace_ctx, "\t\t\t[%3d, %3d]\n", seg->filter_level[j][0], seg->filter_level[j][1]); + } + va_TraceMsg(trace_ctx, "\t\tluma_ac_quant_scale = %d\n", seg->luma_ac_quant_scale); + va_TraceMsg(trace_ctx, "\t\tluma_dc_quant_scale = %d\n", seg->luma_dc_quant_scale); + va_TraceMsg(trace_ctx, "\t\tchroma_ac_quant_scale = %d\n", seg->chroma_ac_quant_scale); + va_TraceMsg(trace_ctx, "\t\tchroma_dc_quant_scale = %d\n", seg->chroma_dc_quant_scale); + } + + va_TraceMsg(trace_ctx, NULL); + + return; +} + void va_TraceBeginPicture( VADisplay dpy, VAContextID context, VASurfaceID render_target ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); TRACE_FUNCNAME(idx); @@ -2544,7 +3985,7 @@ static void va_TraceVAEncSequenceParameterBufferH263( void *data) { VAEncSequenceParameterBufferH263 *p = (VAEncSequenceParameterBufferH263 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncSequenceParameterBufferH263\n"); @@ -2569,7 +4010,7 @@ static void va_TraceVAEncPictureParameterBufferH263( void *data) { VAEncPictureParameterBufferH263 *p = (VAEncPictureParameterBufferH263 *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferH263\n"); va_TraceMsg(trace_ctx, "\treference_picture = 0x%08x\n", p->reference_picture); @@ -2595,7 +4036,7 @@ static void va_TraceVAEncPictureParameterBufferJPEG( VAEncPictureParameterBufferJPEG *p = (VAEncPictureParameterBufferJPEG *)data; int i; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncPictureParameterBufferJPEG\n"); va_TraceMsg(trace_ctx, "\treconstructed_picture = 0x%08x\n", p->reconstructed_picture); @@ -2637,7 +4078,7 @@ static void va_TraceVAEncQMatrixBufferJPEG( void *data) { VAQMatrixBufferJPEG *p = (VAQMatrixBufferJPEG *)data; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAQMatrixBufferJPEG\n"); va_TraceMsg(trace_ctx, "\tload_lum_quantiser_matrix = %d", p->load_lum_quantiser_matrix); @@ -2679,7 +4120,7 @@ static void va_TraceVAEncSliceParameterBufferJPEG( VAEncSliceParameterBufferJPEG *p = (VAEncSliceParameterBufferJPEG *)data; int i; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAEncSliceParameterBufferJPEG\n"); va_TraceMsg(trace_ctx, "\trestart_interval = 0x%04x\n", p->restart_interval); @@ -2879,7 +4320,7 @@ static void va_TraceHEVCBuf( void *pbuf ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (type) { case VAPictureParameterBufferType: @@ -2889,7 +4330,19 @@ static void va_TraceHEVCBuf( va_TraceVASliceParameterBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf); break; case VAIQMatrixBufferType: - va_TraceVAIQMatrixBufferH264(dpy, context, buffer, type, size, num_elements, pbuf); + va_TraceVAIQMatrixBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf); + break; + case VAEncSequenceParameterBufferType: + va_TraceVAEncSequenceParameterBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf); + break; + case VAEncPictureParameterBufferType: + va_TraceVAEncPictureParameterBufferHEVC(dpy, context, buffer, type, size, num_elements, pbuf); + break; + case VAEncSliceParameterBufferType: + va_TraceVAEncSliceParameterBufferHEVC(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); @@ -2907,7 +4360,7 @@ static void va_TraceH264Buf( void *pbuf ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (type) { case VAPictureParameterBufferType: @@ -2979,7 +4432,7 @@ static void va_TraceVP8Buf( void *pbuf ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (type) { case VAPictureParameterBufferType: @@ -3033,6 +4486,40 @@ static void va_TraceVP8Buf( } } +static void va_TraceVP9Buf( + VADisplay dpy, + VAContextID context, + VABufferID buffer, + VABufferType type, + unsigned int size, + unsigned int num_elements, + void *pbuf +) +{ + DPY2TRACECTX(dpy, context, VA_INVALID_ID); + + switch (type) { + 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; + } +} + static void va_TraceVC1Buf( VADisplay dpy, VAContextID context, @@ -3043,7 +4530,7 @@ static void va_TraceVC1Buf( void *pbuf ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (type) { case VAPictureParameterBufferType: @@ -3103,7 +4590,7 @@ va_TraceProcFilterParameterBufferDeinterlacing( { VAProcFilterParameterBufferDeinterlacing *deint = (VAProcFilterParameterBufferDeinterlacing *)base; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t type = %d\n", deint->type); va_TraceMsg(trace_ctx, "\t algorithm = %d\n", deint->algorithm); @@ -3119,7 +4606,7 @@ va_TraceProcFilterParameterBufferColorBalance( { VAProcFilterParameterBufferColorBalance *color_balance = (VAProcFilterParameterBufferColorBalance *)base; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t type = %d\n", color_balance->type); va_TraceMsg(trace_ctx, "\t attrib = %d\n", color_balance->attrib); @@ -3133,7 +4620,7 @@ va_TraceProcFilterParameterBufferBase( VAProcFilterParameterBufferBase *base ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t type = %d\n", base->type); } @@ -3150,9 +4637,9 @@ va_TraceProcFilterParameterBuffer( unsigned int size; unsigned int num_elements; VAProcFilterParameterBufferBase *base_filter = NULL; - int i; + unsigned int i; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); if (num_filters == 0 || filters == NULL) { va_TraceMsg(trace_ctx, "\t num_filters = %d\n", num_filters); @@ -3215,9 +4702,9 @@ va_TraceVAProcPipelineParameterBuffer( ) { VAProcPipelineParameterBuffer *p = (VAProcPipelineParameterBuffer *)data; - int i; + uint32_t i; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); va_TraceMsg(trace_ctx, "\t--VAProcPipelineParameterBuffer\n"); @@ -3302,7 +4789,7 @@ va_TraceNoneBuf( void *pbuf ) { - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); switch (type) { case VAProcPipelineParameterBufferType: @@ -3325,7 +4812,7 @@ void va_TraceRenderPicture( unsigned int size; unsigned int num_elements; int i; - DPY2TRACECTX(dpy); + DPY2TRACECTX(dpy, context, VA_INVALID_ID); TRACE_FUNCNAME(idx); @@ -3343,7 +4830,7 @@ void va_TraceRenderPicture( 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); @@ -3367,7 +4854,6 @@ void va_TraceRenderPicture( va_TraceMPEG4Buf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j); } break; - case VAProfileH264Baseline: case VAProfileH264Main: case VAProfileH264High: case VAProfileH264ConstrainedBaseline: @@ -3425,6 +4911,13 @@ void va_TraceRenderPicture( va_TraceHEVCBuf(dpy, context, buffers[i], type, size, num_elements, pbuf + size*j); } break; + case VAProfileVP9Profile0: + for (j=0; jtrace_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))) - va_TraceSurface(dpy); + 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); + va_TraceSurface(dpy, context); } va_TraceMsg(trace_ctx, NULL); @@ -3474,12 +4967,14 @@ void va_TraceSyncSurface( VASurfaceID render_target ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); va_TraceMsg(trace_ctx, "\trender_target = 0x%08x\n", render_target); va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } void va_TraceQuerySurfaceAttributes( @@ -3489,7 +4984,7 @@ void va_TraceQuerySurfaceAttributes( unsigned int *num_attribs ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); va_TraceMsg(trace_ctx, "\tconfig = 0x%08x\n", config); @@ -3497,6 +4992,7 @@ void va_TraceQuerySurfaceAttributes( va_TraceMsg(trace_ctx, NULL); + DPY2TRACE_VIRCTX_EXIT(pva_trace); } @@ -3506,7 +5002,7 @@ void va_TraceQuerySurfaceStatus( VASurfaceStatus *status /* out */ ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); @@ -3514,6 +5010,8 @@ void va_TraceQuerySurfaceStatus( if (status) va_TraceMsg(trace_ctx, "\tstatus = 0x%08x\n", *status); va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } @@ -3524,7 +5022,7 @@ void va_TraceQuerySurfaceError( void **error_info /*out*/ ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); va_TraceMsg(trace_ctx, "\tsurface = 0x%08x\n", surface); @@ -3539,6 +5037,8 @@ void va_TraceQuerySurfaceError( } } va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } void va_TraceMaxNumDisplayAttributes ( @@ -3546,12 +5046,14 @@ void va_TraceMaxNumDisplayAttributes ( int number ) { - DPY2TRACECTX(dpy); + DPY2TRACE_VIRCTX(dpy); TRACE_FUNCNAME(idx); va_TraceMsg(trace_ctx, "\tmax_display_attributes = %d\n", number); va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } void va_TraceQueryDisplayAttributes ( @@ -3561,43 +5063,45 @@ void va_TraceQueryDisplayAttributes ( ) { int i; - - DPY2TRACECTX(dpy); - + if (attr_list == NULL || num_attributes == NULL) return; + DPY2TRACE_VIRCTX(dpy); + + TRACE_FUNCNAME(idx); va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", *num_attributes); for (i=0; i<*num_attributes; i++) { - va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n"); - va_TraceMsg(trace_ctx, "\t typ = 0x%08x\n", attr_list[i].type); + va_TraceMsg(trace_ctx, "\tattr_list[%d] =\n", i); + va_TraceMsg(trace_ctx, "\t type = 0x%08x\n", attr_list[i].type); va_TraceMsg(trace_ctx, "\t min_value = %d\n", attr_list[i].min_value); va_TraceMsg(trace_ctx, "\t max_value = %d\n", attr_list[i].max_value); va_TraceMsg(trace_ctx, "\t value = %d\n", attr_list[i].value); va_TraceMsg(trace_ctx, "\t flags = %d\n", attr_list[i].flags); } va_TraceMsg(trace_ctx, NULL); + + DPY2TRACE_VIRCTX_EXIT(pva_trace); } static void va_TraceDisplayAttributes ( - VADisplay dpy, + struct trace_context *trace_ctx, VADisplayAttribute *attr_list, int num_attributes ) { int i; - - DPY2TRACECTX(dpy); - - va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", num_attributes); + if (attr_list == NULL) return; - + + va_TraceMsg(trace_ctx, "\tnum_attributes = %d\n", num_attributes); + for (i=0; i