cursos:ensamblador:compresion_rle

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anterior Revisión previa
Próxima revisión		 Revisión previa
cursos:ensamblador:compresion_rle [18-01-2024 10:00] – [Rutina optimizada por Z80user] sromerocursos:ensamblador:compresion_rle [19-01-2024 12:35] (actual) – [Programa de ejemplo de descompresión] sromero
Línea 345: Línea 345:
 RLE_decompress: RLE_decompress:
  
-RLE_dec_loop: +rle_dec_loop: 
-    LD A, (HL)                     ; leemos un byte+    ld a, (hl)                     ; leemos un byte
  
-    CP 192 +    cp 192 
-    JP NC, RLE_dec_compressed     ; si byte > 192 = está comprimido +    jp nc, rle_dec_compressed     ; si byte > 192 = está comprimido 
-    LD (DE), A                    ; si no está comprimido, escribirlo +    ld (de), a                    ; si no está comprimido, escribirlo 
-    INC DE +    inc de 
-    INC HL +    inc hl 
-    DEC BC+    dec bc
  
-RLE_dec_loop2: +rle_dec_loop2: 
-    LD A, B +    ld a, b 
-    OR C +    or c 
-    JR NZ, RLE_dec_loop +    jr nz, rle_dec_loop 
-    RET                           ; miramos si hemos acabado+    ret                           ; miramos si hemos acabado
  
-RLE_dec_compressed:               ; bucle para descompresión +rle_dec_compressed:               ; bucle para descompresión 
-    PUSH BC +    push bc 
-    AND 63                        ; cogemos el numero de repeticiones +    and %00111111                 ; cogemos el numero de repeticiones 
-    LD B, A                       ; lo salvamos en B +    ld b, a                       ; lo salvamos en B 
-    INC HL                        ; y leemos otro byte (dato a repetir) +    inc hl                        ; y leemos otro byte (dato a repetir) 
-    LD A, (HL)+    ld a, (hl)
  
-RLE_dec_loop3: +rle_dec_loop3: 
-    LD (DE), A                    ; bucle de escritura del dato B veces +    ld (de), a                    ; bucle de escritura del dato B veces 
-    INC DE +    inc de 
-    DJNZ RLE_dec_loop3 +    djnz rle_dec_loop3 
-    INC HL +    inc hl 
-    POP BC                        ; recuperamos BC +    pop bc                        ; recuperamos BC 
-    DEC BC                        ; Este DEC BC puede hacer BC=0 si los datos+    dec bc                        ; Este dec bc puede hacer BC=0 si los datos
                                   ; RLE no son correctos. Cuidado (mem-smashing).                                   ; RLE no son correctos. Cuidado (mem-smashing).
-    DEC BC +    dec bc 
-    JR RLE_dec_loop2 +    jr rle_dec_loop2 
-    RET+    ret
 </code> </code>
  
Línea 567: Línea 567:
  
 \\  \\ 
-  * **Método INCBIN**: Incluyendo el binario directamente en Pasmo con la directiva ''INCBIN'' asociándole una etiqueta para poder hacer referencia a él:\\ <code>+  * **Método INCBIN**: Incluyendo el binario directamente en Pasmo con la directiva ''INCBIN'' asociándole una etiqueta para poder hacer referencia a él:\\ \\ <code>
 Datos_Comprimidos: Datos_Comprimidos:
    INCBIN "fichero.rle"    INCBIN "fichero.rle"
Línea 573: Línea 573:
 \\  \\ 
  
-  * **Método BIN2CODE**: Convirtiendo los datos binarios a "texto" con una utilidad como BIN2C o BIN2CODE (las tenéis disponibles como descargas en la sección de ficheros). Estas utilidades para PC (Linux, MAC, DOS/Windows) toman un fichero binario y lo convierten a datos listos para incluir en nuestros programas:\\ <code>+  * **Método BIN2CODE**: Convirtiendo los datos binarios a "texto" con una utilidad como BIN2C o BIN2CODE (las tenéis disponibles como descargas en la sección de ficheros). Estas utilidades para PC (Linux, MAC, DOS/Windows) toman un fichero binario y lo convierten a datos listos para incluir en nuestros programas:\\ \\ <code>
 [sromero@compiler:~rlezx]$ bin2code sokoban.rle datos.asm a [sromero@compiler:~rlezx]$ bin2code sokoban.rle datos.asm a
 BIN2CODE v1.0             By NoP of Compiler SoftWare BIN2CODE v1.0             By NoP of Compiler SoftWare
Línea 581: Línea 581:
  
 [sromero@compiler:~rlezx]$ cat datos.asm [sromero@compiler:~rlezx]$ cat datos.asm
-;  File created with  BIN2CODE  v1.0  by  NOP of Compiler SoftWare+;  File created with  BIN2CODE  v1.0  by  nop of Compiler SoftWare
  
 BINDATASIZE   EQU   2571 BINDATASIZE   EQU   2571
Línea 611: Línea 611:
  
     ; Cargamos los datos y preparamos nuestra rutina     ; Cargamos los datos y preparamos nuestra rutina
-    LD HL, Pantalla_Comprimida +    ld hl, Pantalla_Comprimida 
-    LD DE, 16384 +    ld de, 16384 
-    LD BC, 2571 +    ld bc, 2571 
-    CALL RLE_decompress+    call RLE_decompress
  
 Wait_For_Keys_Pressed:         ; Bucle para esperar pulsación de tecla Wait_For_Keys_Pressed:         ; Bucle para esperar pulsación de tecla
-    XOR A +    xor a 
-    IN A, (254) +    in a, ($fe) 
-    OR 224 +    or %11100000 
-    INC A +    inc a 
-    JR Z, Wait_For_Keys_Pressed +    jr z, Wait_For_Keys_Pressed 
-    RET                          ; Fin del programa+    ret                          ; Fin del programa
  
-;; +; Aquí incluiremos el código de la rutina RLE_decompress 
-;; RLE_decompress +;; --- RLE_decompress ---
-;; Descomprime un bloque de datos RLE de memoria a memoria. +
-;; +
-;; Entrada a la rutina: +
-;; +
-;; HL = dirección origen de los datos RLE. +
-;; DE = destino donde descomprimir los datos. +
-;; BC = tamaño de los datos comprimidos. +
-;; +
-RLE_decompress: +
- +
-RLE_dec_loop: +
-    LD A, (HL)                         ; leemos un byte +
- +
-    CP 192 +
-    JP NC, RLE_dec_compressed          ; si byte > 192 = está comprimido +
-    LD (DE), A                         ; si no está comprimido, escribirlo +
-    INC DE +
-    INC HL +
-    DEC BC +
- +
-RLE_dec_loop2: +
-    LD A, B +
-    OR C +
-    JR NZ, RLE_dec_loop +
-    RET                                 ; miramos si hemos acabado +
- +
-RLE_dec_compressed:                    ; bucle para descompresión +
-    PUSH BC +
-    AND 63                              ; cogemos el numero de repeticiones +
-    LD B, A                             ; lo salvamos en B +
-    INC HL                              ; y leemos otro byte (dato a repetir) +
-    LD A, (HL) +
- +
-RLE_dec_loop3: +
-    LD (DE), A                          ; bucle de escritura del dato B veces +
-    INC DE +
-    DJNZ RLE_dec_loop3 +
-    INC HL +
-    POP BC                              ; recuperamos BC +
-    DEC BC                              ; Este DEC BC puede hacer BC=0 si los datos +
-                                        ; RLE no correctos. Cuidado (mem-smashing). +
-    DEC BC +
-    JR RLE_dec_loop2 +
-    RET+
  
 ; Aquí viene nuestra pantalla comprimida con RLE. ; Aquí viene nuestra pantalla comprimida con RLE.
 ; Hay que darse cuenta de que está fuera de todo ; Hay que darse cuenta de que está fuera de todo
-; código ejecutable, es decir, el RET de la rutina +; código ejecutable, es decir, el ret de la rutina 
-; principal y el RET de las subrutina de RLE_Decompress+; principal y el ret de las subrutina de RLE_Decompress
 ; hacen que nunca se llegue a este punto para ejecución. ; hacen que nunca se llegue a este punto para ejecución.
  
Línea 695: Línea 651:
  
 \\  \\ 
-//He leído el articulo del RLE,  he reescrito el codigo de la rutina descompresora y he creado la rutina compresora. He realizado la compresion de la ROM de 48K,  y posterior descompresión y salen identicas. He utilizado un pequeño truquito con el ''LDI'' y el ''RET PO'' (un flash no muy usado,  pero que usa ''LDI'' para indicar BC=#0000) y me he ahorrado algunos bytes (compresora 62 bytes,  descompresora 26 bytes).//+//He leído el articulo del RLE,  he reescrito el codigo de la rutina descompresora y he creado la rutina compresora. He realizado la compresion de la ROM de 48K,  y posterior descompresión y salen identicas. He utilizado un pequeño truquito con el ''LDI'' y el ''ret pO'' (un flash no muy usado,  pero que usa ''LDI'' para indicar BC=#0000) y me he ahorrado algunos bytes (compresora 62 bytes,  descompresora 26 bytes).//
 \\  \\ 
  
Línea 725: Línea 681:
 RLE_descompress: RLE_descompress:
 rle_dec_loop: rle_dec_loop:
-          LD A, (HL)                     ; Leemos 1 byte +          ld a, (hl)                     ; Leemos 1 byte 
-          CP A, 192 +          cp a, 192 
-          JR NC, rle_dec                 ; si byte > 192 = está comprimido+          jr nc, rle_dec                 ; si byte > 192 = está comprimido
 rle_test_end: rle_test_end:
-          LDI                            ; Copiamos 1 byte en crudo +          ldi                            ; Copiamos 1 byte en crudo 
-          RET PO                         ; Volvemos si hemos terminado +          ret pO                         ; Volvemos si hemos terminado 
-          JR rle_dec_loop                ; Repetimos el bucle+          jr rle_dec_loop                ; Repetimos el bucle
 rle_dec:                                 ; bucle para descompresión RLE rle_dec:                                 ; bucle para descompresión RLE
-          INC HL                         ; Nos colocamos en el valor +          inc hl                         ; Nos colocamos en el valor 
-          AND A, #3F +          and a, $3f 
-          JR Z, rle_test_end             ; Si 192,  es dato en crudo +          jr z, rle_test_end             ; Si 192,  es dato en crudo 
-          PUSH BC +          push bc 
-          LD B, A                        ; B= numero de repeticiones +          ld b, a                        ; B= numero de repeticiones 
-          LD A, (HL)+          ld a, (hl)
 rle_bucle: rle_bucle:
-          LD (DE), A                     ; \ +          ld (de), a                     ; \ 
-          INC DE                         ;  Bucle de escritura B veces +          inc de                         ;  Bucle de escritura B veces 
-          DJNZ rle_bucle                 ; / +          djnz rle_bucle                 ; / 
-          POP BC +          pop bc 
-          DEC BC                         ; Ajustamos el contador al usar RLE +          dec bc                         ; Ajustamos el contador al usar RLE 
-          JR rle_test_end                ; Copiamos 1 byte mas+          jr rle_test_end                ; Copiamos 1 byte mas
  
  
Línea 751: Línea 707:
 RLE_Comprimir: RLE_Comprimir:
 rle_byte_1: rle_byte_1:
-          LD E, (IX+#00)                 ; leer byte +          ld e, (ix+$00)                 ; leer byte 
-          INC IX                         ; incrementar posicion +          inc ix                         ; incrementar posicion 
-          DEC BC                         ; descontar contador +          dec bc                         ; descontar contador 
-          LD A, E+          ld a, e
 rle_byte_2: rle_byte_2:
-          CP A, #C0                      ; Si es un codigo RLE +          cp a, #C0                      ; Si es un codigo RLE 
-          JR NC, rle_compress            ;  tratar como RLE +          jr nc, rle_compress            ;  tratar como RLE 
-          CALL rle_get_byte              ; tomar el 2º byte +          call rle_get_byte              ; tomar el 2º byte 
-          JR Z, rle_ultimo_byte          ; falta escribir el ultimo byte +          jr z, rle_ultimo_byte          ; falta escribir el ultimo byte 
-          CP A, E +          cp a, E 
-          JR Z, rle_compress2            ; usar compresion RLE si son identicos +          jr z, rle_compress2            ; usar compresion RLE si son identicos 
-          LD (HL), E                     ; son distintos,  escribir el byte anterior +          ld (hl), e                     ; son distintos,  escribir el byte anterior 
-          INC HL +          inc hl 
-          LD E, A                        ; recuperar el ultimo byte leido +          ld e, a                        ; recuperar el ultimo byte leido 
-          JR byte_2                      ; continuar con la compresion+          jr byte_2                      ; continuar con la compresion
 rle_ultimo_byte: rle_ultimo_byte:
-          LD (HL), E                     ; escribir el ultimo byte +          ld (hl), e                     ; escribir el ultimo byte 
-          INC HL +          inc hl 
-          RET                            ; salir+          ret                            ; salir
 rle_compress2: rle_compress2:
-          LD D, #C1                      ; eran identicos,  empezar,  con 2 +          ld d, $c1                      ; eran identicos,  empezar,  con 2 
-          JR rle_repetido+          jr rle_repetido
 rle_compress: rle_compress:
-          LD D, #C0                      ; era un valor RLE original+          ld d, $c0                      ; era un valor RLE original
 rle_repetido: rle_repetido:
-          CALL get_byte                  ; Obtener otro byte +          call get_byte                  ; Obtener otro byte 
-          JR Z, rle_distinto             ; Escribir el valor RLE si no hya mas bytes +          jr z, rle_distinto             ; Escribir el valor RLE si no hya mas bytes 
-          CP A, E                        ; Comprobar si es identico +          cp a, E                        ; Comprobar si es identico 
-          JR NZ, rle_distinto            ; Se encontro un byte distinto +          jr nz, rle_distinto            ; Se encontro un byte distinto 
-          INC D                          ; incrementar el contador de repeticiones +          inc d                          ; incrementar el contador de repeticiones 
-          JR NZ, rle_repetido            ; Otro byte identico +          jr nz, rle_repetido            ; Otro byte identico 
-          DEC D                          ; Se acabo el contador de repeticiones+          dec d                          ; Se acabo el contador de repeticiones
 rle_distinto: rle_distinto:
-          LD (HL), D                     ; \ +          ld (hl), d                     ; \ 
-          INC L                          ;  \ +          inc l                          ;  \ 
 rle_byte_simple:                         ;   / escribir valor RLE rle_byte_simple:                         ;   / escribir valor RLE
-          LD (HL), E                     ;  / +          ld (hl), e                     ;  / 
-          INC HL                         ; / +          inc hl                         ; / 
-          LD E, A                        ; Recuperar el ultimo byte distinto +          ld e, a                        ; Recuperar el ultimo byte distinto 
-          JR rle_byte_2                      ; seguir comprimiendo+          jr rle_byte_2                      ; seguir comprimiendo
 rle_get_byte: rle_get_byte:
-          LD A, B                        ; \ +          ld a, b                        ; \ 
-          OR A, C                        ;  Comprobar si es el ultimo byte +          or a, C                        ;  Comprobar si es el ultimo byte 
-          RET Z                          ; / +          ret z                          ; / 
-          DEC BC                         ; descontar contador +          dec bc                         ; descontar contador 
-          LD A, (IX+#00)                 ; leer byte +          ld a, (ix+$00)                 ; leer byte 
-          INC IX                         ; incrementar posicion +          inc ix                         ; incrementar posicion 
-          RET+          ret
 </code> </code>
  
Línea 849: Línea 805:
  
 <code z80> <code z80>
-    LD    HL, scr_datos_zx0    ; origen = datos comprimidos +    ld    hl, scr_datos_zx0    ; origen = datos comprimidos 
-    LD    DE, 16384            ; destino = pantalla +    ld    de, 16384            ; destino = pantalla 
-    CALL  decompress_zx0+    call  decompress_zx0
 </code> </code>
  
Línea 868: Línea 824:
     ORG 33500     ORG 33500
  
-    LD HL, pantalla_comprimida   ; datos comprimidos +    ld hl, pantalla_comprimida   ; datos comprimidos 
-    LD DE, 16384                 ; destino compresion +    ld de, 16384                 ; destino compresion 
-    CALL dzx0_standard           ; descomprimir+    call dzx0_standard           ; descomprimir
  
 loop: loop:
-    JR loop                      ; bucle para no volver a BASIC+    jr loop                      ; bucle para no volver a BASIC
  
     INCLUDE "dzx0_standard.asm"     INCLUDE "dzx0_standard.asm"
Línea 932: Línea 888:
 \\  \\ 
 **[ [[.:indice|⬉]] | [[.:gfx5_mapeados|⬅]] | [[.:avanzadas1|➡]] ]** **[ [[.:indice|⬉]] | [[.:gfx5_mapeados|⬅]] | [[.:avanzadas1|➡]] ]**
 +
  • cursos/ensamblador/compresion_rle.1705572057.txt.gz
  • Última modificación: 18-01-2024 10:00
  • por sromero