← Back to branch summary

~ubuntu-branches/ubuntu/saucy/openexr/saucy

« back to all changes in this revision

Viewing changes to IlmImfTest/testScanLineApi.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adeodato Simó
  • Date: 2008-03-24 23:00:21 UTC
  • mfrom: (3.1.2 lenny)
  • Revision ID: james.westby@ubuntu.com-20080324230021-gnofz9mnvcj1xlv3
Tags: 1.6.1-3
Disable (hopefully temporarily) the test suite on arm and ia64.

Show diffs side-by-side

added added

removed removed

Lines of Context:
IlmImfTest/testScanLineApi.cpp
41
41
#include <ImfTiledRgbaFile.h>
42
42
#include <ImfRgbaFile.h>
43
43
#include <ImfArray.h>
44
 
#include <ImathRandom.h>
45
44
#include <ImfChannelList.h>
 
45
#include <ImfThreading.h>
 
46
#include "IlmThread.h"
 
47
#include "ImathRandom.h"
46
48
#include <string>
47
49
#include <stdio.h>
48
50
#include <assert.h>
56
58
 
57
59
namespace {
58
60
 
 
61
using Imf::UINT;
 
62
using Imf::HALF;
 
63
using Imf::FLOAT;
 
64
 
59
65
void
60
66
fillPixels (Array2D<unsigned int> &pi,
61
67
            Array2D<half> &ph,
396
402
        }
397
403
    }
398
404
 
 
405
    {
 
406
        cout << endl << "         reading INCREASING_Y "
 
407
                        "(new frame buffer on every line)" << flush;
 
408
 
 
409
        InputFile in (fileName);
 
410
 
 
411
        const Box2i &dw = in.header().dataWindow();
 
412
        int w = dw.max.x - dw.min.x + 1;
 
413
        int h = dw.max.y - dw.min.y + 1;
 
414
        int dwx = dw.min.x;
 
415
        int dwy = dw.min.y;
 
416
 
 
417
        Array2D<unsigned int> pi2 (h, w);
 
418
        Array2D<half>         ph2 (h, w);
 
419
        Array2D<float>        pf2 (h, w);
 
420
 
 
421
        for (int y = dw.min.y; y <= dw.max.y; ++y)
 
422
        {
 
423
            FrameBuffer fb;
 
424
 
 
425
            fb.insert ("I",                                     // name
 
426
                       Slice (UINT,                             // type
 
427
                              (char *) &pi2[y - dwy][-dwx],     // base
 
428
                              sizeof (pi2[0][0]),               // xStride
 
429
                              0)                                // yStride
 
430
                      );
 
431
 
 
432
            fb.insert ("H",                                     // name
 
433
                       Slice (HALF,                             // type
 
434
                              (char *) &ph2[y - dwy][-dwx],     // base
 
435
                              sizeof (ph2[0][0]),               // xStride
 
436
                              0)                                // yStride
 
437
                      );
 
438
 
 
439
            fb.insert ("F",                                     // name
 
440
                       Slice (FLOAT,                            // type
 
441
                              (char *) &pf2[y - dwy][-dwx],     // base
 
442
                              sizeof (pf2[0][0]),               // xStride
 
443
                              0)                                // yStride
 
444
                      );
 
445
 
 
446
            in.setFrameBuffer (fb);
 
447
            in.readPixels (y);
 
448
        }
 
449
 
 
450
        cout << " comparing" << flush;
 
451
 
 
452
        assert (in.header().displayWindow() == hdr.displayWindow());
 
453
        assert (in.header().dataWindow() == hdr.dataWindow());
 
454
        assert (in.header().pixelAspectRatio() == hdr.pixelAspectRatio());
 
455
        assert (in.header().screenWindowCenter() == hdr.screenWindowCenter());
 
456
        assert (in.header().screenWindowWidth() == hdr.screenWindowWidth());
 
457
        assert (in.header().lineOrder() == hdr.lineOrder());
 
458
        assert (in.header().compression() == hdr.compression());
 
459
 
 
460
        ChannelList::ConstIterator hi = hdr.channels().begin();
 
461
        ChannelList::ConstIterator ii = in.header().channels().begin();
 
462
 
 
463
        while (hi != hdr.channels().end())
 
464
        {
 
465
            assert (!strcmp (hi.name(), ii.name()));
 
466
            assert (hi.channel().type == ii.channel().type);
 
467
            assert (hi.channel().xSampling == ii.channel().xSampling);
 
468
            assert (hi.channel().ySampling == ii.channel().ySampling);
 
469
 
 
470
            ++hi;
 
471
            ++ii;
 
472
        }
 
473
 
 
474
        assert (ii == in.header().channels().end());
 
475
 
 
476
        for (int y = 0; y < h; ++y)
 
477
        {
 
478
            for (int x = 0; x < w; ++x)
 
479
            {
 
480
                assert (pi1[y][x] == pi2[y][x]);
 
481
                assert (ph1[y][x] == ph2[y][x]);
 
482
                assert (pf1[y][x] == pf2[y][x]);
 
483
            }
 
484
        }    
 
485
    }
 
486
 
399
487
    remove (fileName);
400
488
    cout << endl;
401
489
}
443
531
        Array2D<float> pf (H, W);
444
532
        fillPixels (pi, ph, pf, W, H);
445
533
 
446
 
        for (int lorder = 0; lorder < NUM_LINEORDERS; ++lorder)
 
534
        int maxThreads = IlmThread::supportsThreads()? 3: 0;
 
535
 
 
536
        for (int n = 0; n <= maxThreads; ++n)
447
537
        {
448
 
            for (int rmode = 0; rmode < NUM_ROUNDINGMODES; ++rmode)
449
 
            {
450
 
                writeRead (pi, ph, pf,  W, H, 
451
 
                           LineOrder (lorder),
452
 
                           ZIP_COMPRESSION,
453
 
                           LevelRoundingMode (rmode),
454
 
                           0, 0, 1, 1);
455
 
 
456
 
                writeRead (pi, ph, pf, W, H, 
457
 
                           LineOrder (lorder),
458
 
                           ZIP_COMPRESSION,
459
 
                           LevelRoundingMode (rmode),
460
 
                           DX, DY, 1, 1);
461
 
                
462
 
                writeRead (pi, ph, pf, W, H,
463
 
                           LineOrder (lorder),
464
 
                           ZIP_COMPRESSION,
465
 
                           LevelRoundingMode (rmode),
466
 
                           0, 0, 24, 26);
467
 
 
468
 
                writeRead (pi, ph, pf, W, H,
469
 
                           LineOrder (lorder),
470
 
                           ZIP_COMPRESSION,
471
 
                           LevelRoundingMode (rmode),
472
 
                           DX, DY, 24, 26);
473
 
                
474
 
                writeRead (pi, ph, pf, W, H,
475
 
                           LineOrder (lorder),
476
 
                           ZIP_COMPRESSION,
477
 
                           LevelRoundingMode (rmode),
478
 
                           0, 0, 48, 81);
479
 
 
480
 
                writeRead (pi, ph, pf, W, H,
481
 
                           LineOrder (lorder),
482
 
                           ZIP_COMPRESSION,
483
 
                           LevelRoundingMode (rmode),
484
 
                           DX, DY, 48, 81);
485
 
                           
486
 
                writeRead (pi, ph, pf, W, H,
487
 
                           LineOrder (lorder),
488
 
                           ZIP_COMPRESSION,
489
 
                           LevelRoundingMode (rmode),
490
 
                           0, 0, 128, 96);
491
 
 
492
 
                writeRead (pi, ph, pf, W, H,
493
 
                           LineOrder (lorder),
494
 
                           ZIP_COMPRESSION,
495
 
                           LevelRoundingMode (rmode),
496
 
                           DX, DY, 128, 96);
 
538
            if (IlmThread::supportsThreads())
 
539
            {
 
540
                setGlobalThreadCount (n);
 
541
                cout << "\nnumber of threads: " << globalThreadCount() << endl;
 
542
            }
 
543
 
 
544
            for (int lorder = 0; lorder < NUM_LINEORDERS; ++lorder)
 
545
            {
 
546
                for (int rmode = 0; rmode < NUM_ROUNDINGMODES; ++rmode)
 
547
                {
 
548
                    writeRead (pi, ph, pf,  W, H, 
 
549
                               LineOrder (lorder),
 
550
                               ZIP_COMPRESSION,
 
551
                               LevelRoundingMode (rmode),
 
552
                               0, 0, 1, 1);
 
553
 
 
554
                    writeRead (pi, ph, pf, W, H, 
 
555
                               LineOrder (lorder),
 
556
                               ZIP_COMPRESSION,
 
557
                               LevelRoundingMode (rmode),
 
558
                               DX, DY, 1, 1);
 
559
                    
 
560
                    writeRead (pi, ph, pf, W, H,
 
561
                               LineOrder (lorder),
 
562
                               ZIP_COMPRESSION,
 
563
                               LevelRoundingMode (rmode),
 
564
                               0, 0, 24, 26);
 
565
 
 
566
                    writeRead (pi, ph, pf, W, H,
 
567
                               LineOrder (lorder),
 
568
                               ZIP_COMPRESSION,
 
569
                               LevelRoundingMode (rmode),
 
570
                               DX, DY, 24, 26);
 
571
                    
 
572
                    writeRead (pi, ph, pf, W, H,
 
573
                               LineOrder (lorder),
 
574
                               ZIP_COMPRESSION,
 
575
                               LevelRoundingMode (rmode),
 
576
                               0, 0, 48, 81);
 
577
 
 
578
                    writeRead (pi, ph, pf, W, H,
 
579
                               LineOrder (lorder),
 
580
                               ZIP_COMPRESSION,
 
581
                               LevelRoundingMode (rmode),
 
582
                               DX, DY, 48, 81);
 
583
                               
 
584
                    writeRead (pi, ph, pf, W, H,
 
585
                               LineOrder (lorder),
 
586
                               ZIP_COMPRESSION,
 
587
                               LevelRoundingMode (rmode),
 
588
                               0, 0, 128, 96);
 
589
 
 
590
                    writeRead (pi, ph, pf, W, H,
 
591
                               LineOrder (lorder),
 
592
                               ZIP_COMPRESSION,
 
593
                               LevelRoundingMode (rmode),
 
594
                               DX, DY, 128, 96);
 
595
                }
497
596
            }
498
597
        }
499
598