diff options
Diffstat (limited to 'source/blender/imbuf')
| -rw-r--r-- | source/blender/imbuf/IMB_imbuf.h | 7 | ||||
| -rw-r--r-- | source/blender/imbuf/IMB_imbuf_types.h | 4 | ||||
| -rw-r--r-- | source/blender/imbuf/IMB_thumbs.h | 73 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/IMB_imginfo.h | 78 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/allocimbuf.c | 5 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/anim.c | 12 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/imginfo.c | 108 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/md5.c | 360 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/md5.h | 115 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/png.c | 38 | ||||
| -rw-r--r-- | source/blender/imbuf/intern/thumbs.c | 457 |
11 files changed, 1257 insertions, 0 deletions
diff --git a/source/blender/imbuf/IMB_imbuf.h b/source/blender/imbuf/IMB_imbuf.h index 840d39ea0bd..3e8aaea4f3c 100644 --- a/source/blender/imbuf/IMB_imbuf.h +++ b/source/blender/imbuf/IMB_imbuf.h @@ -280,6 +280,13 @@ struct ImBuf * IMB_anim_absolute(struct anim * anim, int position); /** * * @attention Defined in anim.c + * fetches a define previewframe, usually half way into the movie + */ +struct ImBuf * IMB_anim_previewframe(struct anim * anim); + +/** + * + * @attention Defined in anim.c */ void IMB_free_anim_ibuf(struct anim * anim); diff --git a/source/blender/imbuf/IMB_imbuf_types.h b/source/blender/imbuf/IMB_imbuf_types.h index d43b78df0b6..91ffa188fcc 100644 --- a/source/blender/imbuf/IMB_imbuf_types.h +++ b/source/blender/imbuf/IMB_imbuf_types.h @@ -56,6 +56,8 @@ struct _AviMovie; struct Mdec; +struct ImgInfo; + #define IB_MIPMAP_LEVELS 10 /** @@ -103,6 +105,7 @@ typedef struct ImBuf { float dither; /**< random dither value, for conversion from float -> byte rect */ struct MEM_CacheLimiterHandle_s * c_handle; /**< handle for cache limiter */ + struct ImgInfo * img_info; int refcounter; /**< Refcounter for multiple users */ int index; /**< reference index for ImBuf lists */ @@ -148,6 +151,7 @@ typedef enum { #define IB_rectfloat (1 << 15) #define IB_zbuffloat (1 << 16) #define IB_multilayer (1 << 17) +#define IB_imginfo (1 << 18) /* * The bit flag is stored in the ImBuf.ftype variable. diff --git a/source/blender/imbuf/IMB_thumbs.h b/source/blender/imbuf/IMB_thumbs.h new file mode 100644 index 00000000000..22565dac688 --- /dev/null +++ b/source/blender/imbuf/IMB_thumbs.h @@ -0,0 +1,73 @@ +/** + * $Id: $ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2007 Blender Foundation + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Andrea Weikert. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef _IMB_THUMBS_H +#define _IMB_THUMBS_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct ImBuf; + +/** Thumbnail creation and retrieval according to the 'Thumbnail Management Standard' + * supported by Gimp, Gnome (Nautilus), KDE etc. + * Reference: http://jens.triq.net/thumbnail-spec/index.html + */ + + +typedef enum ThumbSize { + THB_NORMAL, + THB_LARGE, + THB_FAIL +} ThumbSize; + +typedef enum ThumbSource { + THB_SOURCE_IMAGE, + THB_SOURCE_MOVIE +} ThumbSource; + +// IB_imginfo + +/* create thumbnail for file and returns new imbuf for thumbnail */ +ImBuf* IMB_thumb_create(const char* dir, const char* file, ThumbSize size, ThumbSource source); + +/* read thumbnail for file and returns new imbuf for thumbnail */ +ImBuf* IMB_thumb_read(const char* dir, const char* file, ThumbSize size); + +/* delete all thumbs for the file */ +void IMB_thumb_delete(const char* dir, const char* file, ThumbSize size); + +/* return the state of the thumb, needed to determine how to manage the thumb */ +ImBuf* IMB_thumb_manage(const char* dir, const char* file, ThumbSize size, ThumbSource source); + + + + +#endif /* _IMB_THUMBS_H */ diff --git a/source/blender/imbuf/intern/IMB_imginfo.h b/source/blender/imbuf/intern/IMB_imginfo.h new file mode 100644 index 00000000000..91073ec9575 --- /dev/null +++ b/source/blender/imbuf/intern/IMB_imginfo.h @@ -0,0 +1,78 @@ +/** + * $Id: $ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2005 Blender Foundation + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Austin Benesh. Ton Roosendaal. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef _IMB_IMGINFO_H +#define _IMB_IMGINFO_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct ImBuf; + +typedef struct ImgInfo { + struct ImgInfo *next, *prev; + char* key; + char* value; + int len; +} ImgInfo; + +/** The imginfo is a list of key/value pairs (both char*) that can me + saved in the header of several image formats. + Apart from some common keys like + 'Software' and 'Description' (png standard) we'll use keys within the + Blender namespace, so should be called 'Blender::StampInfo' or 'Blender::FrameNum' + etc... +*/ + + +/* free blender ImgInfo struct */ +void IMB_imginfo_free(struct ImBuf* img); + +/** read the field from the image info into the field + * @param img - the ImBuf that contains the image data + * @param key - the key of the field + * @param value - the data in the field, first one found with key is returned, + memory has to be allocated by user. + * @param len - length of value buffer allocated by user. + * @return - 1 (true) if ImageInfo present and value for the key found, 0 (false) otherwise + */ +int IMB_imginfo_get_field(struct ImBuf* img, const char* key, char* value, int len); + +/** set user data in the ImgInfo struct, which has to be allocated with IMB_imginfo_create + * before calling this function. + * @param img - the ImBuf that contains the image data + * @param key - the key of the field + * @param value - the data to be written to the field. zero terminated string + * @return - 1 (true) if ImageInfo present, 0 (false) otherwise + */ +int IMB_imginfo_add_field(struct ImBuf* img, const char* key, const char* field); + + +#endif /* _IMB_IMGINFO_H */ diff --git a/source/blender/imbuf/intern/allocimbuf.c b/source/blender/imbuf/intern/allocimbuf.c index 003d377389b..a5d404740cf 100644 --- a/source/blender/imbuf/intern/allocimbuf.c +++ b/source/blender/imbuf/intern/allocimbuf.c @@ -43,6 +43,7 @@ #include "IMB_divers.h" #include "IMB_allocimbuf.h" +#include "IMB_imginfo.h" #include "MEM_CacheLimiterC-Api.h" static unsigned int dfltcmap[16] = { @@ -163,6 +164,7 @@ void IMB_freeImBuf(struct ImBuf * ibuf) IMB_freecmapImBuf(ibuf); freeencodedbufferImBuf(ibuf); IMB_cache_limiter_unmanage(ibuf); + IMB_imginfo_free(ibuf); MEM_freeN(ibuf); } } @@ -476,6 +478,9 @@ struct ImBuf *IMB_dupImBuf(struct ImBuf *ibuf1) tbuf.mall = ibuf2->mall; tbuf.c_handle = 0; + // for now don't duplicate image info + tbuf.img_info = 0; + *ibuf2 = tbuf; if (ibuf1->cmap){ diff --git a/source/blender/imbuf/intern/anim.c b/source/blender/imbuf/intern/anim.c index a1ef735ffdb..24ea79ee90d 100644 --- a/source/blender/imbuf/intern/anim.c +++ b/source/blender/imbuf/intern/anim.c @@ -819,6 +819,18 @@ static struct ImBuf * anim_getnew(struct anim * anim) { return(ibuf); } +struct ImBuf * IMB_anim_previewframe(struct anim * anim) { + struct ImBuf * ibuf = 0; + int position = 0; + + ibuf = IMB_anim_absolute(anim, 0); + if (ibuf) { + IMB_freeImBuf(ibuf); + position = anim->duration / 2; + ibuf = IMB_anim_absolute(anim, position); + } + return ibuf; +} struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) { struct ImBuf * ibuf = 0; diff --git a/source/blender/imbuf/intern/imginfo.c b/source/blender/imbuf/intern/imginfo.c new file mode 100644 index 00000000000..c443b1be885 --- /dev/null +++ b/source/blender/imbuf/intern/imginfo.c @@ -0,0 +1,108 @@ +/** + * $Id: $ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2005 Blender Foundation + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Austin Benesh. Ton Roosendaal. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <stdlib.h> +#include <string.h> + +#include "BLI_blenlib.h" +#include "MEM_guardedalloc.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "IMB_imginfo.h" + + + +void IMB_imginfo_free(struct ImBuf* img) +{ + ImgInfo *info; + + if (!img) + return; + if (!img->img_info) { + return; + } + info = img->img_info; + while (info) { + ImgInfo* next = info->next; + MEM_freeN(info->key); + MEM_freeN(info->value); + MEM_freeN(info); + info = next; + } +} + +int IMB_imginfo_get_field(struct ImBuf* img, const char* key, char* field, int len) +{ + ImgInfo *info; + int retval = 0; + + if (!img) + return 0; + if (!img->img_info) { + return 0; + } + info = img->img_info; + while (info) { + if (strcmp(key, info->key) == 0) { + BLI_strncpy(field, info->value, len); + retval = 1; + break; + } + info = info->next; + } + return retval; +} + +int IMB_imginfo_add_field(struct ImBuf* img, const char* key, const char* field) +{ + ImgInfo *info; + ImgInfo *last; + + if (!img) + return 0; + + if (!img->img_info) { + img->img_info = MEM_callocN(sizeof(ImgInfo), "ImgInfo"); + info = img->img_info; + } else { + info = img->img_info; + last = info; + while (info) { + last = info; + info = info->next; + } + info = MEM_callocN(sizeof(ImgInfo), "ImgInfo"); + last->next = info; + } + info->key = BLI_strdup(key); + info->value = BLI_strdup(field); + return 1; +} diff --git a/source/blender/imbuf/intern/md5.c b/source/blender/imbuf/intern/md5.c new file mode 100644 index 00000000000..3119dd1fe7d --- /dev/null +++ b/source/blender/imbuf/intern/md5.c @@ -0,0 +1,360 @@ +/* md5.c - Functions to compute MD5 message digest of files or memory blocks + according to the definition of MD5 in RFC 1321 from April 1992. + Copyright (C) 1995 Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>. */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <sys/types.h> + +# include <stdlib.h> +# include <string.h> + +#include "md5.h" + +#ifdef WORDS_BIGENDIAN +# define SWAP(n) \ + (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24)) +#else +# define SWAP(n) (n) +#endif + + +/* This array contains the bytes used to pad the buffer to the next + 64-byte boundary. (RFC 1321, 3.1: Step 1) */ +static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ }; + + +/* Initialize structure containing state of computation. + (RFC 1321, 3.3: Step 3) */ +void +md5_init_ctx (ctx) + struct md5_ctx *ctx; +{ + ctx->A = 0x67452301; + ctx->B = 0xefcdab89; + ctx->C = 0x98badcfe; + ctx->D = 0x10325476; +} + +/* Put result from CTX in first 16 bytes following RESBUF. The result must + be in little endian byte order. */ +void * +md5_read_ctx (ctx, resbuf) + const struct md5_ctx *ctx; + void *resbuf; +{ + ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A); + ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B); + ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C); + ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D); + + return resbuf; +} + +/* Compute MD5 message digest for bytes read from STREAM. The + resulting message digest number will be written into the 16 bytes + beginning at RESBLOCK. */ +int +md5_stream (stream, resblock) + FILE *stream; + void *resblock; +{ + /* Important: BLOCKSIZE must be a multiple of 64. */ +#define BLOCKSIZE 4096 + struct md5_ctx ctx; + md5_uint32 len[2]; + char buffer[BLOCKSIZE + 72]; + size_t pad, sum; + + /* Initialize the computation context. */ + md5_init_ctx (&ctx); + + len[0] = 0; + len[1] = 0; + + /* Iterate over full file contents. */ + while (1) + { + /* We read the file in blocks of BLOCKSIZE bytes. One call of the + computation function processes the whole buffer so that with the + next round of the loop another block can be read. */ + size_t n; + sum = 0; + + /* Read block. Take care for partial reads. */ + do + { + n = fread (buffer, 1, BLOCKSIZE - sum, stream); + + sum += n; + } + while (sum < BLOCKSIZE && n != 0); + if (n == 0 && ferror (stream)) + return 1; + + /* RFC 1321 specifies the possible length of the file up to 2^64 bits. + Here we only compute the number of bytes. Do a double word + increment. */ + len[0] += sum; + if (len[0] < sum) + ++len[1]; + + /* If end of file is reached, end the loop. */ + if (n == 0) + break; + + /* Process buffer with BLOCKSIZE bytes. Note that + BLOCKSIZE % 64 == 0 + */ + md5_process_block (buffer, BLOCKSIZE, &ctx); + } + + /* We can copy 64 byte because the buffer is always big enough. FILLBUF + contains the needed bits. */ + memcpy (&buffer[sum], fillbuf, 64); + + /* Compute amount of padding bytes needed. Alignment is done to + (N + PAD) % 64 == 56 + There is always at least one byte padded. I.e. even the alignment + is correctly aligned 64 padding bytes are added. */ + pad = sum & 63; + pad = pad >= 56 ? 64 + 56 - pad : 56 - pad; + + /* Put the 64-bit file length in *bits* at the end of the buffer. */ + *(md5_uint32 *) &buffer[sum + pad] = SWAP (len[0] << 3); + *(md5_uint32 *) &buffer[sum + pad + 4] = SWAP ((len[1] << 3) + | (len[0] >> 29)); + + /* Process last bytes. */ + md5_process_block (buffer, sum + pad + 8, &ctx); + + /* Construct result in desired memory. */ + md5_read_ctx (&ctx, resblock); + return 0; +} + +/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The + result is always in little endian byte order, so that a byte-wise + output yields to the wanted ASCII representation of the message + digest. */ +void * +md5_buffer (buffer, len, resblock) + const char *buffer; + size_t len; + void *resblock; +{ + struct md5_ctx ctx; + char restbuf[64 + 72]; + size_t blocks = len & ~63; + size_t pad, rest; + + /* Initialize the computation context. */ + md5_init_ctx (&ctx); + + /* Process whole buffer but last len % 64 bytes. */ + md5_process_block (buffer, blocks, &ctx); + + /* REST bytes are not processed yet. */ + rest = len - blocks; + /* Copy to own buffer. */ + memcpy (restbuf, &buffer[blocks], rest); + /* Append needed fill bytes at end of buffer. We can copy 64 byte + because the buffer is always big enough. */ + memcpy (&restbuf[rest], fillbuf, 64); + + /* PAD bytes are used for padding to correct alignment. Note that + always at least one byte is padded. */ + pad = rest >= 56 ? 64 + 56 - rest : 56 - rest; + + /* Put length of buffer in *bits* in last eight bytes. */ + *(md5_uint32 *) &restbuf[rest + pad] = (md5_uint32) SWAP (len << 3); + *(md5_uint32 *) &restbuf[rest + pad + 4] = (md5_uint32) SWAP (len >> 29); + + /* Process last bytes. */ + md5_process_block (restbuf, rest + pad + 8, &ctx); + + /* Put result in desired memory area. */ + return md5_read_ctx (&ctx, resblock); +} + + +/* These are the four functions used in the four steps of the MD5 algorithm + and defined in the RFC 1321. The first function is a little bit optimized + (as found in Colin Plumbs public domain implementation). */ +/* #define FF(b, c, d) ((b & c) | (~b & d)) */ +#define FF(b, c, d) (d ^ (b & (c ^ d))) +#define FG(b, c, d) FF (d, b, c) +#define FH(b, c, d) (b ^ c ^ d) +#define FI(b, c, d) (c ^ (b | ~d)) + +/* Process LEN bytes of BUFFER, accumulating context into CTX. + It is assumed that LEN % 64 == 0. */ + +void +md5_process_block (buffer, len, ctx) + const void *buffer; + size_t len; + struct md5_ctx *ctx; +{ + md5_uint32 correct_words[16]; + const md5_uint32 *words = buffer; + size_t nwords = len / sizeof (md5_uint32); + const md5_uint32 *endp = words + nwords; + md5_uint32 A = ctx->A; + md5_uint32 B = ctx->B; + md5_uint32 C = ctx->C; + md5_uint32 D = ctx->D; + + /* Process all bytes in the buffer with 64 bytes in each round of + the loop. */ + while (words < endp) + { + md5_uint32 *cwp = correct_words; + md5_uint32 A_save = A; + md5_uint32 B_save = B; + md5_uint32 C_save = C; + md5_uint32 D_save = D; + + /* First round: using the given function, the context and a constant + the next context is computed. Because the algorithms processing + unit is a 32-bit word and it is determined to work on words in + little endian byte order we perhaps have to change the byte order + before the computation. To reduce the work for the next steps + we store the swapped words in the array CORRECT_WORDS. */ + +#define OP(a, b, c, d, s, T) \ + do \ + { \ + a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \ + ++words; \ + CYCLIC (a, s); \ + a += b; \ + } \ + while (0) + + /* It is unfortunate that C does not provide an operator for + cyclic rotation. Hope the C compiler is smart enough. */ +#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s))) + + /* Before we start, one word to the strange constants. + They are defined in RFC 1321 as + + T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 + */ + + /* Round 1. */ + OP (A, B, C, D, 7, 0xd76aa478); + OP (D, A, B, C, 12, 0xe8c7b756); + OP (C, D, A, B, 17, 0x242070db); + OP (B, C, D, A, 22, 0xc1bdceee); + OP (A, B, C, D, 7, 0xf57c0faf); + OP (D, A, B, C, 12, 0x4787c62a); + OP (C, D, A, B, 17, 0xa8304613); + OP (B, C, D, A, 22, 0xfd469501); + OP (A, B, C, D, 7, 0x698098d8); + OP (D, A, B, C, 12, 0x8b44f7af); + OP (C, D, A, B, 17, 0xffff5bb1); + OP (B, C, D, A, 22, 0x895cd7be); + OP (A, B, C, D, 7, 0x6b901122); + OP (D, A, B, C, 12, 0xfd987193); + OP (C, D, A, B, 17, 0xa679438e); + OP (B, C, D, A, 22, 0x49b40821); + + /* For the second to fourth round we have the possibly swapped words + in CORRECT_WORDS. Redefine the macro to take an additional first + argument specifying the function to use. */ +#undef OP +#define OP(f, a, b, c, d, k, s, T) \ + do \ + { \ + a += f (b, c, d) + correct_words[k] + T; \ + CYCLIC (a, s); \ + a += b; \ + } \ + while (0) + + /* Round 2. */ + OP (FG, A, B, C, D, 1, 5, 0xf61e2562); + OP (FG, D, A, B, C, 6, 9, 0xc040b340); + OP (FG, C, D, A, B, 11, 14, 0x265e5a51); + OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); + OP (FG, A, B, C, D, 5, 5, 0xd62f105d); + OP (FG, D, A, B, C, 10, 9, 0x02441453); + OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); + OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); + OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); + OP (FG, D, A, B, C, 14, 9, 0xc33707d6); + OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); + OP (FG, B, C, D, A, 8, 20, 0x455a14ed); + OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); + OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); + OP (FG, C, D, A, B, 7, 14, 0x676f02d9); + OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); + + /* Round 3. */ + OP (FH, A, B, C, D, 5, 4, 0xfffa3942); + OP (FH, D, A, B, C, 8, 11, 0x8771f681); + OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); + OP (FH, B, C, D, A, 14, 23, 0xfde5380c); + OP (FH, A, B, C, D, 1, 4, 0xa4beea44); + OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); + OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); + OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); + OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); + OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); + OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); + OP (FH, B, C, D, A, 6, 23, 0x04881d05); + OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); + OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); + OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); + OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); + + /* Round 4. */ + OP (FI, A, B, C, D, 0, 6, 0xf4292244); + OP (FI, D, A, B, C, 7, 10, 0x432aff97); + OP (FI, C, D, A, B, 14, 15, 0xab9423a7); + OP (FI, B, C, D, A, 5, 21, 0xfc93a039); + OP (FI, A, B, C, D, 12, 6, 0x655b59c3); + OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); + OP (FI, C, D, A, B, 10, 15, 0xffeff47d); + OP (FI, B, C, D, A, 1, 21, 0x85845dd1); + OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); + OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); + OP (FI, C, D, A, B, 6, 15, 0xa3014314); + OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); + OP (FI, A, B, C, D, 4, 6, 0xf7537e82); + OP (FI, D, A, B, C, 11, 10, 0xbd3af235); + OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); + OP (FI, B, C, D, A, 9, 21, 0xeb86d391); + + /* Add the starting values of the context. */ + A += A_save; + B += B_save; + C += C_save; + D += D_save; + } + + /* Put checksum in context given as argument. */ + ctx->A = A; + ctx->B = B; + ctx->C = C; + ctx->D = D; +} diff --git a/source/blender/imbuf/intern/md5.h b/source/blender/imbuf/intern/md5.h new file mode 100644 index 00000000000..ed38c192d2b --- /dev/null +++ b/source/blender/imbuf/intern/md5.h @@ -0,0 +1,115 @@ +/* md5.h - Declaration of functions and data types used for MD5 sum + computing library functions. + Copyright (C) 1995 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifndef _MD5_H +#define _MD5_H + +#include <stdio.h> + +#if defined HAVE_LIMITS_H || _LIBC +# include <limits.h> +#endif + +/* The following contortions are an attempt to use the C preprocessor + to determine an unsigned integral type that is 32 bits wide. An + alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but + doing that would require that the configure script compile and *run* + the resulting executable. Locally running cross-compiled executables + is usually not possible. */ + +#if defined __STDC__ && __STDC__ +# define UINT_MAX_32_BITS 4294967295U +#else +# define UINT_MAX_32_BITS 0xFFFFFFFF +#endif + +/* If UINT_MAX isn't defined, assume it's a 32-bit type. + This should be valid for all systems GNU cares about because + that doesn't include 16-bit systems, and only modern systems + (that certainly have <limits.h>) have 64+-bit integral types. */ + +#ifndef UINT_MAX +# define UINT_MAX UINT_MAX_32_BITS +#endif + +#if UINT_MAX == UINT_MAX_32_BITS + typedef unsigned int md5_uint32; +#else +# if USHRT_MAX == UINT_MAX_32_BITS + typedef unsigned short md5_uint32; +# else +# if ULONG_MAX == UINT_MAX_32_BITS + typedef unsigned long md5_uint32; +# else + /* The following line is intended to evoke an error. + Using #error is not portable enough. */ + "Cannot determine unsigned 32-bit data type." +# endif +# endif +#endif + +#undef __P +#if defined (__STDC__) && __STDC__ +#define __P(x) x +#else +#define __P(x) () +#endif + +/* Structure to save state of computation between the single steps. */ +struct md5_ctx +{ + md5_uint32 A; + md5_uint32 B; + md5_uint32 C; + md5_uint32 D; +}; + +/* + * The following three functions are build up the low level used in + * the functions `md5_stream' and `md5_buffer'. + */ + +/* Initialize structure containing state of computation. + (RFC 1321, 3.3: Step 3) */ +void md5_init_ctx __P ((struct md5_ctx *ctx)); + +/* Starting with the result of former calls of this function (or the + initialzation function update the context for the next LEN bytes + starting at BUFFER. + It is necessary that LEN is a multiple of 64!!! */ +void md5_process_block __P ((const void *buffer, size_t len, + struct md5_ctx *ctx)); + +/* Put result from CTX in first 16 bytes following RESBUF. The result is + always in little endian byte order, so that a byte-wise output yields + to the wanted ASCII representation of the message digest. */ +void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf)); + + +/* Compute MD5 message digest for bytes read from STREAM. The + resulting message digest number will be written into the 16 bytes + beginning at RESBLOCK. */ +int md5_stream __P ((FILE *stream, void *resblock)); + +/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The + result is always in little endian byte order, so that a byte-wise + output yields to the wanted ASCII representation of the message + digest. */ +void *md5_buffer __P ((const char *buffer, size_t len, void *resblock)); + +#endif diff --git a/source/blender/imbuf/intern/png.c b/source/blender/imbuf/intern/png.c index 46c5232a61a..bb48ff71bff 100644 --- a/source/blender/imbuf/intern/png.c +++ b/source/blender/imbuf/intern/png.c @@ -43,6 +43,7 @@ #include "IMB_allocimbuf.h" #include "IMB_cmap.h" +#include "IMB_imginfo.h" #include "IMB_png.h" typedef struct PNGReadStruct { @@ -100,6 +101,7 @@ short imb_savepng(struct ImBuf *ibuf, char *name, int flags) { png_structp png_ptr; png_infop info_ptr; + unsigned char *pixels = 0; unsigned char *from, *to; png_bytepp row_pointers = 0; @@ -219,6 +221,33 @@ short imb_savepng(struct ImBuf *ibuf, char *name, int flags) PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + /* image text info */ + if (ibuf->img_info) { + png_text* imginfo; + ImgInfo* iptr; + int num_text = 0; + iptr = ibuf->img_info; + while (iptr) { + num_text++; + iptr = iptr->next; + } + + imginfo = MEM_callocN(num_text*sizeof(png_text), "png_imginfo"); + iptr = ibuf->img_info; + num_text = 0; + while (iptr) { + imginfo[num_text].compression = PNG_TEXT_COMPRESSION_NONE; + imginfo[num_text].key = iptr->key; + imginfo[num_text].text = iptr->value; + num_text++; + iptr = iptr->next; + } + + png_set_text(png_ptr, info_ptr, imginfo, num_text); + MEM_freeN(imginfo); + + } + // write the file header information png_write_info(png_ptr, info_ptr); @@ -409,6 +438,15 @@ struct ImBuf *imb_loadpng(unsigned char *mem, int size, int flags) break; } + if (flags & IB_imginfo) { + png_text* text_chunks; + int count = png_get_text(png_ptr, info_ptr, &text_chunks, NULL); + for(i = 0; i < count; i++) { + IMB_imginfo_add_field(ibuf, text_chunks[i].key, text_chunks[i].text); + ibuf->flags |= IB_imginfo; + } + } + png_read_end(png_ptr, info_ptr); } diff --git a/source/blender/imbuf/intern/thumbs.c b/source/blender/imbuf/intern/thumbs.c new file mode 100644 index 00000000000..6976aff6b39 --- /dev/null +++ b/source/blender/imbuf/intern/thumbs.c @@ -0,0 +1,457 @@ +/** + * $Id: $ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2007 Blender Foundation + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Andrea Weikert. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include "BKE_global.h" +#include "BKE_utildefines.h" +#include "BLI_blenlib.h" +#include "MEM_guardedalloc.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" +#include "IMB_thumbs.h" +#include "IMB_imginfo.h" + + +#include "md5.h" + +#ifdef WIN32 +#include <windows.h> /* need to include windows.h so _WIN32_IE is defined */ +#ifndef _WIN32_IE +#define _WIN32_IE 0x0400 /* minimal requirements for SHGetSpecialFolderPath on MINGW MSVC has this defined already */ +#endif +#include <shlobj.h> /* for SHGetSpecialFolderPath, has to be done before BLI_winstuff because 'near' is disabled through BLI_windstuff */ +#include "BLI_winstuff.h" +#include <process.h> /* getpid */ +#else +#include <unistd.h> +#endif + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <stdio.h> + +#define URI_MAX FILE_MAX*3 + 8 + +static int get_thumb_dir( char* dir , ThumbSize size) +{ + char* home; + +#ifdef WIN32 + /* yes, applications shouldn't store data there, but so does GIMP :)*/ + SHGetSpecialFolderPath(0, dir, CSIDL_PROFILE, 0); +#else + home = getenv("HOME"); + if (!home) return 0; + BLI_strncpy(dir, home, FILE_MAX); +#endif + switch(size) { + case THB_NORMAL: + strcat(dir, "/.thumbnails/normal"); + break; + case THB_LARGE: + strcat(dir, "/.thumbnails/large"); + break; + case THB_FAIL: + strcat(dir, "/.thumbnails/fail/blender"); + break; + default: + return 0; /* unknown size */ + } + BLI_cleanup_dir(G.sce, dir); + return 1; +} + +/** ----- begin of adapted code from glib --- + * The following code is adapted from function g_escape_uri_string from the gnome glib + * Source: http://svn.gnome.org/viewcvs/glib/trunk/glib/gconvert.c?view=markup + * released under the Gnu General Public License. + */ +typedef enum { + UNSAFE_ALL = 0x1, /* Escape all unsafe characters */ + UNSAFE_ALLOW_PLUS = 0x2, /* Allows '+' */ + UNSAFE_PATH = 0x8, /* Allows '/', '&', '=', ':', '@', '+', '$' and ',' */ + UNSAFE_HOST = 0x10, /* Allows '/' and ':' and '@' */ + UNSAFE_SLASHES = 0x20 /* Allows all characters except for '/' and '%' */ +} UnsafeCharacterSet; + +static const unsigned char acceptable[96] = { + /* A table of the ASCII chars from space (32) to DEL (127) */ + /* ! " # $ % & ' ( ) * + , - . / */ + 0x00,0x3F,0x20,0x20,0x28,0x00,0x2C,0x3F,0x3F,0x3F,0x3F,0x2A,0x28,0x3F,0x3F,0x1C, + /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ + 0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x38,0x20,0x20,0x2C,0x20,0x20, + /* @ A B C D E F G H I J K L M N O */ + 0x38,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F, + /* P Q R S T U V W X Y Z [ \ ] ^ _ */ + 0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x20,0x3F, + /* ` a b c d e f g h i j k l m n o */ + 0x20,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F, + /* p q r s t u v w x y z { | } ~ DEL */ + 0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x3F,0x20 +}; + +static const char hex[16] = "0123456789abcdef"; + +/* Note: This escape function works on file: URIs, but if you want to + * escape something else, please read RFC-2396 */ +void escape_uri_string (const char *string, char* escaped_string, int len,UnsafeCharacterSet mask) +{ +#define ACCEPTABLE(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask)) + + const char *p; + char *q; + int c; + UnsafeCharacterSet use_mask; + use_mask = mask; + + for (q = escaped_string, p = string; (*p != '\0') && len; p++) { + c = (unsigned char) *p; + len--; + + if (!ACCEPTABLE (c)) { + *q++ = '%'; /* means hex coming */ + *q++ = hex[c >> 4]; + *q++ = hex[c & 15]; + } else { + *q++ = *p; + } + } + + *q = '\0'; +} + +void to_hex_char(char* hexbytes, const unsigned char* bytes, int len) +{ + const unsigned char *p; + char *q; + + for (q = hexbytes, p = bytes; len; p++) { + const unsigned char c = (unsigned char) *p; + len--; + *q++ = hex[c >> 4]; + *q++ = hex[c & 15]; + } +} + +/** ----- end of adapted code from glib --- */ + +static int uri_from_filename( const char *dir, const char *file, char *uri ) +{ + char orig_uri[URI_MAX]; + const char* dirstart = dir; + +#ifdef WIN32 + { + char vol[3]; + + BLI_strncpy(orig_uri, "file:///", FILE_MAX); + if (strlen(dir) < 2 && dir[1] != ':') { + /* not a correct absolute path */ + return 0; + } + /* on windows, using always uppercase drive/volume letter in uri */ + vol[0] = toupper(dir[0]); + vol[1] = ':'; + vol[2] = '\0'; + strcat(orig_uri, vol); + dirstart += 2; + } +#else + BLI_strncpy(orig_uri, "file://", FILE_MAX); +#endif + strcat(orig_uri, dirstart); + strcat(orig_uri, file); + BLI_char_switch(orig_uri, '\\', '/'); + +#ifdef WITH_ICONV + { + escape_uri_string(orig_uri, uri_utf8, FILE_MAX*3+8, UNSAFE_PATH); + BLI_string_to_utf8(uri_utf8, uri, NULL); + char uri_utf8[FILE_MAX*3+8]; + } +#else + escape_uri_string(orig_uri, uri, FILE_MAX*3+8, UNSAFE_PATH); +#endif + return 1; +} + +static void thumbname_from_uri(const char* uri, char* thumb) +{ + char hexdigest[33]; + unsigned char digest[16]; + + md5_buffer( uri, strlen(uri), digest); + hexdigest[0] = '\0'; + to_hex_char(hexdigest, digest, 16); + hexdigest[32] = '\0'; + sprintf(thumb, "%s.png", hexdigest); +} + +static int thumbpath_from_uri(const char* uri, char* path, ThumbSize size) +{ + char tmppath[FILE_MAX]; + int rv = 0; + + if (get_thumb_dir(tmppath, size)) { + char thumb[40]; + thumbname_from_uri(uri, thumb); + BLI_snprintf(path, FILE_MAX, "%s%s", tmppath, thumb); + rv = 1; + } + return rv; +} + + +/* create thumbnail for file and returns new imbuf for thumbnail */ +ImBuf* IMB_thumb_create(const char* dir, const char* file, ThumbSize size, ThumbSource source) +{ + ImBuf *img = 0; + char uri[URI_MAX]; + char desc[URI_MAX+22]; + char tpath[FILE_MAX]; + char tdir[FILE_MAX]; + char wdir[FILE_MAX]; + char temp[FILE_MAX]; + char mtime[40]; + char cwidth[40]; + char cheight[40]; + char thumb[40]; + short tsize = 128; + short ex, ey; + float scaledx, scaledy; + struct stat info; + + switch(size) { + case THB_NORMAL: + tsize = 128; + break; + case THB_LARGE: + tsize = 256; + break; + case THB_FAIL: + tsize = 0; + break; + default: + return 0; /* unknown size */ + } + + uri_from_filename(dir, file,uri); + thumbname_from_uri(uri, thumb); + if (get_thumb_dir(tdir, size)) { + BLI_snprintf(tpath, FILE_MAX, "%s%s", tdir, thumb); + thumb[8] = '\0'; /* shorten for tempname, not needed anymore */ + BLI_snprintf(temp, FILE_MAX, "%sblender_%d_%s.png", tdir, abs(getpid()), thumb); + if (strncmp(thumb, dir, strlen(dir)) == 0) { + return NULL; + } + if (size == THB_FAIL) { + img = IMB_allocImBuf(0,0,32, IB_rect | IB_imginfo, 0); + if (!img) return 0; + } else { + if (THB_SOURCE_IMAGE == source) { + BLI_getwdN(wdir); + chdir(dir); + img = IMB_loadiffname(file, IB_rect); + stat(file, &info); + sprintf(mtime, "%ld", info.st_mtime); + sprintf(cwidth, "%d", img->x); + sprintf(cheight, "%d", img->y); + chdir(wdir); + } else if (THB_SOURCE_MOVIE == source) { + struct anim * anim = NULL; + BLI_getwdN(wdir); + chdir(dir); + anim = IMB_open_anim(file, IB_rect | IB_imginfo); + if (anim != NULL) { + img = IMB_anim_absolute(anim, 0); + if (img == NULL) { + printf("not an anim; %s\n", file); + } else { + IMB_freeImBuf(img); + img = IMB_anim_previewframe(anim); + } + IMB_free_anim(anim); + } + stat(file, &info); + sprintf(mtime, "%ld", info.st_mtime); + chdir(wdir); + } + if (!img) return 0; + + if (img->x > img->y) { + scaledx = (float)tsize; + scaledy = ( (float)img->y/(float)img->x )*tsize; + } + else { + scaledy = (float)tsize; + scaledx = ( (float)img->x/(float)img->y )*tsize; + } + ex = (short)scaledx; + ey = (short)scaledy; + + IMB_scaleImBuf(img, ex, ey); + } + sprintf(desc, "Thumbnail for %s", uri); + IMB_imginfo_add_field(img, "Description", desc); + IMB_imginfo_add_field(img, "Software", "Blender"); + IMB_imginfo_add_field(img, "Thumb::URI", uri); + IMB_imginfo_add_field(img, "Thumb::MTime", mtime); + if (THB_SOURCE_IMAGE == source) { + IMB_imginfo_add_field(img, "Thumb::Image::Width", cwidth); + IMB_imginfo_add_field(img, "Thumb::Image::Height", cheight); + } + img->ftype = PNG; + img->depth = 32; + if (IMB_saveiff(img, temp, IB_rect | IB_imginfo)) { +#ifndef WIN32 + chmod(temp, S_IRUSR | S_IWUSR); +#endif + BLI_rename(temp, tpath); + } + + return img; + } + return img; +} + +/* read thumbnail for file and returns new imbuf for thumbnail */ +ImBuf* IMB_thumb_read(const char* dir, const char* file, ThumbSize size) +{ + char thumb[FILE_MAX]; + char uri[FILE_MAX*3+8]; + ImBuf *img = 0; + + if (!uri_from_filename(dir, file,uri)) { + return NULL; + } + if (thumbpath_from_uri(uri, thumb, size)) { + img = IMB_loadiffname(thumb, IB_rect | IB_imginfo); + } + + return img; +} + +/* delete all thumbs for the file */ +void IMB_thumb_delete(const char* dir, const char* file, ThumbSize size) +{ + char thumb[FILE_MAX]; + char uri[FILE_MAX*3+8]; + + if (!uri_from_filename(dir, file,uri)) { + return; + } + if (thumbpath_from_uri(uri, thumb, size)) { + if (strncmp(thumb, dir, strlen(dir)) == 0) { + return; + } + if (BLI_exists(thumb)) { + BLI_delete(thumb, 0, 0); + } + } +} + + +/* create the thumb if necessary and manage failed and old thumbs */ +ImBuf* IMB_thumb_manage(const char* dir, const char* file, ThumbSize size, ThumbSource source) +{ + char path[FILE_MAX]; + char thumb[FILE_MAX]; + char uri[FILE_MAX*3+8]; + struct stat st; + ImBuf* img = NULL; + + BLI_join_dirfile(path, dir, file); + if (stat(path, &st)) { + return NULL; + } + if (!uri_from_filename(dir, file,uri)) { + return NULL; + } + if (thumbpath_from_uri(uri, thumb, THB_FAIL)) { + /* failure thumb exists, don't try recreating */ + if (BLI_exists(thumb)) { + return NULL; + } + } + + if (thumbpath_from_uri(uri, thumb, size)) { + if (strncmp(thumb, dir, strlen(dir)) == 0) { + img = IMB_loadiffname(path, IB_rect); + } else { + img = IMB_loadiffname(thumb, IB_rect | IB_imginfo); + if (img) { + char mtime[40]; + if (!IMB_imginfo_get_field(img, "Thumb::MTime", mtime, 40)) { + /* illegal thumb, forget it! */ + IMB_freeImBuf(img); + img = 0; + } else { + time_t t = atol(mtime); + if (st.st_mtime != t) { + /* recreate all thumbs */ + IMB_freeImBuf(img); + img = 0; + IMB_thumb_delete(dir, file, THB_NORMAL); + IMB_thumb_delete(dir, file, THB_LARGE); + IMB_thumb_delete(dir, file, THB_FAIL); + img = IMB_thumb_create(dir, file, size, source); + if(!img){ + /* thumb creation failed, write fail thumb */ + img = IMB_thumb_create(dir, file, THB_FAIL, source); + if (img) { + /* we don't need failed thumb anymore */ + IMB_freeImBuf(img); + img = 0; + } + } + } + } + } else { + img = IMB_thumb_create(dir, file, size, source); + if(!img){ + /* thumb creation failed, write fail thumb */ + img = IMB_thumb_create(dir, file, THB_FAIL, source); + if (img) { + /* we don't need failed thumb anymore */ + IMB_freeImBuf(img); + img = 0; + } + } + } + } + } + + return img; +} + + |