function h = deltatime(t, hex)
   // Esta función obtiene el delta time utilizado en
   // archivos MIDI a partir de su representación 
   // hexadecimal de longitud variable, o recíprocamente. 
   // Es útil para crear y/o interpretar archivos  MIDI
   // estándar.   
   //
   // Usos:
   //
   //        h = deltatime(t, hex)
   //        t = deltatime(h, hex)
   //
   // Donde:
   //        h:   Cadena que representa uno o más bytes
   //             en hexadecimal o un vector numérico de
   //             1 a 4 componentes que contiene los 
   //             valores de los bytes correspondientes
   //        t:   Cifra que representa un delta time
   //             expresado en ticks
   //        hex: Modo de representación de los bytes
   //             1: Como cadena hexadecimal (valor por
   //                defecto)
   //             0: Como número entre 0 y 255
   //
   // h debe ser una cadena de caracteres que representan
   // números hexadecimales correspondientes a un delta
   // time en formato de longitud variable. Los bytes más
   // significativos deben empezar con 1 y el menos
   // significativo con 0; en caso contrario se  produce
   // un error. Si se elige hex = 0 debe ser un vector de
   // 1 a 4 componentes, de las cuales excepto la última,
   // que debe estar entre 0 y 127, las restantes deben 
   // estar entre 128 y 255.  A su vez t debe ser un número
   // entero mayor o igual a cero. Típicamente representa
   // la cantidad de ticks (mínima duración posible en un
   // archivo MIDI.
   //
   // La función decide inteligentemente si es directa o
   // inversa dependiendo del tipo de entrada (número
   // entero o cadena de caracteres).
   //
   // -------------------------
   // Autor: Federico Miyara
   // 2008-12-11
   // 2012-12-12
   // 2024-09-12

   if argn(2)<2
      hex = 1;
   end


   if type(t)==1 & length(t)==1
      // El argumento es un número escalar
      // Si el argumento es un tiempo (expresado en
      // ticks) se obtiene su representaci�n en base
      // 128 y a los "dígitos" más significativos se
      // les suma 128, lo que equivale a expresarlos
      // con 8 bits, siendo el más significativo un 1.
      // El "dígito" menos significativo no se modifica.
      // Luego se expresa en forma hexadecimal, cuidando
      // de completar dos dígitos hexadecimales aun en
      // los casos en que un "dígito" es 0, o sea menor
      // de 16.
      i = 0;
      tt = t;
      h = [];
      while tt~=0
         i = i + 1;
         // Se obtiene el resto de dividir por 128
         n(i) = modulo(tt, 128);
         // Se obtiene el cociente entero
         tt = floor(tt/128);
         if i>1
            // Si no es el byte menos significativo 
            // se agrega un bit más significativo
            n(i) = n(i) + 128;
            if hex==1
               // Se convierte en hexadecimal y se
               // yuxtapone a lo anterior
               h = [dec2hex(n(i)), h];
            else
               // Se antepone como nueva componente
               // a lo anterior
               h = [n(i), h];
            end
         else
            // Si es el byte menos significativo
            if hex==1
               if n(i)==0
                  // El resto del cociente por 128
                  // es 0
                  h = "00";
               elseif n(i)<16
                  // El resto del cociente por 128 es
                  // menor que 16, luego el número 
                  //hexadecimal tiene un solo dígito y
                  // debe completarse anteponiéndole 
                  // un 0
                  h = "0" + dec2hex(n(i));
               else
                  // El resto del cociente por 128 es
                  // mayor o igual que 16, por lo tanto
                  // espontáneamente tiene dos dígitos
                  // hexadecimales
                  h = dec2hex(n(i));
               end
            else
               h = n(i);
            end
         end
      end
      
      // Si el resultado se debe expresar como 
      // hexadecimal, concatenar los dígitos
      // hexadecimales
      if hex==1
         h = strcat(h);
      end
      
      // En caso de ser t=0 el proceso anterior da una
      // cadena o una matriz vacía. Lo que sigue arregla
      // este problema.
      if t==0
         if hex==1
            h = "00";
         else
            h = 0;
         end
      end

   elseif type(t)==1 & length(t)>1
      // El argumento es un vector numérico de 2 a 4
      // componentes
      L = length(t);
      h = t(L);
      for i = 1:L-1
         h = h + (t(L-i) - 128)*128^i;
      end

   else
      // El argumento es una cadena de caracteres
      // Si el argumento es un delta time de longitud
      // variable expresado en sistema hexadecimal, a
      // cada par de dígitos hexadecimales excepto al
      // menos significativo se les resta 128, lo que
      // equivale a eliminar el bit más significativo.
      // Lo así obtenido se interpreta como numeración
      // en base 128 (7 bits) y se convierte a decimal.
      L = length(t);
      if L==1
         t = ["0",t];
         L = 2;
      end

      h = hex2dec(part(t, [L-1,L]));
      
      for i = 1:ceil(L/2)-1
         h = h + (hex2dec(part(t, [L-2*i-1,L-2*i])) - 128)*128^i;
      end
   end
   
endfunction
