DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
SkBitmap bm = create_bm();
const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
desc, SkBudgeted::kNo,
bm.getPixels(), bm.rowBytes()));
if (!proxy) {
return;
}
sk_sp<SkSpecialImage> fullSImg(SkSpecialImage::MakeDeferredFromGpu(
context,
SkIRect::MakeWH(kFullSize, kFullSize),
kNeedNewImageUniqueID_SpecialImage,
proxy, nullptr));
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
{
sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeDeferredFromGpu(
context, subset,
kNeedNewImageUniqueID_SpecialImage,
std::move(proxy), nullptr));
test_image(subSImg1, reporter, context, true, kPad, kFullSize);
}
{
sk_sp<SkSpecialImage> subSImg2(fullSImg->makeSubset(subset));
test_image(subSImg2, reporter, context, true, kPad, kFullSize);
}
}
int main()
{
test_image();
test_marchingcube();
test_marchingcubeGen();
test_windowing();
return 0;
}
DEF_TEST(SpecialImage_Raster, reporter) {
SkBitmap bm = create_bm();
sk_sp<SkSpecialImage> fullSImage(SkSpecialImage::MakeFromRaster(
SkIRect::MakeWH(kFullSize, kFullSize),
bm));
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
{
sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeFromRaster(subset, bm));
test_image(subSImg1, reporter, nullptr, false, kPad, kFullSize);
}
{
sk_sp<SkSpecialImage> subSImg2(fullSImage->makeSubset(subset));
test_image(subSImg2, reporter, nullptr, false, 0, kSmallerSize);
}
}
void unit_test(void)
{
test_constants_and_sizes();
test_rectangle();
test_image();
test_gray();
test_streams();
test_image_io();
test_gray_io();
}
static void test_specialimage_image(skiatest::Reporter* reporter, SkColorSpace* dstColorSpace) {
SkBitmap bm = create_bm();
sk_sp<SkImage> fullImage(SkImage::MakeFromBitmap(bm));
sk_sp<SkSpecialImage> fullSImage(SkSpecialImage::MakeFromImage(
SkIRect::MakeWH(kFullSize, kFullSize),
fullImage, dstColorSpace));
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
{
sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeFromImage(subset, fullImage,
dstColorSpace));
test_image(subSImg1, reporter, nullptr, false, kPad, kFullSize);
}
{
sk_sp<SkSpecialImage> subSImg2(fullSImage->makeSubset(subset));
test_image(subSImg2, reporter, nullptr, false, 0, kSmallerSize);
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
SkBitmap bm = create_bm();
GrSurfaceDesc desc;
desc.fConfig = kSkia8888_GrPixelConfig;
desc.fFlags = kNone_GrSurfaceFlags;
desc.fWidth = kFullSize;
desc.fHeight = kFullSize;
sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
desc, SkBudgeted::kNo,
bm.getPixels(), 0));
if (!proxy) {
return;
}
sk_sp<SkSpecialImage> fullSImg(SkSpecialImage::MakeDeferredFromGpu(
context,
SkIRect::MakeWH(kFullSize, kFullSize),
kNeedNewImageUniqueID_SpecialImage,
proxy, nullptr));
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
{
sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeDeferredFromGpu(
context, subset,
kNeedNewImageUniqueID_SpecialImage,
std::move(proxy), nullptr));
test_image(subSImg1, reporter, context, true, kPad, kFullSize);
}
{
sk_sp<SkSpecialImage> subSImg2(fullSImg->makeSubset(subset));
test_image(subSImg2, reporter, context, true, kPad, kFullSize);
}
}
void png_suite_test(const char *path_to_png_suite, const char *path_to_rgba_files) {
const int num_files = sizeof(filenames)/sizeof(filenames[0]);
printf("Testing %i files in path \"%s\".\n", num_files, path_to_png_suite);
double startTime = (double)clock()/CLOCKS_PER_SEC;
int num_failures = 0;
for (int i = 0; i < num_files; i++) {
bool success = test_image(path_to_png_suite, path_to_rgba_files, filenames[i], true);
if (!success) {
num_failures++;
}
else {
success = test_image(path_to_png_suite, path_to_rgba_files, filenames[i], false);
if (!success) {
num_failures++;
}
}
}
double endTime = (double)clock()/CLOCKS_PER_SEC;
double elapsedTime = endTime - startTime;
printf("Success: %i of %i\n", (num_files-num_failures), num_files);
printf("Duration: %f seconds\n", (float)elapsedTime);
}
int main(int argc, char* argv[]) {
test_pixel();
test_channel();
test_pixel_iterator();
test_image_io();
const char* local_name = "gil_reference_checksums.txt";
const char* name_from_status = "../libs/gil/test/gil_reference_checksums.txt";
std::ifstream file_is_there(local_name);
if (file_is_there) {
test_image(local_name);
} else {
std::ifstream file_is_there(name_from_status);
if (file_is_there)
test_image(name_from_status);
else {
std::cerr << "Unable to open gil_reference_checksums.txt"<<std::endl;
return 1;
}
}
return 0;
}
int main(int argc, unsigned char* argv[])
{
#ifdef NO_ASL
//test_integral_image();
//performance_test();
#endif
test_resample();
test_convolve();
test_pixel();
// test_pixel_iterator();
// test_image_io();
test_image();
// test_image_tiler();
return 0;
}
DEF_TEST(SpecialImage_Pixmap, reporter) {
SkAutoPixmapStorage pixmap;
const SkImageInfo info = SkImageInfo::MakeN32(kFullSize, kFullSize, kOpaque_SkAlphaType);
pixmap.alloc(info);
pixmap.erase(SK_ColorGREEN);
const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
pixmap.erase(SK_ColorRED, subset);
{
sk_sp<SkSpecialImage> img(SkSpecialImage::MakeFromPixmap(subset, pixmap,
nullptr, nullptr));
test_image(img, reporter, nullptr, false, kPad, kFullSize);
}
}
static void
validate_accessible (Accessible *accessible,
gboolean has_parent,
gboolean recurse_down)
{
Accessible *tmp;
char *name, *descr;
AccessibleRole role;
AccessibleRelation **relations;
char *role_name;
GString *item_str = g_string_new ("");
int i;
name = Accessible_getName (accessible);
g_assert (name != NULL);
descr = Accessible_getDescription (accessible);
g_assert (descr != NULL);
role = Accessible_getRole (accessible);
g_assert (role != SPI_ROLE_INVALID);
role_name = Accessible_getRoleName (accessible);
g_assert (role_name != NULL);
relations = Accessible_getRelationSet (accessible);
g_assert (relations != NULL);
for (i = 0; relations [i]; i++) {
AccessibleRelationType type;
int targets;
fprintf (stderr, "relation %d\n", i);
type = AccessibleRelation_getRelationType (relations [i]);
g_assert (type != SPI_RELATION_NULL);
targets = AccessibleRelation_getNTargets (relations [i]);
g_assert (targets != -1);
AccessibleRelation_unref (relations [i]);
relations [i] = NULL;
}
free (relations);
if (print_tree) {
int i;
for (i = 0; i < print_tree_depth; i++)
fputc (' ', stderr);
fputs ("|-> [ ", stderr);
}
if (Accessible_isAction (accessible)) {
tmp = Accessible_getAction (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "At");
else
test_action (tmp);
AccessibleAction_unref (tmp);
}
if (Accessible_isApplication (accessible)) {
tmp = Accessible_getApplication (accessible);
if (print_tree)
fprintf (stderr, "Ap");
else
test_application (tmp);
AccessibleApplication_unref (tmp);
}
if (Accessible_isComponent (accessible)) {
tmp = Accessible_getComponent (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Co");
else
test_component (tmp);
AccessibleComponent_unref (tmp);
}
if (Accessible_isEditableText (accessible)) {
tmp = Accessible_getEditableText (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Et");
else
test_editable_text (tmp);
AccessibleEditableText_unref (tmp);
}
if (Accessible_isHypertext (accessible)) {
tmp = Accessible_getHypertext (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Ht");
AccessibleHypertext_unref (tmp);
}
if (Accessible_isImage (accessible)) {
tmp = Accessible_getImage (accessible);
g_assert (tmp != NULL);
if (print_tree) {
char *desc;
fprintf (stderr, "Im");
desc = AccessibleImage_getImageDescription (tmp);
g_string_append_printf (
item_str, " image descr: '%s'", desc);
SPI_freeString (desc);
} else
test_image (tmp);
AccessibleImage_unref (tmp);
}
if (Accessible_isSelection (accessible)) {
tmp = Accessible_getSelection (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Se");
AccessibleSelection_unref (tmp);
}
if (Accessible_isTable (accessible)) {
tmp = Accessible_getTable (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Ta");
else
test_table (tmp);
AccessibleTable_unref (tmp);
}
if (Accessible_isText (accessible)) {
tmp = Accessible_getText (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Te");
else {
if (strcmp (name, TEST_STRING_A_OBJECT) == 0)
test_text (tmp);
}
AccessibleText_unref (tmp);
}
if (Accessible_isValue (accessible)) {
tmp = Accessible_getValue (accessible);
g_assert (tmp != NULL);
if (print_tree)
fprintf (stderr, "Va");
else
test_value (tmp);
AccessibleValue_unref (tmp);
}
if (print_tree)
fprintf (stderr, " ] '%s' (%s) - %s: %s\n",
name, descr, role_name, item_str->str);
SPI_freeString (name);
SPI_freeString (descr);
SPI_freeString (role_name);
g_string_free (item_str, TRUE);
validate_tree (accessible, has_parent, recurse_down);
}
int main(int argc, char *argv[]) {
opj_cinfo_t* cinfo;
opj_event_mgr_t event_mgr; /* event manager */
unsigned int snum;
opj_mj2_t *movie;
mj2_sample_t *sample;
unsigned char* frame_codestream;
FILE *mj2file, *j2kfile;
char *j2kfilename;
unsigned char *buf;
int offset, mdat_initpos;
opj_image_t img;
opj_cio_t *cio;
mj2_cparameters_t parameters;
if (argc != 3) {
printf("Usage: %s source_location mj2_filename\n",argv[0]);
printf("Example: %s input/input output.mj2\n",argv[0]);
return 1;
}
mj2file = fopen(argv[2], "wb");
if (!mj2file) {
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
return 1;
}
memset(&img, 0, sizeof(opj_image_t));
/*
configure the event callbacks (not required)
setting of each callback is optionnal
*/
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
/* get a MJ2 decompressor handle */
cinfo = mj2_create_compress();
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the decoder encoding parameters using user parameters */
memset(¶meters, 0, sizeof(mj2_cparameters_t));
movie = (opj_mj2_t*) cinfo->mj2_handle;
j2kfilename = (char*)malloc(strlen(argv[1]) + 12);/* max. '%6d' */
sprintf(j2kfilename, "%s_00001.j2k",argv[1]);
if(test_image(j2kfilename, ¶meters) == 0) goto fin;
parameters.frame_rate = 25; /* DEFAULT */
mj2_setup_encoder(movie, ¶meters);
/* Writing JP, FTYP and MDAT boxes
Assuming that the JP and FTYP boxes won't be longer than 300 bytes */
buf = (unsigned char*) malloc (300 * sizeof(unsigned char));
cio = opj_cio_open(movie->cinfo, buf, 300);
mj2_write_jp(cio);
mj2_write_ftyp(movie, cio);
mdat_initpos = cio_tell(cio);
cio_skip(cio, 4);
cio_write(cio,MJ2_MDAT, 4);
fwrite(buf,cio_tell(cio),1,mj2file);
free(buf);
// Insert each j2k codestream in a JP2C box
snum=0;
offset = 0;
while(1)
{
sample = &movie->tk[0].sample[snum];
sprintf(j2kfilename,"%s_%05d.j2k",argv[1],snum);
j2kfile = fopen(j2kfilename, "rb");
if (!j2kfile) {
if (snum==0) { // Could not open a single codestream
fprintf(stderr, "failed to open %s for reading\n",j2kfilename);
return 1;
}
else { // Tried to open a inexistant codestream
fprintf(stdout,"%d frames are being added to the MJ2 file\n",snum);
break;
}
}
// Calculating offset for samples and chunks
offset += cio_tell(cio);
sample->offset = offset;
movie->tk[0].chunk[snum].offset = offset; // There will be one sample per chunk
// Calculating sample size
fseek(j2kfile,0,SEEK_END);
sample->sample_size = ftell(j2kfile) + 8; // Sample size is codestream + JP2C box header
fseek(j2kfile,0,SEEK_SET);
// Reading siz marker of j2k image for the first codestream
if (snum==0)
read_siz_marker(j2kfile, &img);
// Writing JP2C box header
frame_codestream = (unsigned char*) malloc (sample->sample_size+8);
cio = opj_cio_open(movie->cinfo, frame_codestream, sample->sample_size);
cio_write(cio,sample->sample_size, 4); // Sample size
cio_write(cio,JP2_JP2C, 4); // JP2C
// Writing codestream from J2K file to MJ2 file
fread(frame_codestream+8,sample->sample_size-8,1,j2kfile);
fwrite(frame_codestream,sample->sample_size,1,mj2file);
cio_skip(cio, sample->sample_size-8);
// Ending loop
fclose(j2kfile);
snum++;
movie->tk[0].sample = (mj2_sample_t*)
realloc(movie->tk[0].sample, (snum+1) * sizeof(mj2_sample_t));
movie->tk[0].chunk = (mj2_chunk_t*)
realloc(movie->tk[0].chunk, (snum+1) * sizeof(mj2_chunk_t));
free(frame_codestream);
}
// Writing the MDAT box length in header
offset += cio_tell(cio);
buf = (unsigned char*) malloc (4 * sizeof(unsigned char));
cio = opj_cio_open(movie->cinfo, buf, 4);
cio_write(cio,offset-mdat_initpos,4);
fseek(mj2file,(long)mdat_initpos,SEEK_SET);
fwrite(buf,4,1,mj2file);
fseek(mj2file,0,SEEK_END);
free(buf);
// Setting movie parameters
movie->tk[0].num_samples=snum;
movie->tk[0].num_chunks=snum;
setparams(movie, &img);
// Writing MOOV box
buf = (unsigned char*) malloc ((TEMP_BUF+snum*20) * sizeof(unsigned char));
cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF+snum*20));
mj2_write_moov(movie, cio);
fwrite(buf,cio_tell(cio),1,mj2file);
// Ending program
free(img.comps);
opj_cio_close(cio);
fin:
fclose(mj2file);
mj2_destroy_compress(movie);
free(j2kfilename);
return 0;
}