MSX Village forum

L'atelier » [EN COURS] Yamaha OPNA 2608 et le MSX. Utilisation d'un OPNA 2608 sur MSX.

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 24/08/2010

Messages: 4799

Le 11/09/2013 à 09h12
Reprise du message précédent

J'aime pô la FM :(
J'aurais préféré un SID ou un POKEY :D

Maire-adjoint

rank_special.png

Avatar

Association

Inscrit le: 02/10/2009

Messages: 9080

Le 11/09/2013 à 10h41
Igal je veux pas être rabat-joie mais trouve t'on la puce aussi difficilement que son data-sheet ?


:noel
Site web    

Villageois

rank_3.png

Avatar

Groupe : compte ++

Inscrit le: 22/11/2011

Messages: 852

Le 11/09/2013 à 11h38
Pour le YMF288, j'ai ça :




Philips.NMS.8245/50/80, Sony.F1XV/HBF-700D, Pana.FSA1FX/A1WX(x2)/A1GT, OCM, GR8BIT.... et ...
   

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 29/07/2010

Messages: 4996

Le 11/09/2013 à 12h29
Vous m'faites bander Marielle plaisir SVEN lol :fou

Tu trouves la même chose pour le YMF297-F et je change mon avatar "Monsieur Patate" par "Moi en Slip" :oups

L'YMF297-F fait 44 Pins qui permettent de câbler OPN et OPL :top

Faites vos jeux!!! qui veut m'voir en zlib

@Jipe: Aucun problème pour toutes les puces évoquées. Elle sont trouvables sur la toile.

La seule puce dont il est dit que Yamaha se serait réservé la production et l'exclusivité d'exploitation (si j'ai bien traduit) serait:

L'YM2164 (OPP) qui serait parfaitement compatible broche pour broche au YM2151 (OPM) ainsi qu'une très grande similitude au niveau des registres. (Tout est donc au conditionnel).

Edit: GIMIC (ils exploitent presque toutes les puces) est une bonne piste mais ils j'ai pas u de schéma chez eux!

Edit2: Sven m'a communiqué ce lien "japonifié" et donc inacceptable par le Forum.
Après me l'avoir transmis par Skype, le lien est devenu exploitable sur notre forum :top
Ca peut etre une bonne astuce pour les liens récalcitrants!

http://gimic.jp/index.php?GMC-MOD01%E8%AA%AC%E6%98%8E



Edité par igal Le 11/09/2013 à 12h53
GDX

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 17/01/2011

Messages: 3064

Le 11/09/2013 à 14h29
igal :
Pour l'OPL3 / OPN3 (Hybride):

YMF297-F => OPN3 (SSG + FM) + OPL3 (FM)

http://fr.aliexpress.com/item/YMF297-F-QFP44-Quality-assurance-welcome-to-buy/689901988.html

Pour 32.46$ les 5 unités

Nb: DAC indéterminé


Sympa cette puce hybride.



Code TEXT :
YMF297
 
Il a le mode OPL et le mode de OPN, Le mode OPL a 2 modes : un à 2 opérateurs et l'autre à 4 opérateurs.
 
Mode OPN :
 
4 opérateurs
6 voix FM, 3 voix PSG, 1 voix générateur de bruit, 6 voix de rythme jouables simultanément.
Compatible avec le stéréo sauf le PSG
 
Mode OPL :
 
2 opérateurs / 4 opérateurs
De 11 à 20 voix FM.  (en fonction du mode choisi)
En mode 2 opérateurs, voix20 FM.
En mode 4 opérateurs, 6 voix FM jouables simultanément parmi 11 disponibles.




Edité par GDX Le 12/09/2013 à 00h05
   

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 29/07/2010

Messages: 1156

Le 11/09/2013 à 20h18
tiens, juste pour le fun
la carte SNE Sound Orchestra VS pour micro Japonais PC98 qui combinait OPN et MSX AUDIO :|


   

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 23/12/2009

Messages: 1171

Le 11/09/2013 à 20h37
igal :
Tu trouves la même chose pour le YMF297-F et je change mon avatar "Monsieur Patate" par "Moi en Slip" :oups


Y'en a déjà qui ont essayé de trouver ... :moue



http://www.soundshock.se/phpBB2/viewtopic.php?t=62&postdays=0&postorder=asc&start=0



(courriers à NEC et YAMAHA avec réponse négative de ceux-ci) :(


Daewoo DPC-200 (MSX1) / Sony HB-F9P (MSX2) / Panasonic FS-A1WX (MSX2+)
MegaSRAM 512Kb SCC (made in Jipe) / MegaFlashROM SCC+ 2SD
Sunrise CF ATA-IDE / FM-PAC
   

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 29/07/2010

Messages: 1156

Le 11/09/2013 à 20h59
non mais j'ai déja dit que c'etait mort.
on verra jamais igal en slip... :D

igal, si déja t'arrive a faire fonctionner l'équivalent de la carte en photo plus haut sur MSX
c'est moi qui me fout a POIL !! :tchin



Edité par popolon Le 11/09/2013 à 21h04


   
Visiteurs

Vagabond

rank_0.png

Avatar

Le 11/09/2013 à 21h18
Faut envoyer un drone dans les archives de Yamaha ! :fou
   

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 29/07/2010

Messages: 4996

Le 11/09/2013 à 21h27
Eh eh!

l'Y8950 génère l'OPL1 + ADPCM et l'YM2203 génère l'OPN + PSG

Vous voyez bien que c'est possible :D

En résumé, ce serait l'équivalent de ce couple mais en génération 3 pour l'OPL3 et OPN3 :top

J'suis curieux d'entendre le rendu de cette carte.

Popolon tu as un enregistrement quelque part?

Edit: @ Popolon: Je te signale que j'ai une centaine de sockets 64Pins spécifiques VDP 9938 et Y8950....Y a de quoi te foutre à poil non :fou

Voici musique OPNA seulement:
FM X 6
SSG X 3
RHYTHM 6
ADPCM 1








Edité par igal Le 11/09/2013 à 21h43

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 29/07/2010

Messages: 4996

Le 13/09/2013 à 10h13
Voici un extrait du "YAMAHA DELTA-T adpcm sound emulation subroutine" pour MAME v0.59.

La source => https://lists.gnu.org/archive/html/qemu-devel/2009-10/msg02413.html

Ce Driver émule l'ADPCM des puces "[(YM2608 OPNA), (YM2610/B OPNB), (Y8950 MSX AUDIO)]".

Code TEXT :
 
@@ -0,0 +1,335 @@
+/*
+**
+** File: ymdeltat.c
+**
+** YAMAHA DELTA-T adpcm sound emulation subroutine
+** used by fmopl.c(v0.37c-) and fm.c(v0.37a-)
+**
+** Base program is YM2610 emulator by Hiromitsu Shioya.
+** Written by Tatsuyuki Satoh
+**
+** History:
+** 05-08-2001 Jarek Burczynski:
+**  - now_step is initialized with 0 at the start of play.
+** 12-06-2001 Jarek Burczynski:
+**  - corrected end of sample bug in YM_DELTAT_ADPCM_CALC.
+**    Checked on real YM2610 chip - address register is 24 bits wide.
+**    Thanks go to Stefan Jokisch (address@hidden) for tracking down the 
problem.
+**
+** TO DO:
+**             Check size of the address register on the other chips....
+**
+** Version 0.37e
+**
+** sound chips that have this unit
+**
+** YM2608   OPNA
+** YM2610/B OPNB
+** Y8950    MSX AUDIO
+**
+**
+*/
+
+/* This version of ay8910.c is a fork of the MAME 0.59 one, relicensed under 
the LGPL.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef YM_INLINE_BLOCK
+
+#include "ymdeltat.h"
+
+#define INLINE static inline
+
+/* -------------------- log output  -------------------- */
+/* log output level */
+#define LOG_ERR  3      /* ERROR       */
+#define LOG_WAR  2      /* WARNING     */
+#define LOG_INF  1      /* INFORMATION */
+#define LOG_LEVEL LOG_ERR
+
+#define LOG(n,x)
+
+UINT8 *ym_deltat_memory;      /* memory pointer */
+
+/* Forecast to next Forecast (rate = *8) */
+/* 1/8 , 3/8 , 5/8 , 7/8 , 9/8 , 11/8 , 13/8 , 15/8 */
+const INT32 ym_deltat_decode_tableB1[16] = {
+  1,   3,   5,   7,   9,  11,  13,  15,
+  -1,  -3,  -5,  -7,  -9, -11, -13, -15,
+};
+/* delta to next delta (rate= *64) */
+/* 0.9 , 0.9 , 0.9 , 0.9 , 1.2 , 1.6 , 2.0 , 2.4 */
+const INT32 ym_deltat_decode_tableB2[16] = {
+  57,  57,  57,  57, 77, 102, 128, 153,
+  57,  57,  57,  57, 77, 102, 128, 153
+};
+
+/* DELTA-T-ADPCM write register */
+void YM_DELTAT_ADPCM_Write(YM_DELTAT *DELTAT,int r,int v)
+{
+       if(r>=0x10) return;
+       DELTAT->reg[r] = v; /* stock data */
+
+       switch( r ){
+       case 0x00:      /* START,REC,MEMDATA,REPEAT,SPOFF,--,--,RESET */
+#if 0
+               case 0x60:      /* write buffer MEMORY from PCM data port */
+               case 0x20:      /* read  buffer MEMORY to   PCM data port */
+#endif
+               if( v&0x80 ){
+                       DELTAT->portstate = v&0x90; /* start req,memory 
mode,repeat flag copy */
+                       /**** start ADPCM ****/
+                       DELTAT->volume_w_step = (double)DELTAT->volume * 
DELTAT->step / (1<<YM_DELTAT_SHIFT);
+                       DELTAT->now_addr = (DELTAT->start)<<1;
+                       DELTAT->now_step = 0;
+                       DELTAT->acc      = 0;
+                       DELTAT->adpcml   = 0;
+                       DELTAT->adpcmd   = YM_DELTAT_DELTA_DEF;
+                       DELTAT->next_leveling=0;
+
+                       if( !DELTAT->step )
+                       {
+                               DELTAT->portstate = 0x00;
+                       }
+                       /**** PCM memory check & limit check ****/
+                       if(DELTAT->memory == 0){                        /* 
Check memory Mapped */
+                               LOG(LOG_ERR,("YM Delta-T ADPCM rom not 
mappedn"));
+                               DELTAT->portstate = 0x00;
+                       }else{
+                               if( DELTAT->end >= DELTAT->memory_size )
+                               {               /* Check End in Range */
+                                       LOG(LOG_ERR,("YM Delta-T ADPCM end out 
of range: $%08xn",DELTAT->end));
+                                       DELTAT->end = DELTAT->memory_size - 1;
+                               }
+                               if( DELTAT->start >= DELTAT->memory_size )
+                               {               /* Check Start in Range */
+                                       LOG(LOG_ERR,("YM Delta-T ADPCM start 
out of range: $%08xn",DELTAT->start));
+                                       DELTAT->portstate = 0x00;
+                               }
+                       }
+               } else if( v&0x01 ){
+                       DELTAT->portstate = 0x00;
+               }
+               break;
+       case 0x01:      /* L,R,-,-,SAMPLE,DA/AD,RAMTYPE,ROM */
+               DELTAT->pan = &DELTAT->output_pointer[(v>>6)&0x03];
+               break;
+       case 0x02:      /* Start Address L */
+       case 0x03:      /* Start Address H */
+               DELTAT->start  = (DELTAT->reg[0x3]*0x0100 | DELTAT->reg[0x2]) 
<< DELTAT->portshift;
+                       /*logerror("DELTAT start: 02=%2x 03=%2x 
addr=%8xn",DELTAT->reg[0x2], DELTAT->reg[0x3],DELTAT->start );*/
+               break;
+       case 0x04:      /* Stop Address L */
+       case 0x05:      /* Stop Address H */
+               DELTAT->end    = (DELTAT->reg[0x5]*0x0100 | DELTAT->reg[0x4]) 
<< DELTAT->portshift;
+               DELTAT->end   += (1<<DELTAT->portshift) - 1;
+                       /*logerror("DELTAT end  : 04=%2x 05=%2x 
addr=%8xn",DELTAT->reg[0x4], DELTAT->reg[0x5],DELTAT->end   );*/
+               break;
+       case 0x06:      /* Prescale L (PCM and Recoard frq) */
+       case 0x07:      /* Proscale H */
+       case 0x08:      /* ADPCM data */
+         break;
+       case 0x09:      /* DELTA-N L (ADPCM Playback Prescaler) */
+       case 0x0a:      /* DELTA-N H */
+               DELTAT->delta  = (DELTAT->reg[0xa]*0x0100 | DELTAT->reg[0x9]);
+                       /*logerror("DELTAT deltan:09=%2x 
0a=%2xn",DELTAT->reg[0x9], DELTAT->reg[0xa]);*/
+               DELTAT->step     = (UINT32)( (double)(DELTAT->delta /* 
*(1<<(YM_DELTAT_SHIFT-16)) */ ) * (DELTAT->freqbase) );
+               DELTAT->volume_w_step = (double)DELTAT->volume * DELTAT->step / 
(1<<YM_DELTAT_SHIFT);
+               break;
+       case 0x0b:      /* Level control (volume , voltage flat) */
+               {
+                       INT32 oldvol = DELTAT->volume;
+                       DELTAT->volume = (v&0xff) * (DELTAT->output_range/256) 
/ YM_DELTAT_DECODE_RANGE;
+//                                                             v         *     
        ((1<<16)>>8)            >>      15;
+//                                             thus:   v         *             
(1<<8)                          >>      15;
+//                                             thus: output_range must be (1 
<< (15+8)) at least
+//                                                             v     *         
((1<<23)>>8)            >>      15;
+//                                                             v         *     
        (1<<15)                         >>      15;
+                       /*logerror("DELTAT vol = %2xn",v&0xff);*/
+                       if( oldvol != 0 )
+                       {
+                               DELTAT->adpcml        = 
(int)((double)DELTAT->adpcml        / (double)oldvol * (double)DELTAT->volume);
+                               DELTAT->resample_step = 
(int)((double)DELTAT->resample_step / (double)oldvol * (double)DELTAT->volume);
+                       }
+                       DELTAT->volume_w_step = (double)DELTAT->volume * 
DELTAT->step / (1<<YM_DELTAT_SHIFT);
+               }
+               break;
+       }
+}
+
+void YM_DELTAT_ADPCM_Reset(YM_DELTAT *DELTAT,int pan)
+{
+       DELTAT->now_addr  = 0;
+       DELTAT->now_step  = 0;
+       DELTAT->step      = 0;
+       DELTAT->start     = 0;
+       DELTAT->end       = 0;
+       /* F2610->adpcm[i].delta     = 21866; */
+       DELTAT->volume    = 0;
+       DELTAT->pan       = &DELTAT->output_pointer[pan];
+       /* DELTAT->flagMask  = 0; */
+       DELTAT->acc       = 0;
+       DELTAT->adpcmd    = 127;
+       DELTAT->adpcml    = 0;
+       DELTAT->volume_w_step = 0;
+       DELTAT->next_leveling = 0;
+       DELTAT->portstate = 0;
+       /* DELTAT->portshift = 8; */
+}
+
+void YM_DELTAT_postload(YM_DELTAT *DELTAT,UINT8 *regs)
+{
+       int r;
+
+       /* to keep adpcml and resample_step */
+       DELTAT->volume = 0;
+       /* update */
+       for(r=1;r<16;r++)
+               YM_DELTAT_ADPCM_Write(DELTAT,r,regs[r]);
+       DELTAT->reg[0] = regs[0];
+       /* current rom data */
+       DELTAT->now_data = *(ym_deltat_memory+(DELTAT->now_addr>>1));
+
+}
+
+void YM_DELTAT_savestate(QEMUFile* f, YM_DELTAT *DELTAT)
+{
+       qemu_put_8s(f, &DELTAT->portstate);
+       qemu_put_be32s(f, &DELTAT->now_addr);
+       qemu_put_be32s(f, &DELTAT->now_step);
+       qemu_put_be32s(f, &DELTAT->acc);
+       qemu_put_be32s(f, &DELTAT->adpcmd);
+       qemu_put_be32s(f, &DELTAT->adpcml);
+       qemu_put_be32s(f, &DELTAT->next_leveling);
+       qemu_put_be32s(f, &DELTAT->resample_step);
+}
+
+int YM_DELTAT_loadstate(QEMUFile* f, YM_DELTAT *DELTAT)
+{
+       qemu_get_8s(f, &DELTAT->portstate);
+       qemu_get_be32s(f, &DELTAT->now_addr);
+       qemu_get_be32s(f, &DELTAT->now_step);
+       qemu_get_be32s(f, &DELTAT->acc);
+       qemu_get_be32s(f, &DELTAT->adpcmd);
+       qemu_get_be32s(f, &DELTAT->adpcml);
+       qemu_get_be32s(f, &DELTAT->next_leveling);
+       qemu_get_be32s(f, &DELTAT->resample_step);
+
+       return 0;
+}
+#else /* YM_INLINE_BLOCK */
+
+/* ---------- inline block ---------- */
+
+/* DELTA-T particle adjuster */
+#define YM_DELTAT_DELTA_MAX (24576)
+#define YM_DELTAT_DELTA_MIN (127)
+#define YM_DELTAT_DELTA_DEF (127)
+
+#define YM_DELTAT_DECODE_RANGE 32768
+#define YM_DELTAT_DECODE_MIN (-(YM_DELTAT_DECODE_RANGE))
+#define YM_DELTAT_DECODE_MAX ((YM_DELTAT_DECODE_RANGE)-1)
+
+extern const INT32 ym_deltat_decode_tableB1[];
+extern const INT32 ym_deltat_decode_tableB2[];
+
+#define YM_DELTAT_Limit(val,max,min)   
+{                                                                              
 
+       if ( val > max ) val = max;                     
+       else if ( val < min ) val = min;        
+}
+
+/**** ADPCM B (Delta-T control type) ****/
+INLINE void YM_DELTAT_ADPCM_CALC(YM_DELTAT *DELTAT)
+{
+       UINT32 step;
+       int data;
+       INT32 prev_acc;
+       INT32 now_leveling;
+
+       DELTAT->now_step += DELTAT->step;
+       if ( DELTAT->now_step >= (1<<YM_DELTAT_SHIFT) )
+       {
+               step = DELTAT->now_step >> YM_DELTAT_SHIFT;
+               DELTAT->now_step &= (1<<YM_DELTAT_SHIFT)-1;
+               do{
+                       if ( DELTAT->now_addr == (DELTAT->end<<1) ) {   /* 
12-06-2001 JB: corrected comparison. Was > instead of == */
+                               if( DELTAT->portstate&0x10 ){
+                                       /**** repeat start ****/
+                                       DELTAT->now_addr = DELTAT->start<<1;
+                                       DELTAT->acc      = 0;
+                                       DELTAT->adpcmd   = YM_DELTAT_DELTA_DEF;
+                                       DELTAT->next_leveling = 0;
+                               }else{
+                                       if(DELTAT->arrivedFlagPtr)
+                                               (*DELTAT->arrivedFlagPtr) |= 
DELTAT->flagMask;
+                                       DELTAT->portstate = 0;
+                                       DELTAT->adpcml = 0;
+                                       now_leveling = 0;
+                                       return;
+                               }
+                       }
+                       if( DELTAT->now_addr&1 ) data = DELTAT->now_data & 0x0f;
+                       else
+                       {
+                               DELTAT->now_data = 
*(ym_deltat_memory+(DELTAT->now_addr>>1));
+                               data = DELTAT->now_data >> 4;
+                       }
+
+                       DELTAT->now_addr++;
+                       /* 12-06-2001 JB: */
+                       /* YM2610 address register is 24 bits wide.*/
+                       /* The "+1" is there because we use 1 bit more for 
nibble calculations.*/
+                       /* WARNING: */
+                       /* Side effect: we should take the size of the mapped 
ROM into account */
+                       DELTAT->now_addr &= ( (1<<(24+1))-1);
+
+                       /* store accumulator value */
+                       prev_acc     = DELTAT->acc;
+                       /* Forecast to next Forecast */
+                       DELTAT->acc += (ym_deltat_decode_tableB1[data] * 
DELTAT->adpcmd / 8);
+                       YM_DELTAT_Limit(DELTAT->acc,YM_DELTAT_DECODE_MAX, 
YM_DELTAT_DECODE_MIN);
+                       /* delta to next delta */
+                       DELTAT->adpcmd = (DELTAT->adpcmd * 
ym_deltat_decode_tableB2[data] ) / 64;
+                       YM_DELTAT_Limit(DELTAT->adpcmd,YM_DELTAT_DELTA_MAX, 
YM_DELTAT_DELTA_MIN );
+                       /* calulate new leveling value */
+                       now_leveling      = DELTAT->next_leveling;
+                       DELTAT->next_leveling = prev_acc + ((DELTAT->acc - 
prev_acc) / 2 );
+
+               }while(--step);
+
+/* #define YM_DELTAT_CUT_RE_SAMPLING */
+#ifdef YM_DELTAT_CUT_RE_SAMPLING
+               DELTAT->adpcml  = DELTAT->next_leveling * DELTAT->volume;
+               DELTAT->adpcml  = DELTAT->acc * DELTAT->volume;
+       }
+#else
+               /* delta step of resampling */
+               DELTAT->resample_step = (DELTAT->next_leveling - now_leveling) 
* DELTAT->volume_w_step;
+//             DELTAT->resample_step = (DELTAT->next_leveling - now_leveling) *
+//                                                     ((double)DELTAT->volume 
* DELTAT->step / (1<<YM_DELTAT_SHIFT));
+
+               /* output of start point */
+               DELTAT->adpcml  = now_leveling * DELTAT->volume;
+               /* adjust to now */
+               DELTAT->adpcml += (int)((double)DELTAT->resample_step * 
((double)DELTAT->now_step/(double)DELTAT->step));
+       }
+       DELTAT->adpcml += DELTAT->resample_step;
+#endif
+       /* output for work of output channels (outd[OPNxxxx])*/
+       *(DELTAT->pan) += DELTAT->adpcml;
+}
+
+#endif /* YM_INLINE_BLOCK */
diff --git a/qemu/hw/ymdeltat.h b/qemu/hw/ymdeltat.h
new file mode 100644
index 0000000..9fea8f1
--- /dev/null
+++ b/qemu/hw/ymdeltat.h
@@ -0,0 +1,58 @@
+#ifndef __YMDELTAT_H_
+#define __YMDELTAT_H_
+
+#include "hw.h"
+#include "fm_def.h"
+
+#define YM_DELTAT_SHIFT    (16)
+
+/* adpcm type A and type B struct */
+typedef struct deltat_adpcm_state {
+       UINT8 *memory;
+       int memory_size;
+       double freqbase;
+       INT32 *output_pointer; /* pointer of output pointers */
+       int output_range;
+
+       UINT8 reg[16];                  /* adpcm registers              */
+       UINT8 portstate;                /* port status  : stop==0*/
+       int portshift;                  /* address shift bits   */
+       UINT8 now_data;                 /* current rom data             */
+       UINT32 now_addr;                /* current address              */
+       UINT32 now_step;                /* currect step                 */
+       UINT32 step;                    /* step                                 
*/
+       UINT32 start;                   /* start address                */
+       UINT32 end;                             /* end address                  
*/
+       UINT32 delta;                   /* delta scale                  */
+       INT32 volume;                   /* current volume               */
+       INT32 *pan;                             /* pan : &output_pointer[pan] */
+       INT32 acc;                              /* shift Measurement value */
+       INT32 adpcmd;                   /* next Forecast                */
+       INT32 adpcml;                   /* current value                */
+       /* leveling and re-sampling state for DELTA-T */
+       INT32 volume_w_step;    /* volume with step rate */
+       INT32 next_leveling;    /* leveling value        */
+       INT32 resample_step;    /* step of re-sampling   */
+       /* external flag controll (for YM2610) */
+       UINT8 flagMask;                 /* arrived flag mask    */
+       UINT8 *arrivedFlagPtr;  /* pointer of arrived end address flag */
+}YM_DELTAT;
+
+/* static state */
+extern UINT8 *ym_deltat_memory;       /* memory pointer */
+
+/* before YM_DELTAT_ADPCM_CALC(YM_DELTAT *DELTAT); */
+#define YM_DELTAT_DECODE_PRESET(DELTAT) {ym_deltat_memory = DELTAT->memory;}
+
+void YM_DELTAT_ADPCM_Write(YM_DELTAT *DELTAT,int r,int v);
+void YM_DELTAT_ADPCM_Reset(YM_DELTAT *DELTAT,int pan);
+void YM_DELTAT_postload(YM_DELTAT *DELTAT,UINT8 *regs);
+void YM_DELTAT_savestate(QEMUFile* f, YM_DELTAT *DELTAT);
+int YM_DELTAT_loadstate(QEMUFile* f, YM_DELTAT *DELTAT);
+
+/* INLINE void YM_DELTAT_ADPCM_CALC(YM_DELTAT *DELTAT); */
+#define YM_INLINE_BLOCK
+#include "ymdeltat.c" /* include inline function section */
+#undef  YM_INLINE_BLOCK
+
+#endif
 



Cette partie émule la FM des puces (BUILD_YM2203||BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B)

Voici la source => http://mamedev.org/source/src/emu/sound/fm.c.html

Nb: Même si cela reste assez obscure pour moi, je pense qu'un curieux de passage saura en tirer partie si il le souhaite.



Concernant l'Opération [One Chip Msx] [My Slip Only], un membre dont le pseudo commence par [TheWhip] et finissant par [Master] et dont je garderai l'anonymat, travaille d'arrache pied pour résoudre l'énigme...



Edité par igal Le 13/09/2013 à 10h15

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 29/07/2010

Messages: 1156

Le 13/09/2013 à 13h06
igal :
Voici un extrait du "YAMAHA DELTA-T adpcm sound emulation subroutine" pour MAME v0.59.



+** Base program is YM2610 emulator by Hiromitsu Shioya.

+** Written by Tatsuyuki Satoh

+**

+** History:

+** 05-08-2001 Jarek Burczynski:

+** - now_step is initialized with 0 at the start of play.





Nb: Même si cela reste assez obscure pour moi, je pense qu'un curieux de passage saura en tirer partie si il le souhaite.




si le curieux s'apelle Hiromitsu Shioya, Tatsuyuki Satoh ou encore Jared Burczynski, a la limite, ça peut le faire.

sinon, l'espoir fait vivre... ^^


   

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 29/07/2010

Messages: 4996

Le 13/09/2013 à 18h06
Entièrement d'accord avec toi.

Je retrouve pas l'info mais un/des auteurs de OpenMsx ont contribué à une des version(s) du Driver Msx-Audio Y8950 sur Mame.

En cherchant cette info, je tombe sur ceci concernant l'OPL4:

Code TEXT :
  This software is dual-licensed: it may be used in MAME and properly licensed
   MAME derivatives under the terms of the MAME license.  For use outside of
   MAME and properly licensed derivatives, it is available under the
   terms of the GNU Lesser General Public License (LGPL), version 2.1.
   You may read the LGPL at http://www.gnu.org/licenses/lgpl.html
 
   Changelog:
   Sep. 8, 2002 - fixed ymf278b_compute_rate when octave is negative (RB)
   Dec. 11, 2002 - added ability to set non-standard clock rates (RB)
                   fixed envelope target for release (fixes missing
           instruments in hotdebut).
                   Thanks to Team Japump! for MP3s from a real PCB.
           fixed crash if MAME is run with no sound.
   June 4, 2003 -  Changed to dual-license with LGPL for use in openMSX.
                   openMSX contributed a bugfix where looped samples were
            not being addressed properly, causing pitch fluctuation.
 
   With further improvements over the years by MAME team.
 
   TODO:
   - accurate timing of envelopes
   - LFO (vibrato, tremolo)
   - integrate YMF262 (used by Fuuki games, not used by Psikyo and Metro games)
   - able to hook up "Moonsound", supporting mixed ROM+RAM (for MSX driver in MESS)


On peut tjrs penser au meilleur comme au pire...

Pour le même prix autant être optimiste :top

Conseiller Municipal

rank_5.png

Avatar

Association

Inscrit le: 29/07/2010

Messages: 4996

Le 28/09/2013 à 17h07
A défaut de mettre la main sur le Datasheet, on peut essayer une approche du genre "Reverse engineering" :fou

Faut trouver le moyen de déterminer quel signal va ou. Peut être une solution.


Il y a11 Pin par coté, la No devrait être celle sous le Gros point en Bas relief.
si l'on compte dans le sens inverse des aiguilles d'une montre (comme les CI habituels) on peut dire que:

Les Pin 16, 24 et 26 sont reliés à des pistes beaucoup plus larges que les autres.
On peut penser qu'il s'agit des Voltages et GND.

Pour le reste, Les pins suivantes sont câblées:
8, 14, 15, 16, 18, 21, 24, 25, 26, 32, 35, 36, 37, 38, 40, 43.

Il y a donc 16 Pins connectés.
3 d'entres elles semblent être V/GND.
Il en reste 13.
On sait que les DATAS sont au nombre de 8 qui sont donc à déterminés au milieu des 13.
D0
D1
D2
D3
D4
D5
D6
D7

Une fois les datas identifiés, il restera encore 5 Pins.
sur ces 5 pins, on a certainement:
A0
A1
RD
WR
CS
RST
IRQ

Il y en a 2 de trop ce qui tombe bien puisque je pense que les Pins 1 et 30 sont peut être reliées.

J'essaierai d'affiner à mesure que je trouves des Photos et/ou informations quelconques.

N'hésitez pas si vous avez des bribes d'infos :top







Villageois

rank_3.png

Avatar

Association

Inscrit le: 27/11/2011

Messages: 579

Le 28/09/2013 à 17h16
J aime bien ton idee tordu :tchin
En revanche prend un carte plus simple du genre
http://saved9821.blog.fc2.com/blog-entry-18.html


HB-F700F(X2),A1GT,Altera DE1 + slots , Sunrise IDE CF,FMPAC, Music Module,Slot expander 8X (X3) ,PlaySoniq, et autres
   

Conseiller Municipal

rank_5.png

Avatar

Inscrit le: 27/08/2010

Messages: 1363

Le 28/09/2013 à 17h19
tiens une carte d'extension pour mon cr13 elles ne courent pas les rues celle ci -_-.
Google+    
Répondre
Vous n'êtes pas autorisé à écrire dans cette catégorie
4 Utilisateurs en ligne : 0 Administrateur, 0 Modérateur, 0 Membre et 4 Visiteurs
Utilisateurs en ligne : Aucun membre connecté