diff --git a/gifwidget/gif.h b/gifwidget/gif.h new file mode 100644 index 0000000..fe797d9 --- /dev/null +++ b/gifwidget/gif.h @@ -0,0 +1,803 @@ +// +// gif.h +// by Charlie Tangora +// Public domain. +// Email me : ctangora -at- gmail -dot- com +// +// This file offers a simple, very limited way to create animated GIFs directly in code. +// +// Those looking for particular cleverness are likely to be disappointed; it's pretty +// much a straight-ahead implementation of the GIF format with optional Floyd-Steinberg +// dithering. (It does at least use delta encoding - only the changed portions of each +// frame are saved.) +// +// So resulting files are often quite large. The hope is that it will be handy nonetheless +// as a quick and easily-integrated way for programs to spit out animations. +// +// Only RGBA8 is currently supported as an input format. (The alpha is ignored.) +// +// USAGE: +// Create a GifWriter struct. Pass it to GifBegin() to initialize and write the header. +// Pass subsequent frames to GifWriteFrame(). +// Finally, call GifEnd() to close the file handle and free memory. +// + +#ifndef __gif_h__ +#define __gif_h__ + +#include // for FILE* +#include // for memcpy and bzero +#include // for integer typedefs + +// Define these macros to hook into a custom memory allocator. +// TEMP_MALLOC and TEMP_FREE will only be called in stack fashion - frees in the reverse order of mallocs +// and any temp memory allocated by a function will be freed before it exits. +// MALLOC and FREE are used only by GifBegin and GifEnd respectively (to allocate a buffer the size of the image, which +// is used to find changed pixels for delta-encoding.) + +#ifndef GIF_TEMP_MALLOC +#include +#define GIF_TEMP_MALLOC malloc +#endif + +#ifndef GIF_TEMP_FREE +#include +#define GIF_TEMP_FREE free +#endif + +#ifndef GIF_MALLOC +#include +#define GIF_MALLOC malloc +#endif + +#ifndef GIF_FREE +#include +#define GIF_FREE free +#endif + +class Gif +{ +public: + int kGifTransIndex; + struct GifPalette { + int bitDepth; + uint8_t r[256]; + uint8_t g[256]; + uint8_t b[256]; + // k-d tree over RGB space, organized in heap fashion + // i.e. left child of node i is node i*2, right child is node i*2+1 + // nodes 256-511 are implicitly the leaves, containing a color + uint8_t treeSplitElt[255]; + uint8_t treeSplit[255]; + }; + + // max, min, and abs functions + int GifIMax(int l, int r) + { + return l > r ? l : r; + } + int GifIMin(int l, int r) + { + return l < r ? l : r; + } + int GifIAbs(int i) + { + return i < 0 ? -i : i; + } + + // walks the k-d tree to pick the palette entry for a desired color. + // Takes as in/out parameters the current best color and its error - + // only changes them if it finds a better color in its subtree. + // this is the major hotspot in the code at the moment. + void GifGetClosestPaletteColor(GifPalette *pPal, int r, int g, int b, int &bestInd, int &bestDiff, int treeRoot = 1) + { + // base case, reached the bottom of the tree + if(treeRoot > (1 << pPal->bitDepth) - 1) { + int ind = treeRoot - (1 << pPal->bitDepth); + if(ind == kGifTransIndex) { + return; + } + // check whether this color is better than the current winner + int r_err = r - ((int32_t)pPal->r[ind]); + int g_err = g - ((int32_t)pPal->g[ind]); + int b_err = b - ((int32_t)pPal->b[ind]); + int diff = GifIAbs(r_err) + GifIAbs(g_err) + GifIAbs(b_err); + if(diff < bestDiff) { + bestInd = ind; + bestDiff = diff; + } + return; + } + // take the appropriate color (r, g, or b) for this node of the k-d tree + int comps[3]; + comps[0] = r; + comps[1] = g; + comps[2] = b; + int splitComp = comps[pPal->treeSplitElt[treeRoot]]; + + int splitPos = pPal->treeSplit[treeRoot]; + if(splitPos > splitComp) { + // check the left subtree + GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot * 2); + if( bestDiff > splitPos - splitComp ) { + // cannot prove there's not a better value in the right subtree, check that too + GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot * 2 + 1); + } + } else { + GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot * 2 + 1); + if( bestDiff > splitComp - splitPos ) { + GifGetClosestPaletteColor(pPal, r, g, b, bestInd, bestDiff, treeRoot * 2); + } + } + } + + void GifSwapPixels(uint8_t *image, int pixA, int pixB) + { + uint8_t rA = image[pixA * 4]; + uint8_t gA = image[pixA * 4 + 1]; + uint8_t bA = image[pixA * 4 + 2]; + uint8_t aA = image[pixA * 4 + 3]; + + uint8_t rB = image[pixB * 4]; + uint8_t gB = image[pixB * 4 + 1]; + uint8_t bB = image[pixB * 4 + 2]; + uint8_t aB = image[pixA * 4 + 3]; + + image[pixA * 4] = rB; + image[pixA * 4 + 1] = gB; + image[pixA * 4 + 2] = bB; + image[pixA * 4 + 3] = aB; + + image[pixB * 4] = rA; + image[pixB * 4 + 1] = gA; + image[pixB * 4 + 2] = bA; + image[pixB * 4 + 3] = aA; + } + + // just the partition operation from quicksort + int GifPartition(uint8_t *image, const int left, const int right, const int elt, int pivotIndex) + { + const int pivotValue = image[(pivotIndex) * 4 + elt]; + GifSwapPixels(image, pivotIndex, right - 1); + int storeIndex = left; + bool split = 0; + for(int ii = left; ii < right - 1; ++ii) { + int arrayVal = image[ii * 4 + elt]; + if( arrayVal < pivotValue ) { + GifSwapPixels(image, ii, storeIndex); + ++storeIndex; + } else if( arrayVal == pivotValue ) { + if(split) { + GifSwapPixels(image, ii, storeIndex); + ++storeIndex; + } + split = !split; + } + } + GifSwapPixels(image, storeIndex, right - 1); + return storeIndex; + } + + // Perform an incomplete sort, finding all elements above and below the desired median + void GifPartitionByMedian(uint8_t *image, int left, int right, int com, int neededCenter) + { + if (left < right - 1) { + int pivotIndex = left + (right - left) / 2; + pivotIndex = GifPartition(image, left, right, com, pivotIndex); + // Only "sort" the section of the array that contains the median + if(pivotIndex > neededCenter) { + GifPartitionByMedian(image, left, pivotIndex, com, neededCenter); + } + if(pivotIndex < neededCenter) { + GifPartitionByMedian(image, pivotIndex + 1, right, com, neededCenter); + } + } + } + + // Builds a palette by creating a balanced k-d tree of all pixels in the image + void GifSplitPalette(uint8_t *image, + int numPixels, int firstElt, + int lastElt, int splitElt, + int splitDist, int treeNode, + bool buildForDither, GifPalette *pal) + { + if (lastElt <= firstElt || numPixels == 0) { + return; + } + // base case, bottom of the tree + if (lastElt == firstElt + 1) { + if (buildForDither) { + // Dithering needs at least one color as dark as anything + // in the image and at least one brightest color - + // otherwise it builds up error and produces strange artifacts + if( firstElt == 1 ) { + // special case: the darkest color in the image + uint32_t r = 255, g = 255, b = 255; + for(int ii = 0; ii < numPixels; ++ii) { + r = (uint32_t)GifIMin((int32_t)r, image[ii * 4 + 0]); + g = (uint32_t)GifIMin((int32_t)g, image[ii * 4 + 1]); + b = (uint32_t)GifIMin((int32_t)b, image[ii * 4 + 2]); + } + pal->r[firstElt] = (uint8_t)r; + pal->g[firstElt] = (uint8_t)g; + pal->b[firstElt] = (uint8_t)b; + return; + } + + if ( firstElt == (1 << pal->bitDepth) - 1 ) { + // special case: the lightest color in the image + uint32_t r = 0, g = 0, b = 0; + for(int ii = 0; ii < numPixels; ++ii) { + r = (uint32_t)GifIMax((int32_t)r, image[ii * 4 + 0]); + g = (uint32_t)GifIMax((int32_t)g, image[ii * 4 + 1]); + b = (uint32_t)GifIMax((int32_t)b, image[ii * 4 + 2]); + } + pal->r[firstElt] = (uint8_t)r; + pal->g[firstElt] = (uint8_t)g; + pal->b[firstElt] = (uint8_t)b; + return; + } + } + // otherwise, take the average of all colors in this subcube + uint64_t r = 0, g = 0, b = 0; + for (int ii = 0; ii < numPixels; ++ii) { + r += image[ii * 4 + 0]; + g += image[ii * 4 + 1]; + b += image[ii * 4 + 2]; + } + + r += (uint64_t)numPixels / 2; // round to nearest + g += (uint64_t)numPixels / 2; + b += (uint64_t)numPixels / 2; + + r /= (uint64_t)numPixels; + g /= (uint64_t)numPixels; + b /= (uint64_t)numPixels; + + pal->r[firstElt] = (uint8_t)r; + pal->g[firstElt] = (uint8_t)g; + pal->b[firstElt] = (uint8_t)b; + return; + } + // Find the axis with the largest range + int minR = 255, maxR = 0; + int minG = 255, maxG = 0; + int minB = 255, maxB = 0; + for(int ii = 0; ii < numPixels; ++ii) { + int r = image[ii * 4 + 0]; + int g = image[ii * 4 + 1]; + int b = image[ii * 4 + 2]; + + if(r > maxR) { + maxR = r; + } + if(r < minR) { + minR = r; + } + + if(g > maxG) { + maxG = g; + } + if(g < minG) { + minG = g; + } + + if(b > maxB) { + maxB = b; + } + if(b < minB) { + minB = b; + } + } + + int rRange = maxR - minR; + int gRange = maxG - minG; + int bRange = maxB - minB; + // and split along that axis. (incidentally, this means this isn't a "proper" k-d tree but I don't know what else to call it) + int splitCom = 1; + if (bRange > gRange) { + splitCom = 2; + } + if (rRange > bRange && rRange > gRange) { + splitCom = 0; + } + + int subPixelsA = numPixels * (splitElt - firstElt) / (lastElt - firstElt); + int subPixelsB = numPixels - subPixelsA; + + GifPartitionByMedian(image, 0, numPixels, splitCom, subPixelsA); + + pal->treeSplitElt[treeNode] = (uint8_t)splitCom; + pal->treeSplit[treeNode] = image[subPixelsA * 4 + splitCom]; + + GifSplitPalette(image, subPixelsA, firstElt, splitElt, splitElt - splitDist, splitDist / 2, treeNode * 2, buildForDither, pal); + GifSplitPalette(image + subPixelsA * 4, subPixelsB, splitElt, lastElt, splitElt + splitDist, splitDist / 2, treeNode * 2 + 1, buildForDither, pal); + } + + // Finds all pixels that have changed from the previous image and + // moves them to the fromt of th buffer. + // This allows us to build a palette optimized for the colors of the + // changed pixels only. + int GifPickChangedPixels( const uint8_t *lastFrame, uint8_t *frame, int numPixels ) + { + int numChanged = 0; + uint8_t *writeIter = frame; + for (int ii = 0; ii < numPixels; ++ii) { + if(lastFrame[0] != frame[0] || + lastFrame[1] != frame[1] || + lastFrame[2] != frame[2]) { + writeIter[0] = frame[0]; + writeIter[1] = frame[1]; + writeIter[2] = frame[2]; + ++numChanged; + writeIter += 4; + } + lastFrame += 4; + frame += 4; + } + return numChanged; + } + + // Creates a palette by placing all the image pixels in a k-d tree and then averaging the blocks at the bottom. + // This is known as the "modified median split" technique + void GifMakePalette( const uint8_t *lastFrame, + const uint8_t *nextFrame, + uint32_t width, uint32_t height, + int bitDepth, bool buildForDither, + GifPalette *pPal ) + { + pPal->bitDepth = bitDepth; + + // SplitPalette is destructive (it sorts the pixels by color) so + // we must create a copy of the image for it to destroy + size_t imageSize = (size_t)(width * height * 4 * sizeof(uint8_t)); + uint8_t *destroyableImage = (uint8_t *)GIF_TEMP_MALLOC(imageSize); + memcpy(destroyableImage, nextFrame, imageSize); + + int numPixels = (int)(width * height); + if(lastFrame) { + numPixels = GifPickChangedPixels(lastFrame, destroyableImage, numPixels); + } + + const int lastElt = 1 << bitDepth; + const int splitElt = lastElt / 2; + const int splitDist = splitElt / 2; + + GifSplitPalette(destroyableImage, numPixels, 1, lastElt, splitElt, splitDist, 1, buildForDither, pPal); + + GIF_TEMP_FREE(destroyableImage); + + // add the bottom node for the transparency index + pPal->treeSplit[1 << (bitDepth - 1)] = 0; + pPal->treeSplitElt[1 << (bitDepth - 1)] = 0; + + pPal->r[0] = pPal->g[0] = pPal->b[0] = 0; + } + + // Implements Floyd-Steinberg dithering, writes palette value to alpha + void GifDitherImage( const uint8_t *lastFrame, const uint8_t *nextFrame, + uint8_t *outFrame, uint32_t width, + uint32_t height, GifPalette *pPal ) + { + int numPixels = (int)(width * height); + + // quantPixels initially holds color*256 for all pixels + // The extra 8 bits of precision allow for sub-single-color error values + // to be propagated + int32_t *quantPixels = (int32_t *)GIF_TEMP_MALLOC(sizeof(int32_t) * (size_t)numPixels * 4); + for( int ii = 0; ii < numPixels * 4; ++ii ) { + uint8_t pix = nextFrame[ii]; + int32_t pix16 = int32_t(pix) * 256; + quantPixels[ii] = pix16; + } + + for( uint32_t yy = 0; yy < height; ++yy ) { + for( uint32_t xx = 0; xx < width; ++xx ) { + int32_t *nextPix = quantPixels + 4 * (yy * width + xx); + const uint8_t *lastPix = lastFrame ? lastFrame + 4 * (yy * width + xx) : NULL; + // Compute the colors we want (rounding to nearest) + int32_t rr = (nextPix[0] + 127) / 256; + int32_t gg = (nextPix[1] + 127) / 256; + int32_t bb = (nextPix[2] + 127) / 256; + // if it happens that we want the color from last frame, then just write out + // a transparent pixel + if( lastFrame && + lastPix[0] == rr && + lastPix[1] == gg && + lastPix[2] == bb ) { + nextPix[0] = rr; + nextPix[1] = gg; + nextPix[2] = bb; + nextPix[3] = kGifTransIndex; + continue; + } + + int32_t bestDiff = 1000000; + int32_t bestInd = kGifTransIndex; + // Search the palete + GifGetClosestPaletteColor(pPal, rr, gg, bb, bestInd, bestDiff); + // Write the result to the temp buffer + int32_t r_err = nextPix[0] - int32_t(pPal->r[bestInd]) * 256; + int32_t g_err = nextPix[1] - int32_t(pPal->g[bestInd]) * 256; + int32_t b_err = nextPix[2] - int32_t(pPal->b[bestInd]) * 256; + + nextPix[0] = pPal->r[bestInd]; + nextPix[1] = pPal->g[bestInd]; + nextPix[2] = pPal->b[bestInd]; + nextPix[3] = bestInd; + + // Propagate the error to the four adjacent locations + // that we haven't touched yet + int quantloc_7 = (int)(yy * width + xx + 1); + int quantloc_3 = (int)(yy * width + width + xx - 1); + int quantloc_5 = (int)(yy * width + width + xx); + int quantloc_1 = (int)(yy * width + width + xx + 1); + + if(quantloc_7 < numPixels) { + int32_t *pix7 = quantPixels + 4 * quantloc_7; + pix7[0] += GifIMax( -pix7[0], r_err * 7 / 16 ); + pix7[1] += GifIMax( -pix7[1], g_err * 7 / 16 ); + pix7[2] += GifIMax( -pix7[2], b_err * 7 / 16 ); + } + + if(quantloc_3 < numPixels) { + int32_t *pix3 = quantPixels + 4 * quantloc_3; + pix3[0] += GifIMax( -pix3[0], r_err * 3 / 16 ); + pix3[1] += GifIMax( -pix3[1], g_err * 3 / 16 ); + pix3[2] += GifIMax( -pix3[2], b_err * 3 / 16 ); + } + + if(quantloc_5 < numPixels) { + int32_t *pix5 = quantPixels + 4 * quantloc_5; + pix5[0] += GifIMax( -pix5[0], r_err * 5 / 16 ); + pix5[1] += GifIMax( -pix5[1], g_err * 5 / 16 ); + pix5[2] += GifIMax( -pix5[2], b_err * 5 / 16 ); + } + + if(quantloc_1 < numPixels) { + int32_t *pix1 = quantPixels + 4 * quantloc_1; + pix1[0] += GifIMax( -pix1[0], r_err / 16 ); + pix1[1] += GifIMax( -pix1[1], g_err / 16 ); + pix1[2] += GifIMax( -pix1[2], b_err / 16 ); + } + } + } + // Copy the palettized result to the output buffer + for( int ii = 0; ii < numPixels * 4; ++ii ) { + outFrame[ii] = (uint8_t)quantPixels[ii]; + } + + GIF_TEMP_FREE(quantPixels); + } + + // Picks palette colors for the image using simple thresholding, no dithering + void GifThresholdImage( const uint8_t *lastFrame, const uint8_t *nextFrame, + uint8_t *outFrame, uint32_t width, uint32_t height, + GifPalette *pPal ) + { + uint32_t numPixels = width * height; + for( uint32_t ii = 0; ii < numPixels; ++ii ) { + // if a previous color is available, and it matches the current color, + // set the pixel to transparent + if(lastFrame && + lastFrame[0] == nextFrame[0] && + lastFrame[1] == nextFrame[1] && + lastFrame[2] == nextFrame[2]) { + outFrame[0] = lastFrame[0]; + outFrame[1] = lastFrame[1]; + outFrame[2] = lastFrame[2]; + outFrame[3] = kGifTransIndex; + } else { + // palettize the pixel + int32_t bestDiff = 1000000; + int32_t bestInd = 1; + GifGetClosestPaletteColor(pPal, nextFrame[0], nextFrame[1], nextFrame[2], bestInd, bestDiff); + + // Write the resulting color to the output buffer + outFrame[0] = pPal->r[bestInd]; + outFrame[1] = pPal->g[bestInd]; + outFrame[2] = pPal->b[bestInd]; + outFrame[3] = (uint8_t)bestInd; + } + if(lastFrame) { + lastFrame += 4; + } + outFrame += 4; + nextFrame += 4; + } + } + + // Simple structure to write out the LZW-compressed portion of the image + // one bit at a time + struct GifBitStatus { + uint8_t bitIndex; // how many bits in the partial byte written so far + uint8_t byte; // current partial byte + + uint32_t chunkIndex; + uint8_t chunk[256]; // bytes are written in here until we have 256 of them, then written to the file + }; + + // insert a single bit + void GifWriteBit( GifBitStatus &stat, uint32_t bit ) + { + bit = bit & 1; + bit = bit << stat.bitIndex; + stat.byte |= bit; + + ++stat.bitIndex; + if( stat.bitIndex > 7 ) { + // move the newly-finished byte to the chunk buffer + stat.chunk[stat.chunkIndex++] = stat.byte; + // and start a new byte + stat.bitIndex = 0; + stat.byte = 0; + } + } + + // write all bytes so far to the file + void GifWriteChunk( FILE *f, GifBitStatus &stat ) + { + fputc((int)stat.chunkIndex, f); + fwrite(stat.chunk, 1, stat.chunkIndex, f); + + stat.bitIndex = 0; + stat.byte = 0; + stat.chunkIndex = 0; + } + + void GifWriteCode( FILE *f, GifBitStatus &stat, uint32_t code, uint32_t length ) + { + for( uint32_t ii = 0; ii < length; ++ii ) { + GifWriteBit(stat, code); + code = code >> 1; + if( stat.chunkIndex == 255 ) { + GifWriteChunk(f, stat); + } + } + } + + // The LZW dictionary is a 256-ary tree constructed as the file is encoded, + // this is one node + struct GifLzwNode { + uint16_t m_next[256]; + }; + + // write a 256-color (8-bit) image palette to the file + void GifWritePalette( const GifPalette *pPal, FILE *f ) + { + fputc(0, f); // first color: transparency + fputc(0, f); + fputc(0, f); + for(int ii = 1; ii < (1 << pPal->bitDepth); ++ii) { + uint32_t r = pPal->r[ii]; + uint32_t g = pPal->g[ii]; + uint32_t b = pPal->b[ii]; + fputc((int)r, f); + fputc((int)g, f); + fputc((int)b, f); + } + } + + // write the image header, LZW-compress and write out the image + void GifWriteLzwImage(FILE *f, uint8_t *image, uint32_t left, + uint32_t top, uint32_t width, + uint32_t height, uint32_t delay, + GifPalette *pPal) + { + // graphics control extension + fputc(0x21, f); + fputc(0xf9, f); + fputc(0x04, f); + fputc(0x05, f); // leave prev frame in place, this frame has transparency + fputc(delay & 0xff, f); + fputc((delay >> 8) & 0xff, f); + fputc(kGifTransIndex, f); // transparent color index + fputc(0, f); + + fputc(0x2c, f); // image descriptor block + + fputc(left & 0xff, f); // corner of image in canvas space + fputc((left >> 8) & 0xff, f); + fputc(top & 0xff, f); + fputc((top >> 8) & 0xff, f); + + fputc(width & 0xff, f); // width and height of image + fputc((width >> 8) & 0xff, f); + fputc(height & 0xff, f); + fputc((height >> 8) & 0xff, f); + + //fputc(0, f); // no local color table, no transparency + //fputc(0x80, f); // no local color table, but transparency + + fputc(0x80 + pPal->bitDepth - 1, f); // local color table present, 2 ^ bitDepth entries + GifWritePalette(pPal, f); + + const int minCodeSize = pPal->bitDepth; + const uint32_t clearCode = 1 << pPal->bitDepth; + + fputc(minCodeSize, f); // min code size 8 bits + + GifLzwNode *codetree = (GifLzwNode *)GIF_TEMP_MALLOC(sizeof(GifLzwNode) * 4096); + + memset(codetree, 0, sizeof(GifLzwNode) * 4096); + int32_t curCode = -1; + uint32_t codeSize = (uint32_t)minCodeSize + 1; + uint32_t maxCode = clearCode + 1; + + GifBitStatus stat; + stat.byte = 0; + stat.bitIndex = 0; + stat.chunkIndex = 0; + + GifWriteCode(f, stat, clearCode, codeSize); // start with a fresh LZW dictionary + + for(uint32_t yy = 0; yy < height; ++yy) { + for(uint32_t xx = 0; xx < width; ++xx) { + uint8_t nextValue = image[(yy * width + xx) * 4 + 3]; + // "loser mode" - no compression, every single code is followed immediately by a clear + //WriteCode( f, stat, nextValue, codeSize ); + //WriteCode( f, stat, 256, codeSize ); + if( curCode < 0 ) { + // first value in a new run + curCode = nextValue; + } else if( codetree[curCode].m_next[nextValue] ) { + // current run already in the dictionary + curCode = codetree[curCode].m_next[nextValue]; + } else { + // finish the current run, write a code + GifWriteCode(f, stat, (uint32_t)curCode, codeSize); + // insert the new run into the dictionary + codetree[curCode].m_next[nextValue] = (uint16_t)++maxCode; + if( maxCode >= (1ul << codeSize) ) { + // dictionary entry count has broken a size barrier, + // we need more bits for codes + codeSize++; + } + if( maxCode == 4095 ) { + // the dictionary is full, clear it out and begin anew + GifWriteCode(f, stat, clearCode, codeSize); // clear tree + + memset(codetree, 0, sizeof(GifLzwNode) * 4096); + codeSize = (uint32_t)(minCodeSize + 1); + maxCode = clearCode + 1; + } + curCode = nextValue; + } + } + } + // compression footer + GifWriteCode(f, stat, (uint32_t)curCode, codeSize); + GifWriteCode(f, stat, clearCode, codeSize); + GifWriteCode(f, stat, clearCode + 1, (uint32_t)minCodeSize + 1); + // write out the last partial chunk + while( stat.bitIndex ) { + GifWriteBit(stat, 0); + } + if( stat.chunkIndex ) { + GifWriteChunk(f, stat); + } + + fputc(0, f); // image block terminator + + GIF_TEMP_FREE(codetree); + } + + struct GifWriter { + FILE *f; + uint8_t *oldImage; + bool firstFrame; + }; + + // Creates a gif file. + // The input GIFWriter is assumed to be uninitialized. + // The delay value is the time between frames in hundredths of a second - note that not all viewers pay much attention to this value. + bool GifBegin( GifWriter *writer, const char *filename, + uint32_t width, uint32_t height, + uint32_t delay, int32_t bitDepth = 8, + bool dither = false ) + { + (void)bitDepth; + (void)dither; // Mute "Unused argument" warnings +#if defined(_MSC_VER) && (_MSC_VER >= 1400) + writer->f = 0; + fopen_s(&writer->f, filename, "wb"); +#else + writer->f = fopen(filename, "wb"); +#endif + if(!writer->f) { + return false; + } + + writer->firstFrame = true; + + // allocate + writer->oldImage = (uint8_t *)GIF_MALLOC(width * height * 4); + fputs("GIF89a", writer->f); + + // screen descriptor + fputc(width & 0xff, writer->f); + fputc((width >> 8) & 0xff, writer->f); + fputc(height & 0xff, writer->f); + fputc((height >> 8) & 0xff, writer->f); + + fputc(0xf0, writer->f); // there is an unsorted global color table of 2 entries + fputc(0, writer->f); // background color + fputc(0, writer->f); // pixels are square (we need to specify this because it's 1989) + + // now the "global" palette (really just a dummy palette) + // color 0: black + fputc(0, writer->f); + fputc(0, writer->f); + fputc(0, writer->f); + // color 1: also black + fputc(0, writer->f); + fputc(0, writer->f); + fputc(0, writer->f); + + if( delay != 0 ) { + // animation header + fputc(0x21, writer->f); // extension + fputc(0xff, writer->f); // application specific + fputc(11, writer->f); // length 11 + fputs("NETSCAPE2.0", writer->f); // yes, really + fputc(3, writer->f); // 3 bytes of NETSCAPE2.0 data + + fputc(1, writer->f); // JUST BECAUSE + fputc(0, writer->f); // loop infinitely (byte 0) + fputc(0, writer->f); // loop infinitely (byte 1) + + fputc(0, writer->f); // block terminator + } + return true; + } + + // Writes out a new frame to a GIF in progress. + // The GIFWriter should have been created by GIFBegin. + // AFAIK, it is legal to use different bit depths for different frames of an image - + // this may be handy to save bits in animations that don't change much. + bool GifWriteFrame( GifWriter *writer, const uint8_t *image, + uint32_t width, uint32_t height, + uint32_t delay, int bitDepth = 8, bool dither = false ) + { + if(!writer->f) { + return false; + } + + const uint8_t *oldImage = writer->firstFrame ? NULL : writer->oldImage; + writer->firstFrame = false; + + GifPalette pal; + GifMakePalette((dither ? NULL : oldImage), image, width, height, bitDepth, dither, &pal); + + if(dither) { + GifDitherImage(oldImage, image, writer->oldImage, width, height, &pal); + } else { + GifThresholdImage(oldImage, image, writer->oldImage, width, height, &pal); + } + + GifWriteLzwImage(writer->f, writer->oldImage, 0, 0, width, height, delay, &pal); + + return true; + } + + // Writes the EOF code, closes the file handle, and frees temp memory used by a GIF. + // Many if not most viewers will still display a GIF properly if the EOF code is missing, + // but it's still a good idea to write it out. + bool GifEnd( GifWriter *writer ) + { + if(!writer->f) { + return false; + } + + fputc(0x3b, writer->f); // end of file + fclose(writer->f); + GIF_FREE(writer->oldImage); + + writer->f = NULL; + writer->oldImage = NULL; + + return true; + } +}; + +#endif diff --git a/gifwidget/gifwidget.cpp b/gifwidget/gifwidget.cpp new file mode 100644 index 0000000..84ed18b --- /dev/null +++ b/gifwidget/gifwidget.cpp @@ -0,0 +1,363 @@ +#pragma execution_character_set("utf-8") + +#include "gifwidget.h" +#include "qmutex.h" +#include "qlabel.h" +#include "qlineedit.h" +#include "qpushbutton.h" +#include "qlayout.h" +#include "qpainter.h" +#include "qevent.h" +#include "qstyle.h" +#include "qpixmap.h" +#include "qtimer.h" +#include "qdatetime.h" +#include "qapplication.h" +#include "qdesktopwidget.h" +#include "qdesktopservices.h" +#include "qfiledialog.h" +#include "qurl.h" +#include "qdebug.h" +#if (QT_VERSION > QT_VERSION_CHECK(5,0,0)) +#include "qscreen.h" +#endif + +QScopedPointer GifWidget::self; +GifWidget *GifWidget::Instance() +{ + if (self.isNull()) { + static QMutex mutex; + QMutexLocker locker(&mutex); + if (self.isNull()) { + self.reset(new GifWidget); + } + } + + return self.data(); +} + +GifWidget::GifWidget(QWidget *parent) : QDialog(parent) +{ + this->initControl(); + this->initForm(); +} + +bool GifWidget::eventFilter(QObject *watched, QEvent *event) +{ + static QPoint mousePoint; + static bool mousePressed = false; + + QMouseEvent *mouseEvent = static_cast(event); + if (mouseEvent->type() == QEvent::MouseButtonPress) { + if (mouseEvent->button() == Qt::LeftButton) { + mousePressed = true; + mousePoint = mouseEvent->globalPos() - this->pos(); + return true; + } + } else if (mouseEvent->type() == QEvent::MouseButtonRelease) { + mousePressed = false; + return true; + } else if (mouseEvent->type() == QEvent::MouseMove) { + if (mousePressed && (mouseEvent->buttons() && Qt::LeftButton)) { + this->move(mouseEvent->globalPos() - mousePoint); + return true; + } + } + + return QWidget::eventFilter(watched, event); +} + +void GifWidget::resizeEvent(QResizeEvent *e) +{ + //拉动右下角改变大小自动赋值 + txtWidth->setText(QString::number(widgetMain->width())); + txtHeight->setText(QString::number(widgetMain->height())); + QDialog::resizeEvent(e); +} + +void GifWidget::paintEvent(QPaintEvent *) +{ + int width = txtWidth->text().toInt(); + int height = txtHeight->text().toInt(); + rectGif = QRect(borderWidth, widgetTop->height(), width - (borderWidth * 2), height); + + QPainter painter(this); + painter.setPen(Qt::NoPen); + painter.setBrush(bgColor); + painter.drawRoundedRect(this->rect(), 5, 5); + painter.setCompositionMode(QPainter::CompositionMode_Clear); + painter.fillRect(rectGif, Qt::SolidPattern); +} + +int GifWidget::getBorderWidth() const +{ + return this->borderWidth; +} + +QColor GifWidget::getBgColor() const +{ + return this->bgColor; +} + +void GifWidget::initControl() +{ + this->setObjectName("GifWidget"); + this->resize(800, 600); + this->setSizeGripEnabled(true); + QVBoxLayout *verticalLayout = new QVBoxLayout(this); + verticalLayout->setSpacing(0); + verticalLayout->setContentsMargins(11, 11, 11, 11); + verticalLayout->setObjectName("verticalLayout"); + verticalLayout->setContentsMargins(0, 0, 0, 0); + + widgetTop = new QWidget(this); + widgetTop->setObjectName("widgetTop"); + widgetTop->setMinimumSize(QSize(0, 35)); + widgetTop->setMaximumSize(QSize(16777215, 35)); + + QHBoxLayout *layoutTop = new QHBoxLayout(widgetTop); + layoutTop->setSpacing(0); + layoutTop->setContentsMargins(11, 11, 11, 11); + layoutTop->setObjectName("layoutTop"); + layoutTop->setContentsMargins(0, 0, 0, 0); + + QPushButton *btnIcon = new QPushButton(widgetTop); + btnIcon->setObjectName("btnIcon"); + QSizePolicy sizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + sizePolicy.setHeightForWidth(btnIcon->sizePolicy().hasHeightForWidth()); + btnIcon->setSizePolicy(sizePolicy); + btnIcon->setMinimumSize(QSize(35, 0)); + btnIcon->setFlat(true); + layoutTop->addWidget(btnIcon); + + QLabel *labTitle = new QLabel(widgetTop); + labTitle->setObjectName("labTitle"); + layoutTop->addWidget(labTitle); + + QSpacerItem *horizontalSpacer = new QSpacerItem(87, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + layoutTop->addItem(horizontalSpacer); + + QPushButton *btnClose = new QPushButton(widgetTop); + btnClose->setObjectName("btnClose"); + sizePolicy.setHeightForWidth(btnClose->sizePolicy().hasHeightForWidth()); + btnClose->setSizePolicy(sizePolicy); + btnClose->setMinimumSize(QSize(35, 0)); + btnClose->setFocusPolicy(Qt::NoFocus); + btnClose->setFlat(true); + layoutTop->addWidget(btnClose); + verticalLayout->addWidget(widgetTop); + + widgetMain = new QWidget(this); + widgetMain->setObjectName("widgetMain"); + QSizePolicy sizePolicy1(QSizePolicy::Preferred, QSizePolicy::Expanding); + sizePolicy1.setHorizontalStretch(0); + sizePolicy1.setVerticalStretch(0); + sizePolicy1.setHeightForWidth(widgetMain->sizePolicy().hasHeightForWidth()); + widgetMain->setSizePolicy(sizePolicy1); + verticalLayout->addWidget(widgetMain); + + widgetBottom = new QWidget(this); + widgetBottom->setObjectName("widgetBottom"); + widgetBottom->setMinimumSize(QSize(0, 45)); + widgetBottom->setMaximumSize(QSize(16777215, 45)); + + QHBoxLayout *layoutBottom = new QHBoxLayout(widgetBottom); + layoutBottom->setSpacing(6); + layoutBottom->setContentsMargins(11, 11, 11, 11); + layoutBottom->setObjectName("layoutBottom"); + layoutBottom->setContentsMargins(9, 9, -1, -1); + + QLabel *labFps = new QLabel(widgetBottom); + labFps->setObjectName("labFps"); + layoutBottom->addWidget(labFps); + + txtFps = new QLineEdit(widgetBottom); + txtFps->setObjectName("txtFps"); + txtFps->setMaximumSize(QSize(50, 16777215)); + txtFps->setAlignment(Qt::AlignCenter); + layoutBottom->addWidget(txtFps); + + QLabel *labWidth = new QLabel(widgetBottom); + labWidth->setObjectName("labWidth"); + layoutBottom->addWidget(labWidth); + + txtWidth = new QLineEdit(widgetBottom); + txtWidth->setObjectName("txtWidth"); + txtWidth->setEnabled(true); + txtWidth->setMaximumSize(QSize(50, 16777215)); + txtWidth->setAlignment(Qt::AlignCenter); + layoutBottom->addWidget(txtWidth); + + QLabel *labHeight = new QLabel(widgetBottom); + labHeight->setObjectName("labHeight"); + layoutBottom->addWidget(labHeight); + + txtHeight = new QLineEdit(widgetBottom); + txtHeight->setObjectName("txtHeight"); + txtHeight->setEnabled(true); + txtHeight->setMaximumSize(QSize(50, 16777215)); + txtHeight->setAlignment(Qt::AlignCenter); + layoutBottom->addWidget(txtHeight); + + labStatus = new QLabel(widgetBottom); + labStatus->setObjectName("labStatus"); + QSizePolicy sizePolicy2(QSizePolicy::Expanding, QSizePolicy::Preferred); + sizePolicy2.setHorizontalStretch(0); + sizePolicy2.setVerticalStretch(0); + sizePolicy2.setHeightForWidth(labStatus->sizePolicy().hasHeightForWidth()); + labStatus->setSizePolicy(sizePolicy2); + labStatus->setAlignment(Qt::AlignCenter); + layoutBottom->addWidget(labStatus); + + btnStart = new QPushButton(widgetBottom); + btnStart->setObjectName("btnStart"); + sizePolicy.setHeightForWidth(btnStart->sizePolicy().hasHeightForWidth()); + btnStart->setSizePolicy(sizePolicy); + layoutBottom->addWidget(btnStart); + verticalLayout->addWidget(widgetBottom); + + labTitle->setText("GIF录屏工具(QQ:517216493)"); + labFps->setText("帧率"); + labWidth->setText("宽度"); + labHeight->setText("高度"); + btnStart->setText("开始"); + this->setWindowTitle(labTitle->text()); + + btnIcon->setIcon(style()->standardIcon(QStyle::SP_ComputerIcon)); + btnClose->setIcon(style()->standardIcon(QStyle::SP_TitleBarCloseButton)); + + connect(btnClose, SIGNAL(clicked(bool)), this, SLOT(closeAll())); + connect(btnStart, SIGNAL(clicked(bool)), this, SLOT(record())); + connect(txtWidth, SIGNAL(editingFinished()), this, SLOT(resizeForm())); + connect(txtHeight, SIGNAL(editingFinished()), this, SLOT(resizeForm())); +} + +void GifWidget::initForm() +{ + borderWidth = 3; + bgColor = QColor(34, 163, 169); + + fps = 10; + txtFps->setText(QString::number(fps)); + gifWriter = 0; + + timer = new QTimer(this); + timer->setInterval(100); + connect(timer, SIGNAL(timeout()), this, SLOT(saveImage())); + + this->setAttribute(Qt::WA_TranslucentBackground); + this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint | Qt::WindowStaysOnTopHint); + this->installEventFilter(this); + + QStringList qss; + qss.append("QLabel{color:#ffffff;}"); + qss.append("#btnClose,#btnIcon{border:none;border-radius:0px;}"); + qss.append("#btnClose:hover{background-color:#ff0000;}"); + qss.append("#btnClose{border-top-right-radius:5px;}"); + qss.append("#labTitle{font:bold 16px;}"); + qss.append("#labStatus{font:15px;}"); + this->setStyleSheet(qss.join("")); +} + +void GifWidget::saveImage() +{ + if (!gifWriter) { + return; + } + +#if (QT_VERSION <= QT_VERSION_CHECK(5,0,0)) + //由于qt4没有RGBA8888,采用最接近RGBA8888的是ARGB32,颜色会有点偏差 + QPixmap pix = QPixmap::grabWindow(0, x() + rectGif.x(), y() + rectGif.y(), rectGif.width(), rectGif.height()); + QImage image = pix.toImage().convertToFormat(QImage::Format_ARGB32); +#else + QScreen *screen = QApplication::primaryScreen(); + QPixmap pix = screen->grabWindow(0, x() + rectGif.x(), y() + rectGif.y(), rectGif.width(), rectGif.height()); + QImage image = pix.toImage().convertToFormat(QImage::Format_RGBA8888); +#endif + + gif.GifWriteFrame(gifWriter, image.bits(), rectGif.width(), rectGif.height(), fps); + count++; + labStatus->setText(QString("正在录制 第 %1 帧").arg(count)); +} + +void GifWidget::record() +{ + if (btnStart->text() == "开始") { + if (0 != gifWriter) { + delete gifWriter; + gifWriter = 0; + } + + //先弹出文件保存对话框 + //fileName = qApp->applicationDirPath() + "/" + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss.gif"); + fileName = QFileDialog::getSaveFileName(this, "选择保存位置", qApp->applicationDirPath() + "/", "gif图片(*.gif)"); + if (fileName.isEmpty()) { + return; + } + + int width = txtWidth->text().toInt(); + int height = txtHeight->text().toInt(); + fps = txtFps->text().toInt(); + + gifWriter = new Gif::GifWriter; + bool bOk = gif.GifBegin(gifWriter, fileName.toLocal8Bit().data(), width, height, fps); + if (!bOk) { + delete gifWriter; + gifWriter = 0; + return; + } + + count = 0; + labStatus->setText("开始录制..."); + btnStart->setText("停止"); + //延时启动 + timer->setInterval(1000 / fps); + QTimer::singleShot(1000, timer, SLOT(start())); + //saveImage(); + } else { + timer->stop(); + gif.GifEnd(gifWriter); + + delete gifWriter; + gifWriter = 0; + + labStatus->setText(QString("录制完成 共 %1 帧").arg(count)); + btnStart->setText("开始"); + QDesktopServices::openUrl(QUrl(fileName)); + } +} + +void GifWidget::closeAll() +{ + if (0 != gifWriter) { + delete gifWriter; + gifWriter = 0; + } + + this->close(); +} + +void GifWidget::resizeForm() +{ + int width = txtWidth->text().toInt(); + int height = txtHeight->text().toInt(); + this->resize(width, height + widgetTop->height() + widgetBottom->height()); +} + +void GifWidget::setBorderWidth(int borderWidth) +{ + if (this->borderWidth != borderWidth) { + this->borderWidth = borderWidth; + this->update(); + } +} + +void GifWidget::setBgColor(const QColor &bgColor) +{ + if (this->bgColor != bgColor) { + this->bgColor = bgColor; + this->update(); + } +} diff --git a/gifwidget/gifwidget.h b/gifwidget/gifwidget.h new file mode 100644 index 0000000..4378aa4 --- /dev/null +++ b/gifwidget/gifwidget.h @@ -0,0 +1,85 @@ +#ifndef GIFWIDGET_H +#define GIFWIDGET_H + +/** + * GIF录屏控件 作者:feiyangqingyun(QQ:517216493) 2019-4-3 + * 1:可设置要录制屏幕的宽高,支持右下角直接拉动改变. + * 2:可设置变宽的宽度 + * 3:可设置录屏控件的背景颜色 + * 4:可设置录制的帧数 + * 5:录制区域可自由拖动选择 + */ + +#include +#include "gif.h" + +class QLineEdit; +class QLabel; + +#ifdef quc +#if (QT_VERSION < QT_VERSION_CHECK(5,7,0)) +#include +#else +#include +#endif + +class QDESIGNER_WIDGET_EXPORT GifWidget : public QDialog +#else +class GifWidget : public QDialog +#endif + +{ + Q_OBJECT + Q_PROPERTY(int borderWidth READ getBorderWidth WRITE setBorderWidth) + Q_PROPERTY(QColor bgColor READ getBgColor WRITE setBgColor) + +public: + static GifWidget *Instance(); + explicit GifWidget(QWidget *parent = 0); + +protected: + bool eventFilter(QObject *watched, QEvent *event); + void resizeEvent(QResizeEvent *); + void paintEvent(QPaintEvent *); + +private: + static QScopedPointer self; + QWidget *widgetTop; //标题栏 + QWidget *widgetMain; //中间部分 + QWidget *widgetBottom; //底部栏 + QLineEdit *txtFps; //帧率输入框 + QLineEdit *txtWidth; //宽度输入框 + QLineEdit *txtHeight; //高度输入框 + QPushButton *btnStart; //开始按钮 + QLabel *labStatus; //显示状态信息 + + int fps; //帧数 100为1s + int borderWidth; //边框宽度 + QColor bgColor; //背景颜色 + + int count; //帧数计数 + QString fileName; //保存文件名称 + QRect rectGif; //截屏区域 + QTimer *timer; //截屏定时器 + + Gif gif; //gif类对象 + Gif::GifWriter *gifWriter; //gif写入对象 + +public: + int getBorderWidth() const; + QColor getBgColor() const; + +private slots: + void initControl(); + void initForm(); + void saveImage(); + void record(); + void closeAll(); + void resizeForm(); + +public Q_SLOTS: + void setBorderWidth(int borderWidth); + void setBgColor(const QColor &bgColor); +}; + +#endif // GIFWIDGET_H diff --git a/gifwidget/gifwidget.pro b/gifwidget/gifwidget.pro new file mode 100644 index 0000000..39eb595 --- /dev/null +++ b/gifwidget/gifwidget.pro @@ -0,0 +1,20 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2017-01-05T22:11:54 +# +#------------------------------------------------- + +QT += core gui + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +TARGET = gifwidget +TEMPLATE = app +DESTDIR = $$PWD/../bin +CONFIG += warn_off + +SOURCES += main.cpp +SOURCES += gifwidget.cpp +HEADERS += gifwidget.h +HEADERS += gif.h +RESOURCES += main.qrc diff --git a/gifwidget/image/gifwidget.ico b/gifwidget/image/gifwidget.ico new file mode 100644 index 0000000..c23ad4a Binary files /dev/null and b/gifwidget/image/gifwidget.ico differ diff --git a/gifwidget/image/gifwidget.png b/gifwidget/image/gifwidget.png new file mode 100644 index 0000000..c6bc6d1 Binary files /dev/null and b/gifwidget/image/gifwidget.png differ diff --git a/gifwidget/main.cpp b/gifwidget/main.cpp new file mode 100644 index 0000000..327bf26 --- /dev/null +++ b/gifwidget/main.cpp @@ -0,0 +1,31 @@ +#pragma execution_character_set("utf-8") + +#include "gifwidget.h" +#include +#include +#include + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + a.setFont(QFont("Microsoft Yahei", 9)); + a.setWindowIcon(QIcon(":/image/gifwidget.ico")); + +#if (QT_VERSION <= QT_VERSION_CHECK(5,0,0)) +#if _MSC_VER + QTextCodec *codec = QTextCodec::codecForName("gbk"); +#else + QTextCodec *codec = QTextCodec::codecForName("utf-8"); +#endif + QTextCodec::setCodecForLocale(codec); + QTextCodec::setCodecForCStrings(codec); + QTextCodec::setCodecForTr(codec); +#else + QTextCodec *codec = QTextCodec::codecForName("utf-8"); + QTextCodec::setCodecForLocale(codec); +#endif + + GifWidget::Instance()->show(); + + return a.exec(); +} diff --git a/gifwidget/main.qrc b/gifwidget/main.qrc new file mode 100644 index 0000000..72740d5 --- /dev/null +++ b/gifwidget/main.qrc @@ -0,0 +1,5 @@ + + + image/gifwidget.ico + +