FORUM.RYAN.COM.BR

Citação de: jmaraujo em Outubro 09, 2009, 07:06:05 pm

Espero que sirva de ajuda.

Mas é claro!! Foi uma ajuda e tanto (uma descoberta). Obrigado!

Concordo. Eu estava há muito tempo querendo saber como se chegava a esse offset da EEPROM na Shared Memory.

Na verdade, todo o trabalho inicial de ler a EEPROM, mesclar com valor do alinhamento e repassar ao ARM poderia ser evitado se eu soubesse exatamente como ler um endereço de EEPROM diretamente no ARM.

Claro, era a parte que achei mais complicada. Por isso tinha sugerido escrever direto na eeprom.

Você sabe como calcular esse endereço? Não precisamos mudar isso agora, pois não trará diferenças para o usuário, mas seria interessante descobrir para outras mudanças futuras.

Sei sim; foi um método que descobri por acaso, he-he!

Aquela parte no começo do patch das legendas fui eu que mudei; se olhar o documento do patch do "Load org. then all" do Hej456 (ou mesmo o da sincronia do audio) você vai ver que ele usa endereços da Shared Memory. Mas eu estava tendo problemas para achar endereços de shared memory livres. Cada vez que eu tentava fazer um memory dump com o meu cabo USB o meu computador travava e eu tinha que fazer um reset. Ficava impossível.

Daí peguei a ideia de um post do grupo MT13x9 do Y! e sem muitas esperanças tentei escrever direto na EEPROM, e para a minha surpresa... deu certo!

Você tem de calcular deste jeito:
Shared Memory + Offset + Endereço EEPROM a usar

No meu player fica assim:
0376CC00 + 19E3 + EEPROM

No caso do carregamento das legendas, a EEPROM usada é a 53:
0376CC00 + 19E3 + 53 = 0376E636, daí que usei R3, =unk_376E636

O offset é achado na rotina PREF_GetChar (bEepromReadByte). No meu player o offset 0x19E3 esta ali:

ROM:E0AE             ; ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ S U B R O U T I N E ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
ROM:E0AE
ROM:E0AE             ; PREF_GetChar
ROM:E0AE
ROM:E0AE             bEepromReadByte:
ROM:E0AE CD                    xch   A, R5                   ; Read Shared memory
ROM:E0AF EF                    mov   A, R7
ROM:E0B0 CD                    xch   A, R5
ROM:E0B1 CC                    xch   A, R4
ROM:E0B2 EE                    mov   A, R6
ROM:E0B3 CC                    xch   A, R4
ROM:E0B4 BC FF 06              cjne  R4, #0xFF, ROM_E0BD
ROM:E0B4
ROM:E0B7 BD FF 03              cjne  R5, #0xFF, ROM_E0BD
ROM:E0B7
ROM:E0BA 7F 00                 mov   R7, #0
ROM:E0BC 22                    ret
ROM:E0BC
ROM:E0BD             ; ---------------------------------------------------------------------------
ROM:E0BD
ROM:E0BD             ROM_E0BD:
ROM:E0BD C3                    clr   C
ROM:E0BE ED                    mov   A, R5
ROM:E0BF 94 CC                 subb  A, #0xCC ; '¦'
ROM:E0C1 EC                    mov   A, R4
ROM:E0C2 94 00                 subb  A, #0
ROM:E0C4 40 09                 jc    ROM_E0CF
ROM:E0C4
ROM:E0C6 90 FC 03              mov   DPTR, #0xFC03
ROM:E0C9 74 24                 mov   A, #0x24 ; '$'
ROM:E0CB F0                    movx  @DPTR, A
ROM:E0CC 7F 00                 mov   R7, #0
ROM:E0CE 22                    ret
ROM:E0CE
ROM:E0CF             ; ---------------------------------------------------------------------------
ROM:E0CF
ROM:E0CF             ROM_E0CF:
ROM:E0CF ED                    mov   A, R5
ROM:E0D0 24 E3                 add   A, #0xE3 ; 'Ò'
ROM:E0D2 FF                    mov   R7, A
ROM:E0D3 EC                    mov   A, R4
ROM:E0D4 34 19                 addc  A, #0x19
ROM:E0D6 FE                    mov   R6, A
ROM:E0D7 12 04 7B              lcall bReadSInfo              ; Arm_GetChar
ROM:E0D7
ROM:E0DA 22                    ret
ROM:E0DA
ROM:E0DA             ; End of function bEepromReadByte

Espero que sirva de ajuda.

Ate agora está perfeito, Rictad.   Não achei nenhum bug ou comportamento extranho.

Pronto! O problema era o mesmo que acontecia no LG DV39H. A rotina que calcula a largura da linha (SUB_CalcTextLineWidth), que faz parte da rotina responsável pelo alinhamento horizontal (centraliza), também faz uma varredura pelos caracteres do quadro de legenda (pois precisa calcular a largura da linha levando em consideração a largura dos caracteres em itálico, senão o alinhamento fica deslocado). Quando isso é feito, o itálico é acionado ou desativado conforme as tags são encontradas. Se uma tag </i> era encontrada ao final de uma linha quebrada, a rotina deixava o itálico desativado. Quando a rotina que exibe a legenda (Display_subtitle) fosse exibir a linha, exibia sem itálico, pois a tag <i> fica na linha anterior (antes da quebra), que já foi processada. Assim, foi só incluir uma rotina para fazer uma cópia do estado do itálico, que deve ser chamada no início da SUB_CalcTextLineWidth, e uma outra para restaurar o estado ao sair da SUB_CalcTextLineWidth. Dessa forma, o estado do itálico deixou de ser alterado quando se calcula a largura da linha.

Novas rotinas:

ROM:00075662     Copia estado do itálico de 7A380 + 9 para 7A380 + #F
ROM:00075662 10 4B                       LDR     R3, =unk_7A380
ROM:00075664 5A 7A                       LDRB    R2, [R3,#9]
ROM:00075666 DA 73                       STRB    R2, [R3,#0xF]
ROM:00075668 07 1C                       ADDS    R7, R0, #0          ; esse trecho restante é o que estava na
ROM:0007566A 00 25                       MOVS    R5, #0              ; rotina SUB_CalcTextLineWidth e foi substituído pelo BL
ROM:0007566C 70 47                       BX      LR
ROM:00075696        Restaura estado do itálico de 7A380 + #F para 7A380 + 9
ROM:00075696 03 4B                       LDR     R3, =unk_7A380
ROM:00075698 DA 7B                       LDRB    R2, [R3,#0xF]
ROM:0007569A 5A 72                       STRB    R2, [R3,#9]
ROM:0007569C 28 1C                       ADDS    R0, R5, #0       ; esse trecho restante é o que estava na
ROM:0007569E FC BC                       POP     {R2-R7}          ; rotina SUB_CalcTextLineWidth e foi substituído pelo BL
ROM:000756A0 70 47                       BX      LR
Nova posição da palavra que define o endereço das opções da legenda (as novas rotinas precisaram de espaço):

ROM:000756A4 80 A3 07 00 off_756A4       DCD unk_7A380

Como a posição da palavra mudou, as instruções que dependem de sua posição tiveram que ser corrigidas:

ROM:000755F0 2C 4A                 LDR     R2, =unk_7A380
................
................
ROM:00075686 07 4A                 LDR     R2, =unk_7A380

Pontos alterados na SUB_CalcTextLineWidth para chamar as novas rotinas:

ROM:0000E38C FC B5                 PUSH    {R2-R7,LR}
ROM:0000E38E 67 F0 68 F9           BL      sub_75662
ROM:0000E392 3C 48                 LDR     R0, =unk_7A00C
...........................
...........................
...........................
ROM:0000E434 B2 D3                 BCC     loc_E39C
ROM:0000E436
ROM:0000E436          loc_E436              ; CODE XREF: sub_E38C+1E_j
ROM:0000E436                                ; sub_E38C+32_j
ROM:0000E436 67 F0 2E F9           BL      sub_75696
ROM:0000E43A 08 BC                 POP     {R3}

Eu fiz a cópia do estado do itálico no endereço 7A380 + #F do mesmo modo que no LG DV397H. Na rotina SUB_ClearMpeg4SubtitleParams vemos que os endereços de 7A38C a 7A38F são zerados:

ROM:0000E328             sub_E328                                ; CODE XREF: sub_9992+1A_p
ROM:0000E328 5C 48                       LDR     R0, =unk_7A380
ROM:0000E32A FF 21                       MOVS    R1, #0xFF
ROM:0000E32C 01 72                       STRB    R1, [R0,#8]
ROM:0000E32E 00 22                       MOVS    R2, #0
ROM:0000E330 C2 60                       STR     R2, [R0,#0xC]
ROM:0000E332 02 80                       STRH    R2, [R0]
Em #E32E, R2 é zerado e todo seu conteúdo, ou seja, a palavra 00 00 00 00, é colocado a partir de 7A380 + #C (STR guarda a palavra e STRB guarda somente 1 byte). E na rotina SUB_FillMpeg4SubtitleParamsRecord vemos que esses endereços não são utilizados.

ROM:0000E350             sub_E350                                ; CODE XREF: sub_AA2A+47_p
ROM:0000E350 02 78                       LDRB    R2, [R0]
ROM:0000E352 52 49                       LDR     R1, =unk_7A380
ROM:0000E354 0A 72                       STRB    R2, [R1,#8]
ROM:0000E356 83 78                       LDRB    R3, [R0,#2]
ROM:0000E358 42 78                       LDRB    R2, [R0,#1]
ROM:0000E35A 1B 02                       LSLS    R3, R3, #8
ROM:0000E35C 1A 43                       ORRS    R2, R3
ROM:0000E35E 0A 80                       STRH    R2, [R1]
ROM:0000E360 03 79                       LDRB    R3, [R0,#4]
ROM:0000E362 C2 78                       LDRB    R2, [R0,#3]
ROM:0000E364 1B 02                       LSLS    R3, R3, #8
ROM:0000E366 1A 43                       ORRS    R2, R3
ROM:0000E368 4A 80                       STRH    R2, [R1,#2]
ROM:0000E36A 83 79                       LDRB    R3, [R0,#6]
ROM:0000E36C 42 79                       LDRB    R2, [R0,#5]
ROM:0000E36E 1B 02                       LSLS    R3, R3, #8
ROM:0000E370 1A 43                       ORRS    R2, R3
ROM:0000E372 8A 80                       STRH    R2, [R1,#4]
ROM:0000E374 03 7A                       LDRB    R3, [R0,#8]
ROM:0000E376 C2 79                       LDRB    R2, [R0,#7]
ROM:0000E378 1B 02                       LSLS    R3, R3, #8
ROM:0000E37A 1A 43                       ORRS    R2, R3
ROM:0000E37C CA 80                       STRH    R2, [R1,#6]
ROM:0000E37E 42 7A                       LDRB    R2, [R0,#9]
ROM:0000E380 4A 72                       STRB    R2, [R1,#9]
ROM:0000E382 82 7A                       LDRB    R2, [R0,#0xA]
ROM:0000E384 8A 72                       STRB    R2, [R1,#0xA]
ROM:0000E386 C0 7A                       LDRB    R0, [R0,#0xB]
ROM:0000E388 C8 72                       STRB    R0, [R1,#0xB]
ROM:0000E38A 70 47                       BX      LR
Assim, achei seguro usar 7A380 + #F.

Jmaraujo, vou enviar essas modificações na versão 1.5beta2 para você testar. Acho que agora sim, é só fazer as fontes.

Fiz um video pra mostrar o funcionamento do firmware v1.5.

Subtítulos en firmware jmaraujo 1.5

Somente notei um probleminha bem menor por culpa da quebra de linhas. Quando a quebra de linhas é feita perde-se o itálico da última linha. Por exemplo se o texto for:
<i>Exemplo de uma legenda comprida com
quebra de linha automática.</i>
Em vez de aparecer assim:
Exemplo de uma legenda comprida
com quebra de linha automática.

Fica assim:
Exemplo de uma legenda comprida
com quebra de linha automática.

Mas, como eu disse, é um probleminha bem menor e sem importância...

Jmaraujo,

Consegui fazer o itálico funcionar junto com as opções de alinhamento e consegui fazer com que as opções se tornem dinâmicas!


Vamos às modificações:

Em primeiro lugar, as opções de alinhamento vertical e horizontal no firmware 1.4 estão trocadas (verifica isso lá) e bugando a legenda. Troquei os endereços no menu e tudo ficou certo.

Em segundo lugar, não sei o porquê, os valores para o alinhamento vertical, 00 e 01, não deixavam o itálico funcionar, mesmo que eu usasse o endereços do alinhamento horizontal emprestado para o itálico (não o vertical ). Tive que alterar para os padrões dos firmwares mediatek, que são 08 e 09. Veja como ficou os menus dos alinhamentos. Tudo que está em vermelho foi alterado:

4. No Pic. | Horizontal alignment | Set the horizontal alignment
   0008 FFFF 056D 058D 0063 0000 0002 0001 FFF9A7 0000 - ROM:F935
     1. Left | Left | [00]
     0578 0578 0561 00 - ROM:F992
  => 2. Center | Center | [00]
     0579 0579 0561 01 - ROM:F999
     3. Right | Right | [00]
     057A 057A 0561 02 - ROM:F9A0

5. No Pic. | Vertical alignment | Set the vertical alignment
   0008 FFFF 056C 058E 0062 0000 0009 0001 FFF989 0000 - ROM:F920
     1. Top | Top | [00]
     0590 0590 0561 08 - ROM:F974
  => 2. Bottom | Bottom | [00]
     058F 058F 0561 09 - ROM:F97B

Aí o itálico passou a funcionar.

Agora, vamos ao alinhamento dinâmico. Eu vi que você usou a seguinte rotina para interceptar os valores do alinhamento:

B1:FF54             ; aplica alinhamentos legenda
B1:FF54
B1:FF54             B1_FF54:                                ; CODE XREF: B1_EE21+25_p
B1:FF54 7F 57                       mov     R7, #0x57 ; 'W'
B1:FF56 7E 00                       mov     R6, #0
B1:FF58 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF5B 74 28                       mov     A, #0x28 ; '('
B1:FF5D C3                          clr     C
B1:FF5E 9F                          subb    A, R7
B1:FF5F 90 FB F0                    mov     DPTR, #XRAM_FBF0
B1:FF62 F0                          movx    @DPTR, A
B1:FF63 C3                          clr     C
B1:FF64 24 82                       add     A, #0x82 ; 'é'
B1:FF66 90 FB F8                    mov     DPTR, #XRAM_FBF8
B1:FF69 F0                          movx    @DPTR, A
B1:FF6A 7F 62                       mov     R7, #0x62 ; 'b'
B1:FF6C 7E 00                       mov     R6, #0
B1:FF6E 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF71 EF                          mov     A, R7
B1:FF72 FB                          mov     R3, A
B1:FF73 7F 63                       mov     R7, #0x63 ; 'c'
B1:FF75 7E 00                       mov     R6, #0
B1:FF77 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF7A EF                          mov     A, R7
B1:FF7B 22                          ret
Pelo visto, essa rotina só é chamada 1 vez, ao iniciar um CD.

Mas a rotina que você criou para tratar as opções de cor da legenda é chamada várias vezes (possivelmente por todas as Sub_Style, secundárias e primária). Daí, foi só fazer como eu fiz no meu firmware: um salto (com bank switch) da rotina que aplica as cores para a rotina que aplica os alinhamentos. Ela era assim:

B3:FAC2             ; aplica cores legenda
B3:FAC2
B3:FAC2             B3_FAC2:                                ; CODE XREF: BankSw_223_B3_519C+2CE_p
B3:FAC2 7F 4E                       mov     R7, #0x4E ; 'N'
B3:FAC4 7E 00                       mov     R6, #0
B3:FAC6 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FAC9 EF                          mov     A, R7
B3:FACA FB                          mov     R3, A
B3:FACB 7F 7B                       mov     R7, #0x7B ; '{'
B3:FACD 7E 00                       mov     R6, #0
B3:FACF 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FAD2 EF                          mov     A, R7
B3:FAD3 FA                          mov     R2, A
B3:FAD4 7F 2E                       mov     R7, #0x2E ; '.'
B3:FAD6 7E 00                       mov     R6, #0
B3:FAD8 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FADB EF                          mov     A, R7
B3:FADC F9                          mov     R1, A
B3:FADD 7D 00                       mov     R5, #0
B3:FADF 7F 11                       mov     R7, #0x11
B3:FAE1 90 FB A4                    mov     DPTR, #XRAM_FBA4
B3:FAE4 EA                          mov     A, R2
B3:FAE5 F0                          movx    @DPTR, A
B3:FAE6 A3                          inc     DPTR
B3:FAE7 E9                          mov     A, R1
B3:FAE8 F0                          movx    @DPTR, A
B3:FAE9 22                          ret
Ficou assim:

B3:FAC2             ; aplica cores legenda
B3:FAC2
B3:FAC2             B3_FAC2:                                ; CODE XREF: BankSw_223_B3_519C+2CE_p
B3:FAC2 90 EE 21                    mov     DPTR, #0xEE21            ; primeiro, chama rotina que aplica alinhamento
B3:FAC5 12 02 40                    lcall   B3_Bank_1
B3:FAC8 7F 4E                       mov     R7, #0x4E ; 'N'
B3:FACA 7E 00                       mov     R6, #0
B3:FACC 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FACF EF                          mov     A, R7
B3:FAD0 FB                          mov     R3, A
B3:FAD1 7F 7B                       mov     R7, #0x7B ; '{'
B3:FAD3 7E 00                       mov     R6, #0
B3:FAD5 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FAD8 EF                          mov     A, R7
B3:FAD9 FA                          mov     R2, A
B3:FADA 7F 2E                       mov     R7, #0x2E ; '.'
B3:FADC 7E 00                       mov     R6, #0
B3:FADE 12 05 D7                    lcall   B3_BS_125_B4_E0AE
B3:FAE1 EF                          mov     A, R7
B3:FAE2 F9                          mov     R1, A
B3:FAE3 7D 00                       mov     R5, #0
B3:FAE5 7F 11                       mov     R7, #0x11
B3:FAE7 90 FB A4                    mov     DPTR, #XRAM_FBA4
B3:FAEA EA                          mov     A, R2
B3:FAEB F0                          movx    @DPTR, A
B3:FAEC A3                          inc     DPTR
B3:FAED E9                          mov     A, R1
B3:FAEE F0                          movx    @DPTR, A
B3:FAEF 22                          ret

Pronto, alinhamentos dinâmicos!  .

Agora, vou explicar como você deverá fazer com as opções de itálico, já que tenho os pontos de alteração do seu firmware:

Como dito antes, você deve criar um menu com as seguintes opções (só podem ser esses valores, pois são os esperados na rotina do itálico no ARM):

"mostrar todas as tags"   --> valor #40
"esconder todas as tags"  --> valor #20
"habilitar o itálico"     --> valor #00
Você pode usar o endeço de EEPROM que quiser (que estiver disponível). Vamos considerar que você use o endereço XX. Após criar o menu, você deverá fazer a seguinte modificação na rotina que aplica o alinhamento:

B1:FF54             ; aplica alinhamentos legenda
B1:FF54
B1:FF54             B1_FF54:                                ; CODE XREF: B1_EE21+25_p
B1:FF54 7F 57                       mov     R7, #0x57 ; 'W'
B1:FF56 7E 00                       mov     R6, #0
B1:FF58 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF5B 74 28                       mov     A, #0x28 ; '('
B1:FF5D C3                          clr     C
B1:FF5E 9F                          subb    A, R7
B1:FF5F 90 FB F0                    mov     DPTR, #XRAM_FBF0
B1:FF62 F0                          movx    @DPTR, A
B1:FF63 C3                          clr     C
B1:FF64 24 82                       add     A, #0x82 ; 'é'
B1:FF66 90 FB F8                    mov     DPTR, #XRAM_FBF8
B1:FF69 F0                          movx    @DPTR, A
B1:FF6A 7F 62                       mov     R7, #0x62 ; 'b'
B1:FF6C 7E 00                       mov     R6, #0
B1:FF6E 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF71 EF                          mov     A, R7
B1:FF72 FB                          mov     R3, A
B1:FF73 7F 63                       mov     R7, #0x63 ; 'c'            ; alinhamento horizontal agora é em 63!
B1:FF75 7E 00                       mov     R6, #0
B1:FF77 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF7A EF                          mov     A, R7
B1:FF7B FA                          mov     R2, A                        ; alinhamento horizontal guardado temporariamente em R2
B1:FF7C 7F XX                       mov     R7, #0xXX ; 'c'          ; valor da nova opção de itálico, endereço XX da eeprom
B1:FF7E 7E 00                       mov     R6, #0
B1:FF80 12 05 D7                    lcall   B1_BS_125_B4_E0AE
B1:FF83 EF                          mov     A, R7
B1:FF85 4A                          orl     A, R2                       ; OR entre opção de itálico e alinhamento horizontal
B1:FF7B 22                          ret

Assim, as duas opções serão mescladas e chegarão no mesmo byte ao endereço #7A380 + 9 da RAM para o ARM. Como as rotinas que processam o alinhamento horizontal apenas consideram os bits finais, não fará diferença no alinhamento. Já as rotinas do itálico vão filtrar apenas os bits 6 e 5 para processarem a opção.

Vou enviar um email para você com o firmware 1.4 modificado e com 1 fonte com itálicos. Você precisará fazer a nova opção de menu, com os valores que falei, e a modificação acima (senão o itálico sempre ficará habilitado e as demais tags serão filtradas), além de mais algumas fontes com itálicos para ficar tudo em 100%.

Rictad, tenho algumas (muitas) dúvidas... Agora eu entendi o processo, mas fiquei confuso com o fato do alinhamento e o itálico compartirem a mesma eeprom. Mudar uma opção no menu não vai afetar a outra? O fato do alinhamento não ser dinâmico, vai fazer com que a escolha do itálico também não seja dinâmico? Você explicou essa parte, mas não entendi como é que fica:

Mas lembre-se, o valor deve ser mesclado, utilizando a operação OR, com o valor da opção de alinhamento horizontal!. Isso quer dizer que você deve modificar, no 8032, o trecho que lê a opção de alinhamento horizontal para que também leia a opção de tags. Aí você faria um OR entre os 2 valores e enviaria o resultado como se fosse o valor de alinhamento. Porém, como eu ainda não tenho certeza se a posição de memória que usei no ARM realmente corresponde ao alinhamento horizontal, deixe essa parte do OR para depois de eu realizar mais alguns testes.

Você já viu como e que funciona o patch do carregamento de legendas com nome distinto?



O menu tem tres opções: 00, 01 e 02. O patch lé o endereço da eeprom, se o byte guardado for 00 carrega primeiro a original e depois todas legendas, se for 01 carrega todas as legendas, e se for 02 carrega somente as legendas originais (mesmo nome)...

Certo Jmaraujo,

Vou fazer testes com o alinhamento da nova versão. Também enviarei para você o 1.3 com itálico para você testar.

Seguem as rotinas do itálico (patchs) no ARM, ainda sem comentários.

Inibe tags ou habilita itálico na rotina principal:
ROM:000755F0             sub_755F0                               ; CODE XREF: sub_E64C+A8_p
ROM:000755F0                                                     ; sub_75670+6_p
ROM:000755F0 2A 4A                       LDR     R2, =unk_7A380
ROM:000755F2
ROM:000755F2             loc_755F2                               ; CODE XREF: sub_755F0+20_j
ROM:000755F2 53 7A                       LDRB    R3, [R2,#9]
ROM:000755F4 60 20                       MOVS    R0, #0x60 ; '`'
ROM:000755F6 03 40                       ANDS    R3, R0
ROM:000755F8 40 2B                       CMP     R3, #0x40 ; '@'
ROM:000755FA 2E D0                       BEQ     loc_7565A
ROM:000755FC 3C 2D                       CMP     R5, #0x3C ; '<'
ROM:000755FE 24 D1                       BNE     loc_7564A
ROM:00075600 20 2B                       CMP     R3, #0x20 ; ' '
ROM:00075602 06 D1                       BNE     loc_75612
ROM:00075604
ROM:00075604             loc_75604                               ; CODE XREF: sub_755F0+1A_j
ROM:00075604                                                     ; sub_755F0+30_j ...
ROM:00075604 01 31                       ADDS    R1, #1
ROM:00075606 75 5C                       LDRB    R5, [R6,R1]
ROM:00075608 3E 2D                       CMP     R5, #0x3E ; '>'
ROM:0007560A FB D1                       BNE     loc_75604
ROM:0007560C
ROM:0007560C             loc_7560C                               ; CODE XREF: sub_755F0+3A_j
ROM:0007560C                                                     ; sub_755F0+58_j
ROM:0007560C 01 31                       ADDS    R1, #1
ROM:0007560E 75 5C                       LDRB    R5, [R6,R1]
ROM:00075610 EF E7                       B       loc_755F2
ROM:00075612             ; ---------------------------------------------------------------------------
ROM:00075612
ROM:00075612             loc_75612                               ; CODE XREF: sub_755F0+12_j
ROM:00075612 01 31                       ADDS    R1, #1
ROM:00075614 75 5C                       LDRB    R5, [R6,R1]
ROM:00075616 69 2D                       CMP     R5, #0x69 ; 'i'
ROM:00075618 08 D1                       BNE     loc_7562C
ROM:0007561A 01 31                       ADDS    R1, #1
ROM:0007561C 75 5C                       LDRB    R5, [R6,R1]
ROM:0007561E 3E 2D                       CMP     R5, #0x3E ; '>'
ROM:00075620 F0 D1                       BNE     loc_75604
ROM:00075622 53 7A                       LDRB    R3, [R2,#9]
ROM:00075624 80 20                       MOVS    R0, #0x80 ; 'Ç'
ROM:00075626 03 43                       ORRS    R3, R0
ROM:00075628 53 72                       STRB    R3, [R2,#9]
ROM:0007562A EF E7                       B       loc_7560C
ROM:0007562C             ; ---------------------------------------------------------------------------
ROM:0007562C
ROM:0007562C             loc_7562C                               ; CODE XREF: sub_755F0+28_j
ROM:0007562C 2F 2D                       CMP     R5, #0x2F ; '/'
ROM:0007562E E9 D1                       BNE     loc_75604
ROM:00075630 01 31                       ADDS    R1, #1
ROM:00075632 75 5C                       LDRB    R5, [R6,R1]
ROM:00075634 69 2D                       CMP     R5, #0x69 ; 'i'
ROM:00075636 E5 D1                       BNE     loc_75604
ROM:00075638 01 31                       ADDS    R1, #1
ROM:0007563A 75 5C                       LDRB    R5, [R6,R1]
ROM:0007563C 3E 2D                       CMP     R5, #0x3E ; '>'
ROM:0007563E E1 D1                       BNE     loc_75604
ROM:00075640 53 7A                       LDRB    R3, [R2,#9]
ROM:00075642 7F 20                       MOVS    R0, #0x7F ; ''
ROM:00075644 03 40                       ANDS    R3, R0
ROM:00075646 53 72                       STRB    R3, [R2,#9]
ROM:00075648 E0 E7                       B       loc_7560C
ROM:0007564A             ; ---------------------------------------------------------------------------
ROM:0007564A
ROM:0007564A             loc_7564A                               ; CODE XREF: sub_755F0+E_j
ROM:0007564A 53 7A                       LDRB    R3, [R2,#9]
ROM:0007564C
ROM:0007564C             loc_7564C                               ; DATA XREF: ROM:loc_75268_r
ROM:0007564C 80 20                       MOVS    R0, #0x80 ; 'Ç'
ROM:0007564E 03 40                       ANDS    R3, R0
ROM:00075650 80 2B                       CMP     R3, #0x80 ; 'Ç'
ROM:00075652 02 D1                       BNE     loc_7565A
ROM:00075654 20 2D                       CMP     R5, #0x20 ; ' '
ROM:00075656 00 D9                       BLS     loc_7565A
ROM:00075658 DF 35                       ADDS    R5, #0xDF ; '¯'
ROM:0007565A
ROM:0007565A             loc_7565A                               ; CODE XREF: sub_755F0+A_j
ROM:0007565A                                                     ; sub_755F0+62_j ...
ROM:0007565A 48 1C                       ADDS    R0, R1, #1
ROM:0007565C 00 06                       LSLS    R0, R0, #0x18
ROM:0007565E 00 0E                       LSRS    R0, R0, #0x18
ROM:00075660 70 47                       BX      LR
ROM:00075660             ; End of function sub_755F0
Inibe tags ou habilita itálico na rotina "centraliza" (agora aproveita a rotina anterior, para não repetir código):
ROM:00075670             sub_75670                               ; CODE XREF: sub_E38C:loc_E3A0_p
ROM:00075670 20 B5                       PUSH    {R5,LR}
ROM:00075672 35 1C                       ADDS    R5, R6, #0
ROM:00075674 3E 1C                       ADDS    R6, R7, #0
ROM:00075676 FF F7 BB FF                 BL      sub_755F0
ROM:0007567A 2E 1C                       ADDS    R6, R5, #0
ROM:0007567C 20 BC                       POP     {R5}
ROM:0007567E 08 BC                       POP     {R3}
ROM:00075680 18 47                       BX      R3
ROM:00075680             ; End of function sub_75670
Desliga itálico antes de cada quadro:
ROM:00075686             sub_75686                               ; CODE XREF: sub_E64C+98_p
ROM:00075686 05 4A                       LDR     R2, =unk_7A380
ROM:00075688 53 7A                       LDRB    R3, [R2,#9]
ROM:0007568A 7F 24                       MOVS    R4, #0x7F ; ''
ROM:0007568C 23 40                       ANDS    R3, R4
ROM:0007568E 53 72                       STRB    R3, [R2,#9]
ROM:00075690 00 24                       MOVS    R4, #0
ROM:00075692 01 30                       ADDS    R0, #1
ROM:00075694 70 47                       BX      LR
ROM:00075694             ; End of function sub_75686
Palavra com endereço inicial da tabela de opções de legenda:
ROM:0007569C 80 A3 07 00 off_7569C       DCD unk_7A380           ; DATA XREF: sub_755F0_r
ROM:0007569C                                                     ; sub_75686_r
ROM:000756A0 00                          DCB    0
Agora os pontos modificados para chamar as rotinas (BLs):

Desliga o itálico no começo de cada quadro:
ROM:0000E6E2 05 98                       LDR     R0, [SP,#0x38+var_24]
ROM:0000E6E4 66 F0 CF FF                 BL      sub_75686
ROM:0000E6E8 00 04                       LSLS    R0, R0, #0x10
Inibe tags ou habilita itálico na rotina principal:
ROM:0000E6F0 21 1C                       ADDS    R1, R4, #0
ROM:0000E6F2 75 5C                       LDRB    R5, [R6,R1]
ROM:0000E6F4 66 F0 7C FF                 BL      sub_755F0
ROM:0000E6F8 04 1C                       ADDS    R4, R0, #0
ROM:0000E6FA C0 46                       NOP
Inibe tags ou habilita itálico na rotina "centraliza":
ROM:0000E3A0 67 F0 66 F9                 BL      sub_75670
ROM:0000E3A4 04 1C                       ADDS    R4, R0, #0
ROM:0000E3A6 C0 46                       NOP