EERRenderer Class Reference

Public Member Functions
	EERRenderer ()
	~EERRenderer ()
	EERRenderer (const EERRenderer &)
EERRenderer &	operator= (const EERRenderer &)
void	setFramesOfInterest (int start, int end)
void	read (const FileName &_fn_movie, int eer_upsampling)
int	getNFrames ()
int	getWidth ()
int	getHeight ()
template<typename T >
long long	renderFrames (int frame_start, int frame_end, MultidimArray< T > &image)

Static Public Member Functions
static void	TIFFWarningHandler (const char *module, const char *fmt, va_list ap)
static void	silenceTIFFWarnings ()
static bool	isEER (const FileName &fn_movie)

Detailed Description

Definition at line 71 of file rwEER.cpp.

Constructor & Destructor Documentation

EERRenderer() [1/2]

EERRenderer::EERRenderer ( )

inline

Definition at line 221 of file rwEER.cpp.

    {
        ready = false;
        read_data = false;
        buf = NULL;
        preread_start = -1;
        preread_end = -1;
        eer_upsampling = 2;
    }

~EERRenderer()

EERRenderer::~EERRenderer ( )

inline

Definition at line 231 of file rwEER.cpp.

    {
        if (buf != NULL)
            free(buf);
    }

EERRenderer() [2/2]

EERRenderer::EERRenderer ( const EERRenderer &  )

inline

Definition at line 238 of file rwEER.cpp.

    {
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "Copy constructor for EERRenderer not implemented yet.");
    }

Member Function Documentation

getHeight()

int EERRenderer::getHeight ( )

inline

Definition at line 376 of file rwEER.cpp.

    {
        if (!ready)
            REPORT_ERROR(ERR_LOGIC_ERROR, "EERRenderer::getNFrames called before ready.");

        return EER_IMAGE_HEIGHT << (eer_upsampling - 1);
    }

getNFrames()

int EERRenderer::getNFrames ( )

inline

Definition at line 360 of file rwEER.cpp.

    {
        if (!ready)
            REPORT_ERROR(ERR_LOGIC_ERROR, "EERRenderer::getNFrames called before ready.");

        return nframes;
    }

getWidth()

int EERRenderer::getWidth ( )

inline

Definition at line 368 of file rwEER.cpp.

    {
        if (!ready)
            REPORT_ERROR(ERR_LOGIC_ERROR, "EERRenderer::getNFrames called before ready.");

        return EER_IMAGE_WIDTH << (eer_upsampling - 1);
    }

isEER()

static bool EERRenderer::isEER ( const FileName &  fn_movie )

inlinestatic

Definition at line 551 of file rwEER.cpp.

    {
        FileName ext = fn_movie.getExtension();
        return (ext == "eer"  || ext == "ecc");
    }

operator=()

EERRenderer& EERRenderer::operator= ( const EERRenderer &  )

inline

Definition at line 243 of file rwEER.cpp.

    {
        REPORT_ERROR(ERR_NOT_IMPLEMENTED, "Copy assignment operator for EERRenderer not implemented yet.");
    }

read()

void EERRenderer::read ( const FileName &  _fn_movie, int  eer_upsampling  )

inline

Definition at line 286 of file rwEER.cpp.

    {
        if (ready)
            REPORT_ERROR(ERR_LOGIC_ERROR, "Logic error: you cannot recycle EERRenderer for multiple files (now)");

        if (eer_upsampling == 1 || eer_upsampling == 2 || eer_upsampling == 3)
            this->eer_upsampling = eer_upsampling;
        else
        {
            std::cerr << "EERRenderer::read: eer_upsampling = " << eer_upsampling << std::endl;
            REPORT_ERROR(ERR_PARAM_INCORRECT, "EERRenderer::read: eer_upsampling must be 1, 2 or 3.");
        }

        fn_movie = _fn_movie;

        // First of all, check the file size
        FILE *fh = fopen(fn_movie.c_str(), "r");
        if (fh == NULL)
            REPORT_ERROR(ERR_IO_NOTOPEN, "Failed to open " + fn_movie);

        fseek(fh, 0, SEEK_END);
        file_size = ftell(fh);
        fseek(fh, 0, SEEK_SET);

        silenceTIFFWarnings();

        // Try reading as TIFF
        TIFF *ftiff = TIFFOpen(fn_movie.c_str(), "r");

        if (ftiff == NULL)
        {
            is_legacy = true;
            is_7bit = false;
            readLegacy(fh);
        }
        else
        {
            is_legacy = false;

            // Check width & size
            int width, height;
            uint16_t compression = 0;
            TIFFGetField(ftiff, TIFFTAG_IMAGEWIDTH, &width);
            TIFFGetField(ftiff, TIFFTAG_IMAGELENGTH, &height);
            TIFFGetField(ftiff, TIFFTAG_COMPRESSION, &compression);

    #ifdef DEBUG_EER
            printf("EER in TIFF: %s size = %ld, width = %d, height = %d, compression = %d\n", fn_movie.c_str(), file_size, width, height, compression);
    #endif

            // TIA can write an EER file whose first page is a sum and compressoin == 1.
            // This is not supported (yet). EPU never writes such movies.
            if (compression == EERRenderer::TIFF_COMPRESSION_EER8bit)
                is_7bit = false;
            else if (compression == EERRenderer::TIFF_COMPRESSION_EER7bit)
                is_7bit = true;
            else
                REPORT_ERROR(ERR_PARAM_INCORRECT, "Unknown compression scheme for EER " + integerToString(compression));

            if (width != EER_IMAGE_WIDTH || height != EER_IMAGE_HEIGHT)
                REPORT_ERROR(ERR_PARAM_INCORRECT, "Currently we support only 4096x4096 pixel EER movies.");

            // Find the number of frames
            nframes = TIFFNumberOfDirectories(ftiff);
            TIFFClose(ftiff);
    #ifdef DEBUG_EER
            printf("EER in TIFF: %s nframes = %d\n", fn_movie.c_str(), nframes);
    #endif
        }

        fclose(fh);
        ready = true;
    }

renderFrames()

template<typename T >

long long EERRenderer::renderFrames ( int  frame_start, int  frame_end, MultidimArray< T > &  image  )

inline

Definition at line 389 of file rwEER.cpp.

    {
        if (!ready)
            REPORT_ERROR(ERR_LOGIC_ERROR, "EERRenderer::renderNFrames called before ready.");

        lazyReadFrames();

        if (frame_start < 0 || frame_start >= getNFrames() ||
                frame_end < frame_start || frame_end >= getNFrames())
        {
            std::cerr << "EERRenderer::renderFrames(frame_start = " << frame_start << ", frame_end = " << frame_end << "),  NFrames = " << getNFrames() << std::endl;
            REPORT_ERROR(ERR_PARAM_INCORRECT, "Invalid frame range was requested.");
        }

        long long total_n_electron = 0;

        std::vector<unsigned int> positions;
        std::vector<unsigned char> symbols;
        image.initZeros(getHeight(), getWidth());

        for (int iframe = frame_start; iframe <= frame_end; iframe++)
        {
            RCTIC(TIMING_UNPACK_RLE);
            if ((preread_start > 0 && iframe < preread_start) ||
                        (preread_end > 0 && iframe > preread_end))
            {
                std::cerr << "EERRenderer::renderFrames(frame_start = " << frame_start + 1 << ", frame_end = " << frame_end + 1<< "),  NFrames = " << getNFrames() << " preread_start = " << preread_start + 1 << " prered_end = " << preread_end + 1<< std::endl;
                REPORT_ERROR(ERR_LOGIC_ERROR, "Tried to render frames outside pre-read region");
            }       

            long long pos = frame_starts[iframe];
            unsigned int n_pix = 0, n_electron = 0;
            const int max_electrons = frame_sizes[iframe] * 2; // at 4 bits per electron (very permissive bound!)
            if (positions.size() < max_electrons)
            {
                positions.resize(max_electrons);
                symbols.resize(max_electrons);
            }

            if (is_7bit)
            {
                unsigned int bit_pos = 0; // 4 K * 4 K * 11 bit << 2 ** 32
                unsigned char p, s;

                while (true)
                {
                    // Fetch 32 bits and unpack up to 2 chunks of 7 + 4 bits.
                    // This is faster than unpack 7 and 4 bits sequentially.
                    // Since the size of buf is larger than the actual size by the TIFF header size,
                    // it is always safe to read ahead.

                    long long first_byte = pos + (bit_pos >> 3);
                    const unsigned int bit_offset_in_first_byte = bit_pos & 7; // 7 = 00000111 (same as % 8)
                    const unsigned int chunk = (*(unsigned int*)(buf + first_byte)) >> bit_offset_in_first_byte;

                    p = (unsigned char)(chunk & 127); // 127 = 01111111
                    bit_pos += 7; // TODO: we can remove this for further speed.
                    n_pix += p;
                    if (n_pix >= EER_IMAGE_PIXELS) break;
                    if (p == 127) continue; // this should be rare.
                    
                    s = (unsigned char)((chunk >> 7) & 15) ^ 0x0A; // 15 = 00001111; See below for 0x0A
                    bit_pos += 4;
                    positions[n_electron] = n_pix;
                    symbols[n_electron] = s;
                    n_electron++;
                    n_pix++;

                    p = (unsigned char)((chunk >> 11) & 127); // 127 = 01111111
                    bit_pos += 7;
                    n_pix += p;
                    if (n_pix >= EER_IMAGE_PIXELS) break;
                    if (p == 127) continue;
                    
                    s = (unsigned char)((chunk >> 18) & 15) ^ 0x0A; // 15 = 00001111; See below for 0x0A
                    bit_pos += 4;
                    positions[n_electron] = n_pix;
                    symbols[n_electron] = s;
                    n_electron++;
                    n_pix++;
                }
            }
            else
            {
                // unpack every two symbols = 12 bit * 2 = 24 bit = 3 byte
                // high <- |bbbbBBBB|BBBBaaaa|AAAAAAAA| -> low
                // With SIMD intrinsics at the SSSE3 level, we can unpack 10 symbols (120 bits) simultaneously.
                unsigned char p1, p2, s1, s2;

                const long long pos_limit = frame_starts[iframe] + frame_sizes[iframe];
                // Because there is a footer, it is safe to go beyond the limit by two bytes.
                while (pos < pos_limit)
                {
                    // symbol is bit tricky. 0000YyXx; Y and X must be flipped.
                    p1 = buf[pos];
                    s1 = (buf[pos + 1] & 0x0F) ^ 0x0A; // 0x0F = 00001111, 0x0A = 00001010

                    p2 = (buf[pos + 1] >> 4) | (buf[pos + 2] << 4);
                    s2 = (buf[pos + 2] >> 4) ^ 0x0A;

                    // Note the order. Add p before checking the size and placing a new electron.
                    n_pix += p1;
                    if (n_pix >= EER_IMAGE_PIXELS) break;
                    if (p1 < 255)
                    {
                        positions[n_electron] = n_pix;
                        symbols[n_electron] = s1;
                        n_electron++;
                        n_pix++;
                    }

                    n_pix += p2;
                    if (n_pix >= EER_IMAGE_PIXELS) break;
                    if (p2 < 255)
                    {
                        positions[n_electron] = n_pix;
                        symbols[n_electron] = s2;
                        n_electron++;
                        n_pix++;
                    }
    #ifdef DEBUG_EER_DETAIL
                    printf("%d: %u %u, %u %u %d\n", pos, p1, s1, p2, s2, n_pix);
    #endif
                    pos += 3;
                }
            }

            if (n_pix != EER_IMAGE_PIXELS)
            {
                std::cerr << "WARNING: The number of pixels is not right in " + fn_movie + " frame " + integerToString(iframe + 1) + ". Probably this frame is corrupted. This frame is skipped." << std::endl;
                continue;
            }

            RCTOC(TIMING_UNPACK_RLE);

            RCTIC(TIMING_RENDER_ELECTRONS);
            if (eer_upsampling == 3)
                render16K(image, positions, symbols, n_electron);
            else if (eer_upsampling == 2)
                render8K(image, positions, symbols, n_electron);
            else if (eer_upsampling == 1)
                render4K(image, positions, symbols, n_electron);
            else
                REPORT_ERROR(ERR_LOGIC_ERROR, "Invalid EER upsample");
            RCTOC(TIMING_RENDER_ELECTRONS);

            total_n_electron += n_electron;
    #ifdef DEBUG_EER
            printf("Decoded %lld electrons / %d pixels from frame %5d.\n", n_electron, n_pix, iframe);
    #endif
        }
    #ifdef DEBUG_EER
        printf("Decoded %lld electrons in total.\n", total_n_electron);
    #endif

    #ifdef TIMING
        EERtimer.printTimes(false);
    #endif

        return total_n_electron;
    }

setFramesOfInterest()

void EERRenderer::setFramesOfInterest ( int  start, int  end  )

inline

Definition at line 275 of file rwEER.cpp.

    {
        if (is_legacy)
            return;

        if (read_data)
            REPORT_ERROR(ERR_LOGIC_ERROR, "Logic error in EERRenderer::setFramesOfInterest(). This must be set before rendering.");
        preread_start = start - 1;
        preread_end = end - 1;
    }

silenceTIFFWarnings()

static void EERRenderer::silenceTIFFWarnings ( )

inlinestatic

Definition at line 259 of file rwEER.cpp.

    {
        if (prevTIFFWarningHandler == NULL)
        {
            // Thread safety issue:
            // Calling this simultaneously is safe but
            TIFFErrorHandler prev = TIFFSetWarningHandler(EERRenderer::TIFFWarningHandler);

            // we have to make sure prevTIFFWarningHandler does NOT become our own TIFFWarningHandler
            // to avoid an infinite loop.
            if (prev != EERRenderer::TIFFWarningHandler)
                prevTIFFWarningHandler = prev;
        }
    }

TIFFWarningHandler()

static void EERRenderer::TIFFWarningHandler ( const char *  module, const char *  fmt, va_list  ap  )

inlinestatic

Definition at line 249 of file rwEER.cpp.

    {
        // Silence warnings for private tags
        if (strcmp("Unknown field with tag %d (0x%x) encountered", fmt) == 0)
            return;

        if (prevTIFFWarningHandler != NULL)
            prevTIFFWarningHandler(module, fmt, ap);
    }

---

The documentation for this class was generated from the following file:

• xmippCore/core/rwEER.cpp