[Thomson] Vidéo avec son en streaming

[Daniel]

Le bricolage à 5 euros permettant de jouer sur Thomson un signal audio en streaming à 58824 Hz permet aussi de faire de la video avec son à 22050 Hz. Voici une démo du résultat obtenu : http://dcmoto.free.fr/bricolage/streami ... at_win.zip



Rappel du schéma du montage :

[6502man]

EXCELLENT Daniel

Trop fort

[Xavier]

Bravo Daniel!

[Daniel]

L'Arduino est finalement plus rapide que prévu pour lire la carte SD. J'ai découvert aujourd'hui qu'il y a des interruptions (eh oui, je suis débutant sur cette plateforme, je ne le savais pas). Elles perturbaient la lecture en introduisant des délais aléatoires. En désactivant les interruptions on lit la carte SD beaucoup plus vite, et surtout beaucoup plus régulièrement. Maintenant c'est uniquement la vitesse du 6809 qui limite le débit. Au mieux on peut lire 66666 octets par seconde, c'est déjà bien pour un Thomson.

Reste à exploiter cette vitesse. On pourrait concevoir une simulation de disquette, comme je l'ai fait avec le contrôleur CS91-280, qui serait 10 fois plus rapide que la disquette Thomson. Mais il faut beaucoup de temps pour mettre au point un nouveau contrôleur de disquette, l'investissement est trop lourd pour l'enjeu : la disquette est un support trop petit et sa lecture est trop irrégulière pour les démos.

L'intérêt est plus dans la lecture séquentielle, comme je l'ai fait en streaming audio puis en streaming vidéo. La balle est dans le camp des développeurs. Il faut savoir que la construction de l'interface est à peu près aussi difficile que l'assemblage de quatre briques de Lego. Dans le monde de l'Arduino tous les modules sont faits pour se connecter les uns aux autres avec des fils prévus pour cet usage, on oublie le fer à souder, il faut juste enfoncer des broches dans des connecteurs.

[__sam__]

Ca rend super bien, c'est très fluide. Bravo!

66Ko/sec, ca nous fait environ 8 fois 8ko/sec. Dans ce cas on peut imaginer de la video 80x50 en 64 couleur avec des matrices utilisées dans mes expériences de http://forum.system-cfg.com/viewtopic.p ... 48#p100648, mais full-screen ce coup ci.

Cependant 8fps c'est pas beaucoup, et il n'y aurait pas le son. Il faut vraiment une compression.

[__sam__]

Ah non rectif. Avec ma matrice, un écran 16:9 fait 80x45, soit 3.6ko. Dinons qu'on tourne à 12fps. La video mange 43ko/s des 66ko/s dispo. Il en reste 22ko/sec pour le son, ce qui est largement suffisant.

[Daniel]

Pour être honnête, le débit maximum est atteint si on lit sans rien faire d'autre. Dès lors qu'une instruction est ajoutée dans la boucle de 15 cycles le débit baisse. Dans la démo simon's cat, par exemple, je lis 4 octets en 91 cycles soit 43956 octets par seconde. La technique de compression utilisée permet d'afficher presque toujours 50 images pas seconde, sauf s'il y a beaucoup de différences d'une image à l'autre.

[__sam__]

Même à 36ko/sec on a encore un truc pas mal. J'explique: un pixel vidéo tient sur 6 bits (2bits par composantes). Deux pixels consécutifs font 12bits, ce qui laisse 4 bits pour le son tous les 2 octets. On a alors, via un stream de 36ko/sec, environ 10 images à la seconde et du son à 18kHz (car le son est présent un octet sur deux). C'est pas si mal que ca.

Seul truc pas évident: l'écran 80x45 manque de détails. Mais comme il y a de la couleur, ca compense peut-être.

Au fait, tu prévois une emul de ce "support" dans un prochain DCMOTO ? (En fait la possibilité de récupérer un stream d'octet par le protocole que tu as implémenté dans l'arduino.)

[Daniel]

Dans dcmoto_nouveau version 2015.06.01, en émulation MO5 ou TO8 ou n'importe quel autre ordinateur
- choisir support amovible : Interface SDMOTO
- charger fichier sur carte SD : cat.sd http://dcmoto.free.fr/bricolage/streaming/demo/cat.zip
- simuler le clavier pour charger le programme SDANIM2.BAS ci-dessous
- lancer le programme par RUN

Si je ne me suis pas trompé, la démo commence...

Code : Tout sélectionner

1 '================================
2 ' SDANIM2
3 '================================
10 SCREEN0,7,7:LOCATE0,0,0:CLS
20 A=&H9000
30 READX$:IFX$="**"THEN99
40 POKEA,VAL("&H"+X$):A=A+1:GOTO30
99 EXEC&H9000:END
100 DATA 34,7F,1A,50,8E,1F,40,E6
101 DATA 84,63,84,E1,84,27,14,63
102 DATA 84,86,A7,1F,8B,96,C0,8A
103 DATA 01,97,C0,8E,00,00,7F,90
104 DATA 51,20,0D,86,E7,1F,8B,96
105 DATA C3,8A,01,97,C3,8E,40,00
106 DATA 4F,5F,DD,CE,C6,7F,DD,CC
107 DATA 8A,04,97,CE,97,CF,84,3F
108 DATA 97,CD,D6,CC,8A,40,97,CD
109 DATA 5D,2B,0C,27,03,12,20,0B
110 DATA 8E,40,00,12,12,20,06,30
111 DATA 89,01,00,30,85,84,3F,97
112 DATA CD,96,CC,8A,40,97,CD,84
113 DATA 3F,97,CD,D6,CC,8A,40,97
114 DATA CD,E7,84,84,3F,97,CD,96
115 DATA CC,8A,40,97,CD,81,FF,26
116 DATA BD,35,FF,**

Je sais que beaucoup de membres du forum n'aiment pas les émulateurs, alors je donne aussi le sketch Arduino pour lancer la démo sur un vrai ordinateur Thomson (MO ou TO) :

Code : Tout sélectionner

/**************************************************\
*                 S D A N I M 2                    * 
*           (c) 2015 - Daniel Coulom               *  
*           http://dcmoto.free.fr/                 *
*           http://forum.system-cfg.com/           *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune  garantie  et *
* sans  engager  la  responsabilité  de  l'auteur. *
* Vous  pouvez  l' utiliser,  le  modifier  et  le *
* diffuser librement, en conservant cette  licence *
* et les références de l'auteur dans   toutes  les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/

/***************************************************
*                Version 2015.06.03                *
****************************************************
Historique
2015.06.03 optimisation du code
2015.06.02 desactivation des interruptions
2015.05.23 n'utilise plus SimpleSDAudio.cpp
2015.05.19 premiere version operationnelle

Communication parallele avec un ordinateur Thomson
Lecture des donnees dans un fichier sur carte SD
Envoi des octets sur le port D a destination du
port manettes de l'ordinateur Thomson.

Connexion module Catalex pour carte micro SD
 GND --> GND
 SCK --> D13
MISO --> D12
MOSI --> D11
 VCC --> VCC (5V)
  CS --> D10

Connexion DB9 de la manette 0
   1 --> D0 (RX)
   2 --> D1 (TX)
   3 --> D2
   4 --> D3
   5 --> VCC (+5V)
   6 --> D8
   7 --> non connecte
   8 --> non connecte
   9 --> GND
   
Connexion DB9 de la manette 1
   1 --> D4
   2 --> D5
   3 --> D6
   4 --> D7
   5 --> non connecte
   6 --> non connecte
   7 --> non connecte
   8 --> non connecte
   9 --> non connecte
 
 This sketch uses the SimpleSDAudio library for SD card access.
 Visit SimpleSDAudio website for more information:
 http://www.hackerspace-ffm.de/wiki/index.php?title=SimpleSDAudio
*/

#include <sd_l0.h>
#include <sd_l1.h>
#include <sd_l2.h>

#define SD_FILE "cat.sd"

uint8_t  SD_L1_CardCommand(uint8_t cmd, uint32_t arg);
SD_L2_File_t AudioFileInfo;  
uint8_t string[1024];

void setup()
{
 int i;         // compteur de boucle
 int index;     //index dans le buffer
 int wait0xfe;  // indicateur d'attente octet 0xfe
 //desactiver les interruptions 
 noInterrupts(); 
 // Configure pin8 as an input (thomson request)
 pinMode(8, INPUT);
 // Configure port D as an output
 PORTD = 0x00;
 DDRD = 0xff;
 // Initialize SD card
 SD_L0_CSPin = 10;
 SD_L2_Init(string);
 SD_L0_SpiSetHighSpeed();
 // Search for file SD_FILE in Rootdir (=cluster 0),
 // search shortname files only (0x00,0x18)
 SD_L2_SearchFile((uint8_t *)SD_FILE, 0UL, 0x00, 0x18, &AudioFileInfo);
 // send CMD18 (multiblock read)
 uint32_t offset = AudioFileInfo.ActSector;    // offset = secteur
 if (SD_L1_GetCardType() != SD_CARD_TYPE_SDHC) // si carte non SDHC
     offset <<= 9;                             // offset = octet
 SD_L1_CardCommand(18, offset);         // lance CMD18
 while(SD_L0_SpiRecvByte() != 0xfe);    // attente octet $FE de debut de bloc
 uint32_t count = 0;                    // compteur d'echantillons

 while(count < AudioFileInfo.Size)      // tant qu'il reste des echantillons
 {
  // remplir le buffer avec deux octets a chaque boucle
  // (512 octets de donnees et 2 octets de CRC)
  // et envoyer un seul octet par boucle sur le port D
  index = 0;
  for(i = 0; i < 257; i++)                // boucle 257 fois
  {
   string[index++] = SD_L0_SpiRecvByte(); // octet lu sur la carte
   while(digitalRead(8) == LOW);          // wait Thomson acknowledge
   string[index++] = SD_L0_SpiRecvByte(); // octet lu sur la carte
   PORTD = string[i];                     // write byte to output port
   while(digitalRead(8) == HIGH);         // wait Thomson request
  }

  // envoyer les octets suivants (lus dans le buffer)
  // tout en attendant l'octet 0xfe
  wait0xfe = 1;
  for(i = 257; i < 512; i++)
  {
   while(digitalRead(8) == LOW);   // wait Thomson acknowledge
   if(wait0xfe)
   if(SD_L0_SpiRecvByte() == 0xfe) // lire un octet, tester 0xfe
   wait0xfe = 0;                   // raz flag d'attente 0xfe                  
   PORTD = string[i];              // load byte to send
   while(digitalRead(8) == HIGH);  // wait Thomson request
  }
  count += 512;                    // 512 echantillons par boucle 
 }
}

void loop(void) {
}

Et enfin, pour les programmeurs, le code source de SDANIM2 :

Code : Tout sélectionner

/**************************************************\
*                 S D A N I M 2                    * 
*           (c) 2015 - Daniel Coulom               *  
*           http://dcmoto.free.fr/                 *
*           http://forum.system-cfg.com/           *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune  garantie  et *
* sans  engager  la  responsabilité  de  l'auteur. *
* Vous  pouvez  l' utiliser,  le  modifier  et  le *
* diffuser librement, en conservant cette  licence *
* et les références de l'auteur dans   toutes  les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/

* Ce programme sort video + son 22050 Hz a partir de
* donnees lues sur carte SD par l'Arduino et envoyées
* à l'ordinateur Thomson par les ports manettes. 

/**************************************************\
*                Version 2015.05.28                *
\**************************************************/
* Historique
* 2015.05.28 compatibilite MO et TO
* 2015.05.27 premiere version TO operationnelle

*------------------------------------------------------
* INITIALISATIONS
*------------------------------------------------------
  ORG   $9000 
  
  PSHS  U,Y,X,DP,B,A,CC  empile les registres
  ORCC  #$50      masque les interruptions
  LDX   #$1F40    adresse pour test RAM ou ROM
  LDB   ,X        lecture adresse X
  COM   ,X        tente de modifier adresse X
  CMPB  ,X        test modification adresse X
  BEQ   INIT1     pas de difference -> TO
  COM   ,X        retablissement adresse X
  LDA   #$A7      valeur initialisation DP pour MO
  TFR   A,DP      initialisation DP
  LDA   <$C0      port A du PIA systeme 
  ORA   #$01      set bit 0
  STA   <$C0      selection video forme
  LDX   #$0000    adresse dans ecran
  CLR   PLAY2+1   adresse nouvel ecran 
  BRA   INIT2     suite des initialisations    
INIT1
  LDA   #$E7      valeur initialisation DP pour TO
  TFR   A,DP      initialisation DP
  LDA   <$C3      registre de donnees peripheriques port C 
  ORA   #$01      set bit 0
  STA   <$C3      selection video forme
  LDX   #$4000    adresse dans ecran
INIT2
  CLRA            A=$00 
  CLRB            B=$00 
  STD   <$CE      selectionne DDRA et DDRB
  LDB   #$7F      B=$7F 
  STD   <$CC      PA b0-7 en entree, PB b0-7 en sortie
  ORA   #$04      set b2
  STA   <$CE      selectionne PORTA
  STA   <$CF      selectionne PORTB

*------------------------------------------------------
* JOUE LA VIDEO ET LA MUSIQUE
* Boucle de 91 cycles = 21978 Hz
*------------------------------------------------------

* lecture déplacement ecran dans B (34 cycles)
PLAY1
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDB   <$CC      (4) lecture octet déplacement
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) acknowledge
  TSTB            (2) test du signe
  BMI   PLAY3     (3) increment negatif
  BEQ   PLAY2     (3) nouvelle image
  NOP             (2) temporisation 2 cycles
  BRA   PLAY4     (3) incrementation
PLAY2
  LDX   #$4000    (3) debut nouvelle image 
  NOP             (2) temporisation 2 cycles
  NOP             (2) temporisation 2 cycles
  BRA   PLAY5     (3) lecture suivante 
PLAY3
  LEAX  256,X     (8) increment negatif: ajout 256
PLAY4
  LEAX  B,X       (5) incrementation index ecran

* lecture echantillon de son dans A (16 cycles)
PLAY5
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) joue le son et acknowledge

* lecture octet image dans B (20 cycles)
PLAY6
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDB   <$CC      (4) lecture octet image
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) acknowledge
  STB   ,X        (4) affiche l'octet image

* lecture echantillon de son (21 cycles)
PLAY7
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) joue le son et acknowledge
  CMPA  #$FF      (2) test de fin de fichier
  BNE   PLAY1     (3) nouvelle boucle

*------------------------------------------------------
* RETOUR AU BASIC
*------------------------------------------------------
  PULS  CC,A,B,DP,X,Y,U,PC retour au Basic
       
  END

[__sam__]

Quelque remarques en passant après une 1ere lecture à la pause de midi du boulot

Code : Tout sélectionner

LDB   #$7F      B=$7F 
STD   <$CC      PA b0-7 en entree, PB b0-7 en sortie

Je pense que le commentaire est faux. Il y a l'un des port dont le bit de poids fort ne va pas dans la même direction que les autres bits, non ?

Ensuite dans le player, je vois qure tu traites le cas de l'offset negatif en ajoutant 256 à X. Ca rajoute des cycles. Tu peux traiter les offsets negatifs comme des non signés en faisant un simple ABX dans tous les cas (positifs ou negatif). C'est bien plus rapide et compact, et augmentera un poil la vitesse de lecture.

Une question ensuite, b6 est utilisé pour le protocole. Est-ce qu'on peut facilement utiliser b0 ? Si oui, le protocole pourrait être implémenté avec des simples inc/dec ce qui libérerait A pour autre chose.

[Daniel]

- Oui, le commentaire est faux, je voulais mettre les 8 bits en sortie mais finalement je ne l'ai pas fait. Peu importe, le bit 7 est inutilisé. Au tout début du développement, je l'ai mis en lecture pour permettre à l'Arduino de signaler la disponibilité d'un nouvel échantillon. Finalement, pour gagner un test, j'ai abandonné l'idée, en supposant que l'Arduino est toujours plus rapide que le 6809, donc que l'octet est toujours prêt au moment de la lecture du port.

- Oui, tu as raison pour ABX, je le ferai dans une prochaine version.

- b0 est un des bits du CNA, et n'est pas disponible sur le port manette (ni sur aucun port). On ne peut utiliser que b6 ou b7, normalement dédiés aux boutons 0 des manettes 0 et 1. J'avais aussi envisagé d'utiliser le signal MOTORON sur le connecteur magnétophone. Ca complique le câblage et aussi la programmation, et je pense qu'au total on perd des cycles. Dans la méthode actuelle, l'astuce est d'envoyer à la fois l'échantillon de son au CNA et l'acknowledge à l'Arduino par une seule instruction STA <$CD.

[__sam__]

- b0 est un des bits du CNA, et n'est pas disponible sur le port manette (ni sur aucun port). On ne peut utiliser que b6 ou b7, normalement dédiés aux boutons 0 des manettes 0 et 1. J'avais aussi envisagé d'utiliser le signal MOTORON sur le connecteur magnétophone. Ca complique le câblage et aussi la programmation, et je pense qu'au total on perd des cycles. Dans la méthode actuelle, l'astuce est d'envoyer à la fois l'échantillon de son au CNA et l'acknowledge à l'Arduino par une seule instruction STA <$CD.

Oui je comprends. Du coup il faut jongler un peu avec des and/or lorsqu'on lit l'offset et l'octet vidéo.

(j'ai vachement envie de tester le mode video couleur+son avec cette approche sous emul. Il faut que je me libère plus de temps libre (et l'esprit) )

[Daniel]

En utilisant ABX et en optimisant un peu, j'ai réussi à gagner 10 cycles dans la boucle de lecture. Comme quoi il faut se mettre à plusieurs pour optimiser le code

L'émulateur est une bonne base pour développer. Il faut seulement se méfier d'une chose : dcmoto simule un arduino infiniment rapide. Ce qui fonctionne en émulation peut éventuellement ne pas marcher dans la réalité si l'octet n'est pas initialisé assez vite. Le "croquis" (ce nom pour désigner les programmes me fait sourire, en anglais c'est sketch) Arduino fonctionne bien à 58824 octets/seconde, donc a priori je n'ai pas trop d'inquiétude, il devrait pouvoir tenir le rythme du 6809. Si tu n'as pas le matériel, je peux tester tes vidéos.

[__sam__]

10 cycles, c'est déjà ca, mais en examinant le code il me semble qu'il y a deux "ORA #$40" inutiles dans la partie lecture échantillons audio si ces derniers ont déjà le b6 à 1 sur la carte SD:

Code : Tout sélectionner

...
PLAY5
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
*  ORA   #$40      (2) set bit 6 <=== inutile
  STA   <$CD      (4) joue le son et acknowledge
...
PLAY7
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
*  ORA   #$40      (2) set bit 6 <=== inutile
  STA   <$CD      (4) joue le son et acknowledge

Cela fait gagner 4 cycles, soit 77 cycles par rapport à 91 au début (gain = 18% plus rapide), soit du son à 26khz (25974 exactement).

On peut aussi économiser le "cmpa #$ff" final en faisant juste un test BMI (b7=1 sur octet son ==> fin fichier). On descend alors à 75cycles (16 de gagnés par rapport à la version d'origine à 91), soit 26.666khz.

Question: est-ce que l'arduino détecte le front descendant sur le b6 pour écrire une nouvelle donnée? Si oui, alors après un "ora #$40; sta <$CD", <$CC contient toujours l'octet de déplacement. On peut alors lire B juste après et économiser les 2 cycles du TSTB:

Code : Tout sélectionner

PLAY1
  ANlDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) acknowledge
  LDB   <$CC      (4) lecture octet déplacement
*  TSTB            (2) test du signe (inutile)
  BEQ   PLAY2     (3) nouvelle image
  ABX

On descend alors à 73 cycles cpu pour 2 échantillons audio et 1 echantillon son, soit 27.4khz.

C'est très sensiblement le son qualité maxi de l'amiga en son temps où le chip paula récupérait maximum 2 échantillons audio par ligne vidéo soit 2*576*25 = 28khz alors que le 6809 fait tout lui même sans copro et s'occupe même de la video! Si on déroule la boucle de lecture de 2 échantillons son 8 fois en ne testant la fin de fichier qu'une fois sur 8, on économise le BMI 7 fois sur 8, soit 14 cycles sur 73*8, ce qui fait 28.07khz: on dépasse l'amiga (mais c'est juste pour le principe, car 27.4 c'est déjà bien).

Enfin une curiosité: on peu compacter un peu mieux en remarquant que b vaut 255 au max. Or si on remplace "STB ,x" dans la partie vidéo par "STB ,x+", on gagne 1 sur l'incrément, ce qui veut dire qu'on incrémente à présent de (b+1). On peut donc faire des sauts de 256 octets au lieu de 255. Ce qui provoque peut-être un léger gain en optimisation (0.4%). Ca ne changera pas grand chose et en plus pas souvent alors que cela ralentira systématiquement l'affichage de 1 cycle. Cela impactera négativement la vitesse de l'afficheur. Le jeu n'en vaut probablement pas la chandelle, mais il fallait signaler l'idée.

[Daniel]

C'est marrant, nous avons eu exactement les mêmes idées. Dans les 10 cycles gagnés hier, j'ai déjà supprimé le CMPB #$FF et le TSTB (mais ensuite je l'ai remis parce que ça m'arrangeait). J'ai aussi eu l'idée de supprimer les deux ORA #$40, mais il aurait fallu régénérer le fichier .sd et je n'ai pas eu le temps.

Finalement, j'ai préféré utiliser les cycles gagnés pour équilibrer les intervalles entre les envois d'échantillons sur le CNA, en ajoutant une temporisation. C'est plus propre que de les envoyer irrégulièrement. La nouvelle version joue 22222 echantillons par seconde, c'est loin du maximum théorique mais le résultat est déjà très bon.

Code : Tout sélectionner

/**************************************************\
*                 S D A N I M 2                    * 
*           (c) 2015 - Daniel Coulom               *  
*           http://dcmoto.free.fr/                 *
*           http://forum.system-cfg.com/           *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune  garantie  et *
* sans  engager  la  responsabilité  de  l'auteur. *
* Vous  pouvez  l' utiliser,  le  modifier  et  le *
* diffuser librement, en conservant cette  licence *
* et les références de l'auteur dans   toutes  les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/

* Ce programme sort video + son 22050 Hz a partir de
* donnees lues sur carte SD par l'Arduino et envoyées
* à l'ordinateur Thomson par les ports manettes. 

/**************************************************\
*                Version 2015.06.03                *
\**************************************************/
* Historique
* 2015.06.03 utilisation de ABX pour incrementer X
* 2015.05.28 compatibilite MO et TO
* 2015.05.27 premiere version TO operationnelle

*------------------------------------------------------
* INITIALISATIONS
*------------------------------------------------------
  ORG   $9000 
  
  PSHS  U,Y,X,DP,B,A,CC  empile les registres
  ORCC  #$50      masque les interruptions
  LDX   #$1F40    adresse pour test RAM ou ROM
  LDB   ,X        lecture adresse X
  COM   ,X        tente de modifier adresse X
  CMPB  ,X        test modification adresse X
  BEQ   INIT1     pas de difference -> TO
  COM   ,X        retablissement adresse X
  LDA   #$A7      valeur initialisation DP pour MO
  TFR   A,DP      initialisation DP
  LDA   <$C0      port A du PIA systeme 
  ORA   #$01      set bit 0
  STA   <$C0      selection video forme
  LDX   #$0000    adresse dans ecran
  CLR   PLAY2+1   adresse nouvel ecran 
  BRA   INIT2     suite des initialisations    
INIT1
  LDA   #$E7      valeur initialisation DP pour TO
  TFR   A,DP      initialisation DP
  LDA   <$C3      registre de donnees peripheriques port C 
  ORA   #$01      set bit 0
  STA   <$C3      selection video forme
  LDX   #$4000    adresse dans ecran
INIT2
  CLRA            A=$00 
  CLRB            B=$00 
  STD   <$CE      selectionne DDRA et DDRB
  LDB   #$7F      B=$7F 
  STD   <$CC      PA b0-7 en entree, PB b0-6 en sortie
  ORA   #$04      set b2
  STA   <$CE      selectionne PORTA
  STA   <$CF      selectionne PORTB

*------------------------------------------------------
* JOUE LA VIDEO ET LA MUSIQUE
* Boucle de 90 cycles pour 2 echantillons = 22222 Hz
*------------------------------------------------------

* lecture déplacement ecran dans B (16 cycles)
PLAY1
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDB   <$CC      (4) lecture octet déplacement
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) acknowledge

* calcul position dans l ecran (11 cycles)
  TSTB            (2) test du signe
  BEQ   PLAY2     (3) nouvelle image
  ABX             (3) ajout de l'increment 
  BRA   PLAY3     (3) suite
PLAY2 
  LDX   #$4000    (3) debut nouvelle image 
  BRA   PLAY3     (3) suite

* lecture echantillon de son dans A (16 cycles)
PLAY3
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) joue le son et acknowledge

* lecture octet image dans B (20 cycles)
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDB   <$CC      (4) lecture octet image
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) acknowledge
  STB   ,X        (4) affiche l'octet image

* temporisation (8 cycles)
  NOP             (2) temporisation 
  NOP             (2) temporisation 
  NOP             (2) temporisation 
  NOP             (2) temporisation 
  
* lecture echantillon de son (19 cycles)
  ANDA  #$3F      (2) clear bit 6
  STA   <$CD      (4) request to send
  LDA   <$CC      (4) lecture echantillon son
  ORA   #$40      (2) set bit 6
  STA   <$CD      (4) joue le son et acknowledge
  BPL   PLAY1     (3) nouvelle boucle

*------------------------------------------------------
* RETOUR AU BASIC
*------------------------------------------------------
  PULS  CC,A,B,DP,X,Y,U,PC retour au Basic
       
  END

Le dessin au trait de Simon's Cat se prête bien à cette méthode de compression. C'est moins évident pour mes autres vidéos, par exemple celle de Jacques Brel à l'Olympia. Si j'ai le temps j'essaierai de la refaire en optimisant au maximum.

Une autre idée, pour gagner en qualité d'image, est de mettre un seul octet son pour deux octets d'image. On doit pouvoir descendre alors à 64 cycles par boucle, soit un peu moins de 16 kHz. Dommage pour le son, mais l'image sera plus fluide.