BASE64

Preguntaron como codificar y descodificar una imagen en BASE64 sin utilizar la API, como había hecho en este hilo, se trataba de usarlo en un entorno ajeno a Windows (Android). Al leer la pregunta no pude resistirme a implementar mi propia versión sin grandes pretensiones, usando pascal sin las facilidades de la VCL.

BASE64 se basa a usar los bytes de un buffer en conjuntos de 6 bits, de forma que el mayor número es el 111111b es decir, 63 en decimal. A cada valor obtenido se le asigna un carácter de un alfabeto de 64 caracteres. Si faltan bits se añaden ceros y se codifican con uno o dos caracteres '=' (según falten 8 ó 16 bits) para informar al decodificador. La decodificación es a la inversa.
 
El tamaño del buffer de salida codificado, cuando no se introducen retornos de carro y línea se puede calcular así: ((L+2) div 3)*4. Y cuando se decodifica el tamaño será (L*3) div 4. El decodificador debe ignorar cualquier carácter que no esté en el alfabeto.
 
Escribí el código en una unit que publico a continuación:

unit BASE64;
 
interface
 
type
  TAByte = Array of Byte;
  PAByte = ^TAByte;
 
  function Decode64(var S: String): TAByte;
  function Encode64(Bin: PByte; Count: integer): String;
 
implementation
 
const
  SB64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
  IB64: array[#0..#255] of integer = (
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $3E, $FF, $FF, $FF, $3F,
    $34, $35, $36, $37, $38, $39, $3A, $3B, $3C, $3D, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $00, $01, $02, $03, $04, $05, $06, $07, $08, $09, $0A, $0B, $0C, $0D, $0E,
    $0F, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $FF, $FF, $FF, $FF, $FF,
    $FF, $1A, $1B, $1C, $1D, $1E, $1F, $20, $21, $22, $23, $24, $25, $26, $27, $28,
    $29, $2A, $2B, $2C, $2D, $2E, $2F, $30, $31, $32, $33, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
    $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF
  );
 
type
  SAByte = Array[0..0] of Byte;
  PSAByte = ^SAByte;
 
function Decode64(var S: String): TAByte;
var
  B: array[0..3] of BYTE;
  L, n, i, j: integer;
begin
  n:= 1;
  i:= 0;
  L:= Length(S);
  if L < 4 then exit;
  while S[L] = '=' do dec(L);
  SetLength(Result, (L*3) div 4);
  repeat
    for j:= 0 to 3 do
    begin
      while (n < L) and (IB64[S[n]] = $FF) do inc(n); B[j]:= IB64[S[n]]; inc(n);
    end;
    Result[i]:=   (B[0] shl 2) or (B[1] shr 4);
    if B[2] = 255 then break;
    Result[i+1]:= (B[1] shl 4) or (B[2] shr 2);
    if B[3] = 255 then break;
    Result[i+2]:= (B[2] shl 6) or B[3];
    inc(i, 3);
  until n > L;
end;
 
function Encode64(Bin: PByte; Count: integer): String;
var
  B0, B1, B2: BYTE;
  ABin: PSAByte;
  L, n, i: integer;
begin
  if Count = 0 then exit;
  ABin:= PSAByte(Bin);
  n:= 0;
  i:=1;
  L:= ((Count+2) div 3)*4;
  SetLength(Result, L);
  repeat
    B0:= ABin^[n];
    B1:= 0; B2:= 0;
    if (Count - n) > 0 then B1:= ABin^[n+1];
    if (Count - n) > 1 then B2:= ABin^[n+2];
    Result[i]:=   SB64[(B0 shr 2) and $003F +1];
    Result[i+1]:= SB64[((B0 shl 4) or (B1 shr 4)) and $3F +1];
    Result[i+2]:= SB64[((B1 shl 2) or (B2 shr 6)) and $3F +1];
    Result[i+3]:= SB64[(B2 and $3F) +1];
    inc(n,3);
    inc(i,4);
  until n >= Count;
  if n - Count >= 1 then Result[L]:=   '=';
  if n - Count = 2  then Result[L-1]:= '=';
end;
 
end.

Si deseamos usar este código para trabajar con stream sin modificar la unit, podemos implementar estas dos funciones añadidas en otra unit:

function StreamEncode64(MStream: TMemoryStream): string;
begin
  Result:= Encode64(MStream.Memory, MStream.Size);
end;
 
procedure StreamDencode64(var S: String; MStream: TMemoryStream);
var
  Bytes: TAByte;
begin
  Bytes:= Decode64(S);
  MStream.SetSize(Length(Bytes));
  Move(Bytes[0], MStream.Memory^, Length(Bytes));
  SetLength(Bytes,0);
end;

Espero que sea de utilidad.

Saludos.

Muy interesante, nunca me he puesto a estudiar este tipo de algoritmos

Solo tengo una duda, porque en el procedimiento StreamDencode64 pasas el string por referencia (calificador var)

Yo soy bastante obsesivo con los parametros de los metodos y funciones; siempre que sea posible utilizo const, por cuestiones de cohesion y de eficiencia.

Muy interesante, nunca me he puesto a estudiar este tipo de algoritmos

 

Solo tengo una duda, porque en el procedimiento StreamDencode64 pasas el string por referencia (calificador var)

 

Yo soy bastante obsesivo con los parametros de los metodos y funciones; siempre que sea posible utilizo const, por cuestiones de cohesion y de eficiencia.

 Elegí el paso por referencia para evitar la copia previa que el compilador ha de hacer. Teniendo en cuenta que la función ni StreamDencode64 ni Dencode64 escriben en la cadena pasada, me pareció más interesante este tipo de paso.

Si bien veo que en la versión de la unit se declara así:

function Decode64(S: String): TAByte;

function Decode64(var S: String): TAByte;

Saludos.

Yo la verdad es que nunca me puse a estudiar este tema, voy a hacer unas preguntas muy tontas:

¿Cuándo, sobre que, y para que es conveniente codificar en Base64? He leído que se suele usar para "comprimir" imágenes, o también se la usa en MIME. Más o menos entiendo que lo que se hace es leer de a grupos de bits y generar una versión "textual" Pero... o es que no le capto la idea... ¿El objetivo es cifrar algo? Porque de serlo, no es lo mismo cifrar que codificar ¿que no?

Me llama la atención porque supuestamente es muy difundido su uso, y yo estoy en blanco.

Saludos,

Justamente por eso era mi duda

En Delphi el tipo string pertenece a los "managed types", es decir, el manejo de memoria es automático, implementado mediante reference counting, tal y como las interfaces y los record

Al pasar un string usando const se obtiene la máxima eficiencia ya que lo que se pasa es la referencia del string, y además el compilador no inserta la llamada a .AddRef y .DecRef entre el inicio y final del método

Para cifrar que yo sepa no sirve, es simplemente una codificación

 
Me alegra que hagas esta aclaración porque desconocía que pasar como constante un string significaba pasarlo también por referencia. Estoy acostumbrado a trabajar con C/C++. En C++ existe el paso por referencia, paso de una referencia a una constante, paso de un puntero constante o paso de un puntero a un valor constante, si bien en C (no C++) no existe el concepto referencia lo que significa que el paso por referencia se hace con punteros. Siempre pensé que en lo posible sería igual en delphi aunque con menos variabilidad. En C/C++ lo tienes que especificar y no de da por "entendido".
 
Delphius, como indica Agustin Ortu, se trata de una codificación a texto y no comprime, sino que expande. Tiene su uso en la codificación para la identificación en el protocolo SMTP y proxys, por ejemplo. También se usa para enviar imágenes por red en muchas ocasiones. En general su uso está orientado al envío de binarios en protocolos dirigidos a texto. El inconveniente es que expande los binarios en una relación de 3 a 4 (24 bits se expanden a 32).

Saludos.

 
Me alegra que hagas esta aclaración porque desconocía que pasar como constante un string significaba pasarlo también por referencia. Estoy acostumbrado a trabajar con C/C++. En C++ existe el paso por referencia, paso de una referencia a una constante, paso de un puntero constante o paso de un puntero a un valor constante, si bien en C (no C++) no existe el concepto referencia lo que significa que el paso por referencia se hace con punteros. Siempre pensé que en lo posible sería igual en delphi aunque con menos variabilidad. En C/C++ lo tienes que especificar y no de da por "entendido".

En las versiones mas nuevas se fue expandiendo mas este aspecto, en la docwiki hay mas info; por ejemplo se puede usar el atributo [Ref] para [forzar] pasar un parametro const por referencia

Esto es porque a veces el codigo producido por el compilador podria no ser el mas optimo, pero por otro lado (mencione mas arriba "cohesion") se quiere preservar la inmutabilidad  (solo lectura)

Como dije, yo soy obsesivo con este tema de los parametros, y siempre que sea posible utilizo const u out, ya que de alguna manera transmite cierta intencion (este parametro es de solo lectura, por eso es const; en este parametro tendrias que almacenar el resultado de Y, por eso es out)

-----

No estaba al tanto del detalle de el binario resultante del bas64 crecia, crei que al ser tan popular (sobre todo para mandar imagenes)

A nivel de performance en la codificacion/decodificacion como se comporta el algoritmo base64? Quizas los bytes de peso aumentados justifiquen que sea muy rapido

Saludos

Hola, éste es un tema excelente pero además lo que comenta Agustín es algo que suelo hacer cuando estoy creando mis clases, toda función o procedimiento que hag y que requiera de  enviar parámetros los asigno como const, normalmente no uso out a menos que tenga un procedimiento que necesite regresar un valor, o que una función requiera de mas de un valor de regreso, los var es muy raro que los utilice.

Lo dicho, éste es un tema muy bueno y aderezado con explicaciones excelentes y contundentes.

Saludo

Me gusta comprobar las cosas por mi mismo en lo posible, así que he hecho unas pruebas de código en delphi7 y viendo lo que pasa con los punteros y a nivel asm.
 
Primera prueba, paso por valor de un String:

procedure foo(S: String);
var
 S2: string;
begin
 S2:= S;
end;
 
var
S: String;
begin
  S:= '1';
  foo(S);
end.

El resultado es que el puntero de S cambia al entrar en foo, como era de esperar. La llamada a foo se realiza por valor así:

mov eax, [S]
call foo

Una vez en foo se realiza una copia de S con una llamada call @LStrAddRef y un borrado de la copia con call @LstrClr al final antes de la salida ret.


 
Segunda prueba, paso por referencia de un String:

procedure foo(var S: String);
var
 S2: string;
begin
 S2:= S;
end;
 
var
S: String;
 
begin
  S:= '1';
  foo(S);
end.

El resultado es que el puntero de S es el mismo al entrar en foo, como era de esperar, dado que el paso por referencia es el paso por puntero. La llamada a foo se realiza por referencia así:
 

mov eax, $00408294
call foo

Siendo $00408294 el valor del puntero @S.
Una vez en foo no se realiza copia alguna de S y sigue su ejecución hasta ret.

 
Tercera prueba, paso como constante de un String:
 

procedure foo(const S: String);
var
  S2: string;
begin
  S2:= S;
end;
 
var
  S: String;
 
begin
  S:= '1';
  foo(S);
end.

El resultado es que el puntero de S cambia al entrar en foo luego ¡no se pasa por referencia!. La llamada a foo se realiza por valor así:

mov eax, [S]
call foo

Una vez en foo se realiza ¡no se realiza copia alguna de S! careciendo de las llamadas call @LStrAddRef al inicio y call @LstrClr al final, antes de la salida ret.

Conclusiones:

1,- El paso del parámetro de un String como constante es un paso por valor en el que el compilador no realiza copia alguna del mismo, resultando casi un equivalente del paso por referencia, siendo más corto el clásico paso por referencia.

2.- El paso como constante, es por tanto más ortodoxo que el paso por referencia cuando no se pretende cambiar el valor del parámetro pasado.

3.- El paso por referencia resulta un poco más rápido en ciclos que el paso por constante de un String pudiendo ser despreciable en una sola llamada.

Saludos.
 

Aca va mi aporte en Delphi 2010
 
Primero el programa de consola que use para las pruebas, es basicamente las 3 funciones que comentó escafandra
 

uses
  SysUtils;
 
procedure Valor(S: string);
var
  S1: string;
begin
  S1 := S;
end;
 
procedure Referencia(var S: string);
var
  S2: string;
begin
  S2 := S;
end;
 
procedure Constante(const S: string);
var
  S3: string;
begin
  S3 := S;
end;
 
var
  S: string;
 
begin
  try
    S := '1';
    Valor(S);
    Referencia(S);
    Constante(S);
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
 
end.

Luego, este es el código asm generado:

Project1.dpr.33: S := '1';
004101AC B86C6E4100       mov eax,$00416e6c
004101B1 BA70024100       mov edx,$00410270
004101B6 E8F95EFFFF       call @UStrAsg
 
Project1.dpr.34: Valor(S);
004101BB A16C6E4100       mov eax,[$00416e6c]
004101C0 E827E2FFFF       call Valor
 
Project1.dpr.11: S1 := S;
0040E410 8D45F8           lea eax,[ebp-$08]
0040E413 8B55FC           mov edx,[ebp-$04]
0040E416 E8ED7CFFFF       call @UStrLAsg
 
Project1.dpr.35: Referencia(S);
004101C5 B86C6E4100       mov eax,$00416e6c
004101CA E875E2FFFF       call Referencia
 
Project1.dpr.18: S2 := S;
0040E45A 8D45FC           lea eax,[ebp-$04]
0040E45D 8B13             mov edx,[ebx]
0040E45F E8A47CFFFF       call @UStrLAsg
 
Project1.dpr.36: Constante(S);
004101CF A16C6E4100       mov eax,[$00416e6c]
004101D4 E8AFE2FFFF       call Constante 
 
Project1.dpr.25: S3 := S;
0040E49E 8D45FC           lea eax,[ebp-$04]
0040E4A1 8BD3             mov edx,ebx
0040E4A3 E8607CFFFF       call @UStrLAsg

Seria interesante ver la misma prueba en compiladores mas modernos

En el caso de las interfaces la cosa cambia
 
En esta ocasion este es el programa:
 

type
 ITest = interface
 ['{22000E45-F890-4293-8599-6651627718A6}']
   procedure Test;
 end;
 
TTest = class(TInterfacedObject, ITest)
  procedure Test;
end;
 
procedure Valor(T: ITest);
begin
  T.Test;
end;
 
procedure Referencia(var T: ITest);
(*) begin
  T.Test;
end;
 
procedure Constante(const T: ITest);
(*) begin
  T.Test;
end;
 
{ TTest }
procedure TTest.Test;
begin
  Writeln('Testing');
end;
 
var
  T: ITest;
begin
  T := TTest.Create;
  try
    Valor(T);
    Referencia(T);
    Constante(T);
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Ya a simple vista se puede apreciar el resultado; al compilar, no se permite colocar un punto de ruptura en donde marque con * en el codigo, justo en la palabra begin; en el caso del pasaje por valor si se puede
 
El codigo ASM: 
 

Project1.dpr.45: Valor(T);
004101CB A16C6E4100       mov eax,[$00416e6c]
004101D0 E8ABE5FFFF       call Valor
 
Valor(T)
0040E780 55               push ebp
0040E781 8BEC             mov ebp,esp
0040E783 51               push ecx
0040E784 8945FC           mov [ebp-$04],eax
0040E787 8B45FC           mov eax,[ebp-$04]
0040E78A E8C99BFFFF       call @IntfAddRef
0040E78F 33C0             xor eax,eax
0040E791 55               push ebp
0040E792 68BBE74000       push $0040e7bb
0040E797 64FF30           push dword ptr fs:[eax]
0040E79A 648920           mov fs:[eax],esp
Project1.dpr.19: T.Test;
0040E79D 8B45FC           mov eax,[ebp-$04]
0040E7A0 8B10             mov edx,[eax]
0040E7A2 FF520C           call dword ptr [edx+$0c]
 
Project1.dpr.46: Referencia(T);
004101D5 B86C6E4100       mov eax,$00416e6c
004101DA E8E9E5FFFF       call Referencia
 
Referencia(T)
0040E7C8 8B00             mov eax,[eax]
0040E7CA 8B10             mov edx,[eax]
0040E7CC FF520C           call dword ptr [edx+$0c]
 
Project1.dpr.47: Constante(T);
004101DF A16C6E4100       mov eax,[$00416e6c]
004101E4 E8E7E5FFFF       call Constante
 
Constante(T)
0040E7D0 8B10             mov edx,[eax]
0040E7D2 FF520C           call dword ptr [edx+$0c]

En este caso la diferencia entre el usar var/const contra valor si es notable; aunque entre var y const es bastante despreciable (similar al caso de los strings)
 
Esta respuesta de SO arroja algo de luz (enlace)
 
Tiene sentido que en el anterior caso de los string el const no implicaba mucho en la performance porque estabamos asignando en otra variable string. Por lo tanto si se estaba produciendo el "try-finally" oculto para incrementar/decrementar el contador de referencias