Class: Composite::Image

Inherits:

Object

• Object
• Composite::Image

Defined in:

ext/giflib/composite.c

Instance Method Summary

• #addFrame(image) ⇒ Object
• #compose(image, x, y) ⇒ Object
• #encode ⇒ Object
• #getDelayTimeForFrame(frame) ⇒ Object
• #getHeight ⇒ Object
• #getImageCount ⇒ Object
• #getNFrames ⇒ Object
• #getSavedImageExtensionBlockCount(index) ⇒ Object
• #getWidth ⇒ Object
• #initialize(rubyGifString) ⇒ Object constructor
• #setDelayTimeForFrame(frame, delay) ⇒ Object

Constructor Details

#initialize(rubyGifString) ⇒ Object

# File 'ext/giflib/composite.c', line 118

static VALUE initialize(VALUE self, VALUE rubyGifString) {
    struct RubyImage *rubyImage;
    struct RubyString *cGifString;
    int errorCode, i;
    struct GraphicsControlBlock *gcb;
   
    Check_Type(rubyGifString, T_STRING);
    
    Data_Get_Struct(self, struct RubyImage, rubyImage);
    cGifString = getRubyString(rubyGifString);

    // Read gif from Ruby
    if ( (rubyImage->gifFileType = DGifOpen(cGifString, readGifFromMemory, &errorCode)) == NULL ) {
        rb_raise(rb_eException, "Could not read gif, giflib error code %d.", errorCode);
    }
    if (DGifSlurp(rubyImage->gifFileType) == GIF_ERROR) {
        rb_raise(rb_eException, "Could not decode gif, giflib error code %d.", rubyImage->gifFileType->Error);
    }
    if ( (gcb = calloc(rubyImage->gifFileType->ImageCount, sizeof(struct GraphicsControlBlock))) == NULL) {
        rb_raise(rb_eException, "Insufficient memory.");
    }
    
    rubyImage->graphicsControlBlock = gcb;
    for (i = 0; i < rubyImage->gifFileType->ImageCount; i++) {
        readGraphicsControlBlock(rubyImage, i);
    }
    return self;
}

Instance Method Details

#addFrame(image) ⇒ Object

# File 'ext/giflib/composite.c', line 307

static VALUE addFrame(VALUE self, VALUE image) {
    struct RubyImage *current;
    struct RubyImage *newImage;
    GifFileType *currentGif;
    GifFileType *imageGif;
    GraphicsControlBlock *first;
    GraphicsControlBlock *last;
    
    Data_Get_Struct(self, struct RubyImage, current);
    Data_Get_Struct(image, struct RubyImage, newImage);
    currentGif = current->gifFileType;
    imageGif = newImage->gifFileType;

    GifMakeSavedImage(currentGif, imageGif->SavedImages);

    current->graphicsControlBlock = realloc(current->graphicsControlBlock, sizeof(GraphicsControlBlock) * currentGif->ImageCount);
    if (current->graphicsControlBlock == NULL) {
        rb_raise(rb_eException, "Insufficient memory");
    }
    // Copy contents of first Graphics control block into last Graphics control block (so that it is not jibberish)
    first = current->graphicsControlBlock;
    last = current->graphicsControlBlock + currentGif->ImageCount - 1;
    last->DisposalMode = first->DisposalMode;
    last->UserInputFlag = first->UserInputFlag;
    last->DelayTime = first->DelayTime;
    last->TransparentColor = first->TransparentColor;
    return self;
}

#compose(image, x, y) ⇒ Object

# File 'ext/giflib/composite.c', line 275

static VALUE compose(VALUE self, VALUE image, VALUE x, VALUE y) {
	struct RubyImage *current;
	struct RubyImage *compose;
	GifFileType *gifCurrent;
	GifFileType *gifCompose;
	int gifX;
	int gifY;

	Check_Type(x, T_FIXNUM);
	Check_Type(y, T_FIXNUM);

	Data_Get_Struct(self, struct RubyImage, current);
	Data_Get_Struct(image, struct RubyImage, compose);
	gifCurrent = current->gifFileType;
	gifCompose = compose->gifFileType;
	gifX = FIX2INT(x);
	gifY = FIX2INT(y);

	if (gifX < 0) {
		rb_raise(rb_eException, "Compose x value must be >= 0 (not %d).", gifX);
	} else if (gifY < 0) {
		rb_raise(rb_eException, "Compose y value must be >= 0 (not %d).", gifY);
	} else if (gifX + gifCompose->SWidth > gifCurrent->SWidth) {
		rb_raise(rb_eException, "Composite would extend over the end of the current image (current image width: %d, x: %d, composite image width %d)", gifCurrent->SWidth, gifX, gifCompose->SWidth);
	} else if (gifY + gifCompose->SHeight > gifCurrent->SHeight) {
		rb_raise(rb_eException, "Composite would extend over the end of the current image (current image height: %d, y: %d, composite image height %d)", gifCurrent->SHeight, gifY, gifCompose->SHeight);
	}
	
	giflibCompose(gifCurrent, gifCompose, gifX, gifY);
	return Qnil;
}

#encode ⇒ Object

# File 'ext/giflib/composite.c', line 219

static VALUE encode(VALUE self) {
	struct RubyImage *rubyImage;
	struct RubyString *rubyString;
    int i;
    VALUE result;
    
    Data_Get_Struct(self, struct RubyImage, rubyImage);

	rubyString = newRubyString();
    for (i = 0; i < rubyImage->gifFileType->ImageCount; i++) {
        writeGraphicsControlBlock(rubyImage, i);
    }
	writeToMemory(rubyImage->gifFileType, rubyString);
    
	result = rb_str_new(rubyString->text, rubyString->current);
    return result;
}

#getDelayTimeForFrame(frame) ⇒ Object

# File 'ext/giflib/composite.c', line 356

static VALUE getDelayTimeForFrame(VALUE self, VALUE frame) {
    struct RubyImage *current;
    int frameIndex, delayTime;
    
    Data_Get_Struct(self, struct RubyImage, current);
    frameIndex = FIX2INT(frame);
    delayTime = getDelayTimeFromGraphicsControlBlock(current, frameIndex);
    
    return INT2FIX(delayTime);
}

#getHeight ⇒ Object

# File 'ext/giflib/composite.c', line 243

static VALUE getHeight(VALUE self) {
	struct RubyImage * rubyImage;
	Data_Get_Struct(self, struct RubyImage, rubyImage);
	return INT2FIX(rubyImage->gifFileType->SHeight);
}

#getImageCount ⇒ Object

# File 'ext/giflib/composite.c', line 249

static VALUE getImageCount(VALUE self) {
	struct RubyImage * rubyImage;
	Data_Get_Struct(self, struct RubyImage, rubyImage);
	return INT2FIX(rubyImage->gifFileType->ImageCount);
}

#getNFrames ⇒ Object

# File 'ext/giflib/composite.c', line 336

static VALUE getNFrames(VALUE self) {
    struct RubyImage *current;
    
    Data_Get_Struct(self, struct RubyImage, current);
    return INT2FIX(current->gifFileType->ImageCount);
}

#getSavedImageExtensionBlockCount(index) ⇒ Object

# File 'ext/giflib/composite.c', line 367

static VALUE getSavedImageExtensionBlockCount(VALUE self, VALUE index) {
    struct RubyImage *current;
    int intIndex;
    
    Data_Get_Struct(self, struct RubyImage, current);
    intIndex = FIX2INT(index);
    return INT2FIX(current->gifFileType->SavedImages[intIndex].ExtensionBlockCount);
}

#getWidth ⇒ Object

# File 'ext/giflib/composite.c', line 237

static VALUE getWidth(VALUE self) {
	struct RubyImage * rubyImage;
	Data_Get_Struct(self, struct RubyImage, rubyImage);
	return INT2FIX(rubyImage->gifFileType->SWidth);
}

#setDelayTimeForFrame(frame, delay) ⇒ Object

# File 'ext/giflib/composite.c', line 343

static VALUE setDelayTimeForFrame(VALUE self, VALUE frame, VALUE delay) {
    // http://giflib.sourceforge.net/gif_lib.html#idp49255104
    struct RubyImage *current;
    int frameIndex, delayTime;
    
    Data_Get_Struct(self, struct RubyImage, current);
    frameIndex = FIX2INT(frame);
    delayTime = FIX2INT(delay);
    
    setDelayTimeForGraphicsControlBlock(current, frameIndex, delayTime);
    return Qnil;
}