A cópia do código é a seguinte:
<! Doctype html public "-// w3c // dtd xhtml 1.0 transitional // pt" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-bransitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv = "content-type" content = "text /html; charset = gb2312" />
<estilo>
corpo {preenchimento-esquerda: 75px; cor de fundo: bege}
</style>
<Cript>
/////////////////////////////////////////////////////////Tipos ///////////////////
// Base64 codificou a decodificação de imagem GIF
// por mozart0
// 2005/10/29
////////////////////////////////////////////////
// Crie um objeto de classe GIF
// O GIF da classe é definido internamente nesta função
// STR64: BASE64 String codificada do arquivo GIF
// devolveu com sucesso o objeto GIF criado
// retorna nulo se falhar
função getGif (str64) {
var bytes = decodeBase64 (str64);
if (! bytes) {
alerta ("Erro: codificação inválida base64");
retornar nulo;
}
var gif = new gif ();
for (var i = 0; i <6; i ++)
gif.version+= string.fromCharcode (bytes [i]);
if (gif.version.slice (0,3)! = "gif") {
alerta ("Erro: formato de imagem não-GIF");
retornar nulo;
}
gif.width = bytes [i] | (bytes [i+1] << 8);
gif.Height = bytes [i+2] | (bytes [i+3] << 8);
var f = bytes [i+4];
gif.colorresolution = (f >> 4 & 0x7) +1;
gif.sorted = (f & 0x8)? true: false;
gif.backgroundIndex = bytes [i+5];
gif.pixElAspetradio = bytes [i+6];
if (f & 0x80) {
gif.globalPalette = [];
i+= getPalette (i+7, bytes, gif.globalpalette, 2 << (f & 0x7));
}
i+= 7;
for (var j = i; j <bytes.length; j ++)
if (bytes [j] == 0x21 && bytes [j+1] == 0xf9)
quebrar;
if (j == bytes.length) {
para (; i <bytes.length; i ++)
if (bytes [i] == 0x2C)
quebrar;
if (i == bytes.length) {
alerta ("erro: dados de imagem não encontrados");
retornar nulo;
}
var f = new gif_frame ();
if (! getsingleframe (i, f))
retornar nulo;
outro
gif.frames.push (f);
}
outro{
i = j;
fazer{
var f = new gif_frame ();
var t = getsingleFrame (i, f);
se (! t)
retornar nulo;
gif.frames.push (f);
para (i+= t; i <bytes.length; i ++)
if (bytes [i] == 0x21 && bytes [i+1] == 0xf9)
quebrar;
}
enquanto (i <bytes.length);
}
retornar gif;
// Processo interno, gerar tabela de cores
função getpalette (pos, s, d, len) {
len*= 3;
for (var i = pos; i <pos+len; i+= 3)
d.push ('#'+(s [i] <= 0xf? "0": "")+s [i] .ToString (16)
+(s [i+1] <= 0xf? "0": "")+s [i+1] .ToString (16)
+(s [i+2] <= 0xf? "0": "")+s [i+2] .ToString (16));
retornar Len;
}
// Processo interno, integrando segmentos de dados
função getBlock (pos, s, d) {
var p = pos;
while (len = s [p ++]) {
for (var i = 0; i <len; i ++)
d.push (s [p+i]);
p+= len;
}
retornar P-poss;
}
// Processo interno, obtenha um quadro de dados
função getsingleframe (pos, quadro) {
var i = pos;
if (bytes [i] == 0x21) {
i+= 3;
if (bytes [i] e 1)
frame.transparentIndex = bytes [i+3];
frame.Delay = bytes [i+1] | (bytes [i+2] << 8);
para (i+= 5; i <bytes.length && bytes [i]! = 0x2c; i ++);
if (i == bytes.length) {
alerta ("Erro: identificador de imagem não encontrado");
retornar 0;
}
}
frame.offsetx = bytes [i+1] | (bytes [i+2] << 8);
frame.offsety = bytes [i+3] | (bytes [i+4] << 8);
frame.width = bytes [i+5] | (bytes [i+6] << 8);
frame.Height = bytes [i+7] | (bytes [i+8] << 8);
var f = bytes [i+9];
i+= 10;
if (f & 0x40)
frame.interlace = true;
if (f & 0x20)
frame.SortEd = true;
if (f & 0x80) {
frame.colorresolution = (f & 0x7) +1;
frame.localPalette = [];
i+= getPalette (i, bytes, frame.localpalette, 1 << frame.colorresolution);
}
outro{
frame.colorresolution = gif.colorresolution;
frame.localPalette = gif.globalPalette;
}
var lzwlen = bytes [i ++]+1;
i+= getBlock (i, bytes, frame.data);
frame.data = decodelzw (quadro.data, lzwlen);
Return frame.data?i-poss:0;
}
// Defina a estrutura de dados para armazenar arquivos GIF
// Forneça o Method ShowInfo, Retornar Informações da imagem
function gif () {
this.version = "";
this.width = 0;
this.Height = 0; // Altura da tela logística
this.colorresolution = 0; // profundidade de cor
this.sorted = false;
this.GlobalPalette = NULL;
this.backgroundIndex = -1;
this.pixElAspetradio = 0;
this.frames = [];
this.showinfo = function (SEP) {// Mostrar informações da imagem, SEP é o separador de linha
se (! set)
SEP = "/n";
var s = "Informações do GIF:"+SEP+"----------------------------------------- -------------------------------------------------------- -------------------------
s+= subinfo (this)+SEP;
for (var i = 0; i <this.frames.length; i ++)
s+= set+"quadros"+i+"------------------------------------------- -------------------------------------------------------- -----------------------
retorno s;
função subinfo (o) {
var s = "";
para (var i em o) {
if (i == "showInfo" || i == "draw")
continuar;
s+= set+i+":";
if (typeof (o [i]) == "objeto")
s+= (o [i]? O [i] .Length: "null");
outro
s+= o [i];
}
retorno s;
}
}
}
// Defina a estrutura de dados que armazena um quadro de imagens
// Fornecer desenho de método, desenho
function gif_frame () {
this.offsetx = 0; // Offset de direção x
this.offsety = 0;
this.width = 0;
this.Height = 0;
this.localpalette = nulo;
this.colorresolution = 0; // profundidade de cor
this.interlace = false; // sinalização intercalada
this.sorted = false;
this.data = [];
this.TransparentIndex = -1;
this.Delay = 0;
this.draw = function (pai, zoom) {
if (! this.data.length)
retornar;
se (! pai)
pai = document.body;
se (! Zoom)
zoom = 1;
if (parent.clientwidth <this.width*zoom)
parent.style.width = this.width*zoom;
if (parent.clientHeight <this.Height*zoom)
parent.style.Height = this.Height*zoom;
var id = "imgDefaultDraw";
var iMg = document.getElementById (id);
se (img)
excluir parent.RemoveChild (IMG);
img = document.createElement ("div");
img.id = id;
parent.appendChild (IMG);
img.style.position = "absoluto";
var t = document.createElement ("div");
t.style.overflow = "Hidden";
t.style.position = "absoluto";
deflayout (this.data, this.localpalette, this.width, this.Height, img, t, zoom);
excluir t;
}
}
}
// base64 decodificação
// strin, insira a string
// Um retorno bem -sucedido de uma matriz, cada elemento contém um byte de informação
// retorna nulo se falhar
função decodebase64 (strin) {
if (! strin.length || strin.length%4)
retornar nulo;
var str64 =
"Abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/=";
var index64 = [];
for (var i = 0; i <str64.Length; i ++)
index64 [str64.charat (i)] = i;
var C0, C1, C2, C3, B0, B1, B2;
var len = strin.length;
var len1 = len;
if (strin.Charat (len-1) == '=')
len1- = 4;
var resultado = [];
for (var i = 0, j = 0; i <len1; i+= 4) {
c0 = index64 [strin.Charat (i)];
c1 = index64 [strin.Charat (i+1)];
c2 = index64 [strin.Charat (i+2)];
c3 = index64 [strin.Charat (i+3)];
b0 = (C0 << 2) | (C1 >> 4);
B1 = (C1 << 4) | (C2 >> 2);
B2 = (C2 << 6) | C3;
resultado.push (b0 e 0xff);
resultado.push (b1 e 0xff);
resultado.push (b2 e 0xff);
}
if (len1! = len) {
c0 = index64 [strin.Charat (i)];
c1 = index64 [strin.Charat (i+1)];
c2 = strin.Charat (i+2);
b0 = (C0 << 2) | (C1 >> 4);
resultado.push (b0 e 0xff);
if (c2! = '=') {
C2 = index64 [C2];
B1 = (C1 << 4) | (C2 >> 2);
resultado.push (b1 e 0xff);
}
}
resultado de retorno;
}
// Função de decodificação LZW para GIF
// Arrbytes é os dados de origem, NBITs é o número inicial de bits codificados
// retornou com sucesso a matriz, cada elemento inclui um índice de cores
// retorna nulo se falhar
função decodelzw (Arrbytes, nbits) {
var cc = 1 << (nbits-1);
var eoi = cc+1;
var tabela = [], máscara = [], resultado = [];
para (var i = 0; i <cc; i ++)
Tabela [i] = (i >> 8 e 0xf) .ToString (16)
+(i >> 4 & 0xf) .ToString (16)+(i & 0xf) .ToString (16);
para (i = 2, máscara [1] = 1; i <13; i ++)
máscara [i] = máscara [i-1] << 1 | 1;
var bc = nbits;
var pos = 0, temp = 0, tleft = 0, código = 0, antigo = 0;
while (true) {
while (tleft <bc) {
temp = temp | (arrbytes [pos ++] << tleft);
tleft+= 8;
}
código = temp & máscara [bc];
tleft- = bc;
temp >> = bc;
if (code == eoi)
quebrar;
if (code == cc) {
tabela.Length = CC+2;
bc = nbits;
antigo = código;
continuar;
}
var t = "";
if (code <table.length) {
t = tabela [código];
if (antigo! = cc)
tabela.push (tabela [antiga]+t.slice (0,3));
}
else if (antigo <table.length) {
t = tabela [antigo]+tabela [antiga] .Slice (0,3);
tabela.push (t);
}
outro{
alerta ("erro: dados de imagem inválidos");
retornar nulo;
}
antigo = código;
for (var i = 0; i <t.Length; i+= 3)
resultado.push (parseint (t.substr (i, 3), 16))
if (table.length == 1 << bc && bc <12)
BC ++;
}
resultado de retorno;
}
// Desenhe com o mínimo de div de acordo com o layout de dados da matriz de bytes
função deflayout (dados, paleta, largura, altura, imagem, bloco, zoom) {
var map = nova matriz (altura);
for (var i = 0; i <altura; i ++) {
mapa [i] = nova matriz (largura);
for (var j = 0; j <largura; j ++)
mapa [i] [j] = dados [i*width+j];
}
var i, j, i1, i2, j1, j2, c;
para (i = 0; i <altura; i ++)
para (j = 0; j <largura;) {
if (mapa [i] [j] == 0x100) {
j ++;
continuar;
}
c = mapa [i] [j];
for (i1 = i+1; i1 <altura && map [i1] [j] == c; i1 ++);
for (j1 = j+1; j1 <width; j1 ++) {
para (i2 = i; i2 <i1 && map [i2] [j1] == c; i2 ++);
se (i2 <i1)
quebrar;
}
para (i2 = i; i2 <i1; i2 ++)
para (j2 = j; j2 <j1; j2 ++)
mapa [i2] [j2] = 0x100;
var x = block.cloneNode (true);
x.style.left = j*zoom;
x.style.top = i*zoom;
x.style.width = (j1-j)*zoom;
x.style.Height = (i1-i)*zoom;
x.style.backgroundColor = paleta [c];
image.appendChild (x);
j = j1;
}
}
</Script>
<Cript>
função main () {
var t = new Date (). getTime ();
var xmldom = document.getElementById ("imgdata");
var gif=getGif("R0lGODlhDwAPAKECAAAAzMzM//////wAAACwAAAADwAPAAACIISPeQHsrZ5ModrLlN48CXF8m2iQ3YmmKqVlRtW4MLwWACH+H09wdGltXp lZCBieSBVbGVhZCBTbWFydFNhdmVyIQAAOw==");
var info = document.getElementById ("info");
info.innerhtml = gif.showinfo ("<br>");
t = new Date (). getTime ();
gif.frames [0] .Draw (document.getElementById ("Canvas"), 1);
info.innerhtml+= "<br> Time de desenho"+(new Date (). getTime ()-t)+"ms";
}
</Script>
<corpo onload = "main ()">
<div id = "Canvas"> </div>
<HR>
<div id = "info"> A página está carregando, por favor aguarde ... </div>
</body>
</html>
PS: Aqui estão algumas ferramentas de imagem online para sua referência
Conversão de imagem para base64 Codificação on -line Ferramenta:
http://tools.vevb.com/transcoding/img2base64
Ferramenta de criação de ícone por e -mail on -line:
http://tools.vevb.com/email/emaillogo
Ferramenta de processamento de imagem PS online:
http://tools.vevb.com/aideddesign/webps
Ferramenta de formato de imagem on -line (ferramenta JPG/BMP/GIF/PNG):
http://tools.vevb.com/aideddesign/picext
Ferramenta de geração on -line do ICO ICON:
http://tools.vevb.com/aideddesign/ico_img
Anexo: Além disso, recomenda -se uma ferramenta de conversão de codificação BASE64
Ferramenta de codificação e decodificação base64:
http://tools.vevb.com/transcoding/base64