static int process_input(const char* input, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
sk_tools::ImageResultsSummary *jsonSummaryPtr) {
SkOSFile::Iter iter(input, "skp");
SkString inputFilename;
int failures = 0;
SkDebugf("process_input, %s\n", input);
if (iter.next(&inputFilename)) {
do {
SkString inputPath;
SkString inputAsSkString(input);
sk_tools::make_filepath(&inputPath, inputAsSkString, inputFilename);
if (!render_picture(inputPath, outputDir, renderer, jsonSummaryPtr)) {
++failures;
}
} while(iter.next(&inputFilename));
} else if (SkStrEndsWith(input, ".skp")) {
SkString inputPath(input);
if (!render_picture(inputPath, outputDir, renderer, jsonSummaryPtr)) {
++failures;
}
} else {
SkString warning;
warning.printf("Warning: skipping %s\n", input);
SkDebugf(warning.c_str());
}
return failures;
}
static int process_input(const SkString& input, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
bool validate, bool writeWholeImage, int clones) {
SkOSFile::Iter iter(input.c_str(), "skp");
SkString inputFilename;
int failures = 0;
SkDebugf("process_input, %s\n", input.c_str());
if (iter.next(&inputFilename)) {
do {
SkString inputPath;
sk_tools::make_filepath(&inputPath, input, inputFilename);
if (!render_picture(inputPath, outputDir, renderer,
validate, writeWholeImage, clones)) {
++failures;
}
} while(iter.next(&inputFilename));
} else if (SkStrEndsWith(input.c_str(), ".skp")) {
SkString inputPath(input);
if (!render_picture(inputPath, outputDir, renderer,
validate, writeWholeImage, clones)) {
++failures;
}
} else {
SkString warning;
warning.printf("Warning: skipping %s\n", input.c_str());
SkDebugf(warning.c_str());
}
return failures;
}
static int process_input(const char* input, const SkString* writePath,
const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
SkOSFile::Iter iter(input, "skp");
SkString inputFilename;
int failures = 0;
SkDebugf("process_input, %s\n", input);
if (iter.next(&inputFilename)) {
do {
SkString inputPath = SkOSPath::Join(input, inputFilename.c_str());
if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
++failures;
}
} while(iter.next(&inputFilename));
} else if (SkStrEndsWith(input, ".skp")) {
SkString inputPath(input);
if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
++failures;
}
} else {
SkString warning;
warning.printf("Warning: skipping %s\n", input);
SkDebugf("%s", warning.c_str());
}
return failures;
}
int ff_vaapi_common_end_frame(MpegEncContext *s)
{
struct vaapi_context * const vactx = s->avctx->hwaccel_context;
int ret = -1;
av_dlog(s->avctx, "ff_vaapi_common_end_frame()\n");
if (commit_slices(vactx) < 0)
goto done;
if (vactx->n_slice_buf_ids > 0) {
if (render_picture(vactx, ff_vaapi_get_surface_id(s->current_picture_ptr)) < 0)
goto done;
ff_draw_horiz_band(s, 0, s->avctx->height);
}
ret = 0;
done:
destroy_buffers(vactx->display, &vactx->pic_param_buf_id, 1);
destroy_buffers(vactx->display, &vactx->iq_matrix_buf_id, 1);
destroy_buffers(vactx->display, &vactx->bitplane_buf_id, 1);
destroy_buffers(vactx->display, vactx->slice_buf_ids, vactx->n_slice_buf_ids);
av_freep(&vactx->slice_buf_ids);
av_freep(&vactx->slice_params);
vactx->n_slice_buf_ids = 0;
vactx->slice_buf_ids_alloc = 0;
vactx->slice_count = 0;
vactx->slice_params_alloc = 0;
return ret;
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
bool validate,
bool writeWholeImage,
int clones) {
SkBitmap* bitmap = NULL;
bool success = render_picture(inputPath,
writeWholeImage ? NULL : outputDir,
renderer,
validate || writeWholeImage ? &bitmap : NULL, clones);
if (!success || ((validate || writeWholeImage) && bitmap == NULL)) {
SkDebugf("Failed to draw the picture.\n");
SkDELETE(bitmap);
return false;
}
if (validate) {
SkBitmap* referenceBitmap = NULL;
sk_tools::SimplePictureRenderer referenceRenderer;
success = render_picture(inputPath, NULL, referenceRenderer,
&referenceBitmap, 0);
if (!success || !referenceBitmap) {
SkDebugf("Failed to draw the reference picture.\n");
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->width() != referenceBitmap->width())) {
SkDebugf("Expected image width: %i, actual image width %i.\n",
referenceBitmap->width(), bitmap->width());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->height() != referenceBitmap->height())) {
SkDebugf("Expected image height: %i, actual image height %i",
referenceBitmap->height(), bitmap->height());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
for (int y = 0; success && y < bitmap->height(); y++) {
for (int x = 0; success && x < bitmap->width(); x++) {
if (*referenceBitmap->getAddr32(x, y) != *bitmap->getAddr32(x, y)) {
SkDebugf("Expected pixel at (%i %i): 0x%x, actual 0x%x\n",
x, y,
*referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
#ifdef VALIDATE_FAILURE_IS_A_TOOL_FAILURE
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
#else
goto DONE;
#endif
}
}
}
DONE:
SkDELETE(referenceBitmap);
}
if (writeWholeImage) {
sk_tools::force_all_opaque(*bitmap);
if (NULL != outputDir && writeWholeImage) {
SkString inputFilename;
sk_tools::get_basename(&inputFilename, inputPath);
SkString outputPath;
make_output_filepath(&outputPath, *outputDir, inputFilename);
outputPath.append(".png");
if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap,
SkImageEncoder::kPNG_Type, 100)) {
SkDebugf("Failed to draw the picture.\n");
success = false;
}
}
}
SkDELETE(bitmap);
return success;
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
bool validate, int maxComponentDiff,
bool writeWholeImage,
int clones) {
int diffs[256] = {0};
SkBitmap* bitmap = NULL;
bool success = render_picture(inputPath,
writeWholeImage ? NULL : outputDir,
renderer,
validate || writeWholeImage ? &bitmap : NULL, clones);
if (!success || ((validate || writeWholeImage) && bitmap == NULL)) {
SkDebugf("Failed to draw the picture.\n");
SkDELETE(bitmap);
return false;
}
if (validate) {
SkBitmap* referenceBitmap = NULL;
sk_tools::SimplePictureRenderer referenceRenderer;
success = render_picture(inputPath, NULL, referenceRenderer,
&referenceBitmap, 0);
if (!success || !referenceBitmap) {
SkDebugf("Failed to draw the reference picture.\n");
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->width() != referenceBitmap->width())) {
SkDebugf("Expected image width: %i, actual image width %i.\n",
referenceBitmap->width(), bitmap->width());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->height() != referenceBitmap->height())) {
SkDebugf("Expected image height: %i, actual image height %i",
referenceBitmap->height(), bitmap->height());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
for (int y = 0; success && y < bitmap->height(); y++) {
for (int x = 0; success && x < bitmap->width(); x++) {
int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
SkASSERT(diff >= 0 && diff <= 255);
diffs[diff]++;
if (diff > maxComponentDiff) {
SkDebugf("Expected pixel at (%i %i) exceedds maximum "
"component diff of %i: 0x%x, actual 0x%x\n",
x, y, maxComponentDiff,
*referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
}
}
SkDELETE(referenceBitmap);
for (int i = 1; i <= 255; ++i) {
if(diffs[i] > 0) {
SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
}
}
}
if (writeWholeImage) {
sk_tools::force_all_opaque(*bitmap);
if (NULL != outputDir && writeWholeImage) {
SkString inputFilename;
sk_tools::get_basename(&inputFilename, inputPath);
SkString outputPath;
make_output_filepath(&outputPath, *outputDir, inputFilename);
outputPath.append(".png");
if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap,
SkImageEncoder::kPNG_Type, 100)) {
SkDebugf("Failed to draw the picture.\n");
success = false;
}
}
}
SkDELETE(bitmap);
return success;
}
