static void
read_bin_file(const char * filename)
{
uint32_t buf[16384];
int fd, offset, ret;
if (!strcmp(filename, "-"))
fd = fileno(stdin);
else
fd = open (filename, O_RDONLY);
if (fd < 0) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
exit (1);
}
drm_intel_decode_set_dump_past_end(ctx, 1);
offset = 0;
while ((ret = read (fd, buf, sizeof(buf))) > 0) {
drm_intel_decode_set_batch_pointer(ctx, buf, offset, ret/4);
drm_intel_decode(ctx);
offset += ret;
}
close (fd);
}
static void
read_data_file(const char * filename)
{
FILE *file;
uint32_t *data = NULL;
int data_size = 0, count = 0, line_number = 0, matched;
char *line = NULL;
size_t line_size;
uint32_t offset, value;
uint32_t gtt_offset = 0;
if (!strcmp(filename, "-"))
file = stdin;
else
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
exit (1);
}
while (getline (&line, &line_size, file) > 0) {
line_number++;
matched = sscanf (line, "%08x : %08x", &offset, &value);
if (matched != 2) {
printf("ignoring line %s", line);
continue;
}
count++;
if (count > data_size) {
data_size = data_size ? data_size * 2 : 1024;
data = realloc (data, data_size * sizeof (uint32_t));
if (data == NULL) {
fprintf (stderr, "Out of memory.\n");
exit (1);
}
}
data[count-1] = value;
}
if (count) {
drm_intel_decode_set_batch_pointer(ctx, data, gtt_offset, count);
drm_intel_decode(ctx);
}
free (data);
free (line);
fclose (file);
}
static void
dump_batch(struct drm_intel_decode *ctx, const char *batch_filename)
{
void *batch_ptr;
size_t batch_size;
read_file(batch_filename, &batch_ptr, &batch_size);
drm_intel_decode_set_batch_pointer(ctx, batch_ptr, HW_OFFSET,
batch_size / 4);
drm_intel_decode_set_output_file(ctx, stdout);
drm_intel_decode(ctx);
}
static void
compare_batch(struct drm_intel_decode *ctx, const char *batch_filename)
{
FILE *out = NULL;
void *ptr, *ref_ptr, *batch_ptr;
#if HAVE_OPEN_MEMSTREAM
size_t size;
#endif
size_t ref_size, batch_size;
const char *ref_suffix = "-ref.txt";
char *ref_filename;
ref_filename = malloc(strlen(batch_filename) + strlen(ref_suffix) + 1);
sprintf(ref_filename, "%s%s", batch_filename, ref_suffix);
/* Read the batch and reference. */
read_file(batch_filename, &batch_ptr, &batch_size);
read_file(ref_filename, &ref_ptr, &ref_size);
/* Set up our decode output in memory, because I don't want to
* figure out how to output to a file in a safe and sane way
* inside of an automake project's test infrastructure.
*/
#if HAVE_OPEN_MEMSTREAM
out = open_memstream((char **)&ptr, &size);
#else
fprintf(stderr, "platform lacks open_memstream, skipping.\n");
exit(77);
#endif
drm_intel_decode_set_batch_pointer(ctx, batch_ptr, HW_OFFSET,
batch_size / 4);
drm_intel_decode_set_output_file(ctx, out);
drm_intel_decode(ctx);
if (strcmp(ref_ptr, ptr) != 0) {
fprintf(stderr, "Decode mismatch with reference `%s'.\n",
ref_filename);
fprintf(stderr, "You can dump the new output using:\n");
fprintf(stderr, " test_decode \"%s\" -dump\n", batch_filename);
exit(1);
}
fclose(out);
free(ref_filename);
free(ptr);
}
void
intel_winsys_decode_bo(struct intel_winsys *winsys,
struct intel_bo *bo, int used)
{
void *ptr;
ptr = intel_bo_map(bo, false);
if (!ptr) {
debug_printf("failed to map buffer for decoding\n");
return;
}
pipe_mutex_lock(winsys->mutex);
if (!winsys->decode) {
winsys->decode = drm_intel_decode_context_alloc(winsys->info.devid);
if (!winsys->decode) {
pipe_mutex_unlock(winsys->mutex);
intel_bo_unmap(bo);
return;
}
/* debug_printf()/debug_error() uses stderr by default */
drm_intel_decode_set_output_file(winsys->decode, stderr);
}
/* in dwords */
used /= 4;
drm_intel_decode_set_batch_pointer(winsys->decode,
ptr, gem_bo(bo)->offset64, used);
drm_intel_decode(winsys->decode);
pipe_mutex_unlock(winsys->mutex);
intel_bo_unmap(bo);
}
