home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / pegase_src / inputstreamc.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-08-15  |  13.6 KB  |  395 lines
  1. #ifndef _INPUTSTREAM_CLASS_HPP
  2. #define _INPUTSTREAM_CLASS_HPP
  3.  
  4. /*
  5. **
  6. ** InputStreamC.hpp
  7. **
  8. ** $VER: InputStreamC.hpp 1.0 (12.04.98)
  9. **
  10. ** $Revision: 1.3 $
  11. ** $State: Exp $
  12. ** $Date: 1998/08/16 19:03:38 $
  13. **
  14. ** $Log: InputStreamC.hpp $
  15. ** Revision 1.3  1998/08/16 19:03:38  kakace
  16. ** Version Beta3+
  17. **
  18. ** Revision 1.2  1998/08/02 15:17:04  kakace
  19. ** Fonctionnement OK (Layer 1/2 + Stereo/JStereo)
  20. **
  21. ** Revision 1.1  1998/07/24 14:26:53  kakace
  22. ** Automatic global CheckIn
  23. **
  24. ** Revision 1.19  1998/07/24 14:14:27  kakace
  25. ** Version intermédiaire (CheckIn global)
  26. **
  27. ** Revision 1.17  1998/07/02 15:52:00  kakace
  28. ** Automatic global CheckIn
  29. **
  30. */
  31.  
  32.  
  33. //----------------------------------------------------------------------------------------------------
  34.  
  35. #ifndef  _INCLUDE_STRING_H
  36. #include <string.h>
  37. #endif
  38.  
  39. #ifndef  DOS_DOS_H
  40. #include <dos/dos.h>
  41. #endif
  42.  
  43. #ifndef  _FILEINFOS_CLASS_HPP
  44. #include "FileInfosC.hpp"
  45. #endif
  46.  
  47.  
  48. //----------------------------------------------------------------------------------------------------
  49. //======================================== class InputStream =========================================
  50. //----------------------------------------------------------------------------------------------------
  51. //
  52. //   Cette Classe permet de gérer différents types de fichier en entrée (CDDA, PCM ou AIFF par
  53. // exemple). Chaque objet de ce type contient un tampon d'entrée, ainsi que les fonctions nécessaires
  54. // à la gestion de ce tampon.
  55. // Le tampon d'entrée contient toujours des échantillons sur 16 bits, quelque soit le type de fichier.
  56. //
  57. //   Chaque objet de cette classe contient une référence vers l'objet FileInfos décrivant le fichier.
  58. // Cela permet de centraliser les informations de ce fichier dans une seule structure.
  59.  
  60. const ULONG INPUT_BUFF_SIZE = 2304*96;          // Taille du tampon de lecture.
  61.  
  62.  
  63. // Format des échantillons dans le tampon d'entrée.
  64.  
  65. enum e_AudioFMT {FORMAT_MOTOROLA_MONO = 0,      // bit 0 : 0 = Mono, 1 = Stéréo.
  66.                  FORMAT_MOTOROLA_STEREO,        // bit 1 : 0 = Motorola, 1 = Intel.
  67.                  FORMAT_INTEL_MONO,
  68.                  FORMAT_INTEL_STEREO
  69.                 };
  70.  
  71.  
  72. //----------------------------------------------------------------------------------------------------
  73.  
  74. class InputStreamC
  75. {
  76.     public:
  77.  
  78.         // Constructeur et destructeur.
  79.  
  80.         InputStreamC(FileInfosC &roFileInfos);      // Constructeur.
  81.         ~InputStreamC() {
  82.             if (istr_pBufferAddr) FreeStreamBuffer();
  83.             if (istr_bpOldDirLock || istr_bpFileHandle) this->CloseStream();
  84.         }
  85.  
  86.         // Fonctions d'accès aux membres privés (glues vers l'objet FileInfoC)
  87.  
  88.         ULONG GetSampleFreq()  const {return istr_roFileInfo.GetSampleFreq();}
  89.         UBYTE GetNumChannels() const {return istr_roFileInfo.GetNumChannels();}
  90.         ULONG GetNumFrames()   const {return istr_roFileInfo.GetNumFrames();}
  91.         ULONG GetNumSamples()  const {return istr_roFileInfo.GetNumSamples();}
  92.         LONG  GetIoError()     const {return istr_roFileInfo.GetIoError();}
  93.  
  94.         STRING GetFileName()    const {return istr_roFileInfo.NodeName();}
  95.         STRING GetPathName()    const {return istr_roFileInfo.GetPathName();}
  96.  
  97.         // Fonctions de gestion.
  98.  
  99.         e_AudioFMT GetAudioFormat() const           {return istr_iAudioFormat;}
  100.         void       SetAudioFormat(e_AudioFMT fmt)   {istr_iAudioFormat = fmt;
  101.                                                      istr_roFileInfo.SetByteOrder( (fmt > FORMAT_MOTOROLA_STEREO) ? 1 : 0);}
  102.  
  103.         ULONG     GetProgression() const {return istr_iProgressValue;}
  104.         u_Time    GetTime()        const {return istr_roFileInfo.GetTime();}
  105.  
  106.         e_IoErrors AllocStreamBuffer();         // Allouer le tampon de lecture.
  107.         void       FreeStreamBuffer();          // Libérer le tampon de lecture.
  108.  
  109.         WORD *ReadSamples(UWORD iNumSamples);   // Fonction de lecture des échantillons.
  110.         void  SetRollGap(ULONG iGapSpace)
  111.             {istr_iRollGap = iGapSpace;}
  112.  
  113.         // Fonctions virtuelles.
  114.  
  115.         virtual e_IoErrors OpenStream();        // Ouvrir le fichier.
  116.         virtual void       CloseStream();       // Fermer le fichier.
  117.  
  118.         virtual int  GetFileInfos() = 0;        // Obtenir les informations sur le fichier audio.
  119.         virtual int  OverrideSettings(ULONG iSmplFreq, UBYTE bNumChnl);
  120.  
  121.  
  122.     protected:
  123.  
  124.         // Fonctions virtuelles.
  125.  
  126.         virtual int     SeekToAudio();      // Se positionner au début du chunk audio.
  127.         virtual LONG    FillBuffer();       // Remplir le tampon de lecture.
  128.  
  129.         // Fonctions de gestion privées.
  130.  
  131.         WORD *GetNextBlockAddr(UWORD iNumSamples);
  132.         void  RollBuffer();
  133.  
  134.         // Fonctions de gestions (glues vers les fonctions de l'objet FileInfo)
  135.  
  136.         void SetIoError(e_IoErrors iIOErr, LONG iErr2 = 0) const
  137.             {istr_roFileInfo.SetIoError(iIOErr, iErr2);}
  138.  
  139.         void SetFileType(e_AudioTypes iAT) const {istr_roFileInfo.SetFileType(iAT);}
  140.         void SetNumFrames(ULONG iFrames);
  141.  
  142.         // Informations pour la gestion du tampon de lecture.
  143.  
  144.         WORD     *istr_pBufferAddr;         // Adresse du tampon d'entrée
  145.         WORD     *istr_pCurrentPos;         // Dernier pointeur retourné par ReadSamples().
  146.         WORD     *istr_pUpperLimit;         // Limite supérieure du tampon d'entrée.
  147.         LONG      istr_iSamplesRead;        // Nombre total d'échantillons dans le tampon (sert de compteur)
  148.         BOOL      istr_wEOF;                // TRUE si la fin du fichier a été rencontrée.
  149.         BOOL      istr_wContinue;           // FALSE lorsqu'on doit remplir le tampon pour la première fois.
  150.  
  151.         ULONG     istr_iBufferSize;         // Taille du tampon (en octets).
  152.         ULONG     istr_iRollGap;            // Espace laissé disponible en début de tampon (il est surchargé par une
  153.                                             // copie des dernières données du tampons avant que celui-ci ne soit
  154.                                             // rechargé avec de nouvelles données.
  155.  
  156.         // Variables utilisées pour calculer le taux de progression.
  157.  
  158.         ULONG     istr_iSmplProcessed;      // Nombre d'échantillons déjà traités (progression).
  159.         ULONG     istr_iProgressValue;      // Pourcentage de progression
  160.         ULONG     istr_iNextLimit;          // Prochaine valeur Processed qui causera le recalcul de la progression.
  161.         ULONG     istr_iStepMin;            // Valeur minimale faisant changer le taux de progression.
  162.  
  163.         e_AudioFMT istr_iAudioFormat;       // Format des échantillons dans les tampons audio.
  164.  
  165.         // Informations concernant le fichier.
  166.  
  167.         FileInfosC &istr_roFileInfo;        // Référence sur l'objet décrivant le fichier.
  168.  
  169.         // Informations pour la gestion du fichier.
  170.  
  171.         BPTR      istr_bpOldDirLock;        // Lock sur le répertoire précédent.
  172.         BPTR      istr_bpNewDirLock;        // Lock sur le répertoire courant.
  173.         BPTR      istr_bpFileHandle;        //
  174. };
  175.  
  176.  
  177. //########## Fonctions INLINE ##########
  178.  
  179.  
  180. // Constructeur.
  181.  
  182. inline InputStreamC::InputStreamC(FileInfosC &roFileInfo) : istr_roFileInfo(roFileInfo)
  183. {
  184.     // Initialiser les informations de gestion des tampons.
  185.  
  186.     istr_pBufferAddr = istr_pCurrentPos = NULL;
  187.     istr_iSamplesRead = istr_iProgressValue = 0L;
  188.     istr_iSmplProcessed = 0L;
  189. }
  190.  
  191.  
  192. // Destructeur
  193.  
  194. // inline InputStreamC::~InputStreamC()
  195. // {
  196. //     if (istr_pBufferAddr) FreeStreamBuffer();
  197. //     if (istr_bpOldDirLock || istr_bpFileHandle) this->CloseStream();
  198. // }
  199.  
  200.  
  201. // Définir le nombre de pages, et le nombre d'échantillons.
  202.  
  203. inline void InputStreamC::SetNumFrames(ULONG iFrames)
  204. {
  205.     istr_iNextLimit = istr_iStepMin = iFrames / (100 >> GetNumChannels());
  206.     istr_roFileInfo.SetNumFrames(iFrames);
  207. }
  208.  
  209.  
  210. // Modifier les paramètres du fichier (fréquence d'échantillonage et nombre de canaux).
  211.  
  212. inline int InputStreamC::OverrideSettings(ULONG iSampleFreq, UBYTE bNumChannels)
  213. {
  214.     return FALSE;                               // Interdiction de modifier les paramètres.
  215. }
  216.  
  217. //----------------------------------------------------------------------------------------------------
  218. //=========================================== Classe IFF =============================================
  219. //----------------------------------------------------------------------------------------------------
  220.  
  221. #ifndef  IFF_IFFPARSE_H
  222. #include <libraries/iffparse.h>
  223. #endif
  224.  
  225. #ifndef  CLIB_IFFPARSE_PROTOS_H
  226. #include <clib/iffparse_protos.h>
  227. #endif
  228.  
  229.  
  230. // Classe de base, dérivée pour être spécialisée pour chaque type de fichier IFF.
  231.  
  232. class IFF_AudioC : public InputStreamC
  233. {
  234.     public:
  235.  
  236.         // Fonctions de gestion (virtuelles)
  237.  
  238.         WORD  GetRightSample(UWORD iIndex);     // Lire l'échantillon indiqué (canal droit)
  239.         WORD  GetLeftSample(UWORD iIndex);      // Lire l'échantillon indiqué (canal gauche)
  240.         e_IoErrors OpenStream();                // Ouvrir le fichier.
  241.         void       CloseStream();               // Fermer le fichier.
  242.  
  243.     protected:
  244.  
  245.         // Constructeur.
  246.  
  247.         IFF_AudioC(FileInfosC &roFileInfo) : InputStreamC(roFileInfo) {}
  248.  
  249.         // Fonctions virtuelles
  250.  
  251.         int             SeekToAudio();                  // Se positionner au début du chunk audio.
  252.         LONG            FillBuffer();                   // Remplir le tampon de lecture.
  253.  
  254.         // Fonctions de gestion privées.
  255.  
  256.         StoredProperty *ReadChunks();                   // Lire le chunk indiqué.
  257.         void            CheckAudioChunk(ULONG iOffset); // Contrôler la taille du chunk audio.
  258.  
  259.         // Membres données.
  260.  
  261.         IFFHandle  *istr_pIFF;
  262.  
  263.         LONG  istr_iAudioDataOffset;     // Nombre d'octets à sauter au début du chunk audio.
  264.         ULONG istr_iTypeChunkID;
  265.         ULONG istr_iHeaderChunkID;
  266.         ULONG istr_iDataChunkID;
  267. };
  268.  
  269.  
  270. //----------------------------------------------------------------------------------------------------
  271. //======================================== Classe AIFF_AudioC ========================================
  272. //----------------------------------------------------------------------------------------------------
  273.  
  274. struct AIFF_SSND {ULONG Offset;
  275.                   ULONG BlockSize;
  276.                  };
  277.  
  278.  
  279. class AIFF_AudioC : public IFF_AudioC
  280. {
  281.     public:
  282.  
  283.         // Constructeur.
  284.  
  285.         AIFF_AudioC(FileInfosC &roFileInfo) : IFF_AudioC(roFileInfo)
  286.         {
  287.             istr_iTypeChunkID   = 'AIFF';
  288.             istr_iHeaderChunkID = 'COMM';
  289.             istr_iDataChunkID   = 'SSND';
  290.             istr_iAudioDataOffset = sizeof(struct AIFF_SSND);
  291.         }
  292.  
  293.         // Fonctions virtuelles.
  294.  
  295.         int  GetFileInfos();                 // Obtenir les informations sur le fichier audio.
  296. };
  297.  
  298.  
  299. //----------------------------------------------------------------------------------------------------
  300. //======================================== Classe MAUD_AudioC ========================================
  301. //----------------------------------------------------------------------------------------------------
  302.  
  303. class MAUD_AudioC : public IFF_AudioC
  304. {
  305.     public:
  306.  
  307.         // Constructeur.
  308.  
  309.         MAUD_AudioC(FileInfosC &roFileInfo) : IFF_AudioC(roFileInfo)
  310.         {
  311.             istr_iTypeChunkID   = 'MAUD';
  312.             istr_iHeaderChunkID = 'MHDR';
  313.             istr_iDataChunkID   = 'MDAT';
  314.             istr_iAudioDataOffset = 0;
  315.         }
  316.  
  317.         // Fonctions virtuelles.
  318.  
  319.         int  GetFileInfos();                 // Obtenir les informations sur le fichier audio.
  320. };
  321.  
  322.  
  323. //----------------------------------------------------------------------------------------------------
  324. //========================================== Classe RAW/PCM ==========================================
  325. //----------------------------------------------------------------------------------------------------
  326.  
  327. class RAW_AudioC : public InputStreamC
  328. {
  329.     public:
  330.  
  331.         // Constructeur.
  332.  
  333.         RAW_AudioC(FileInfosC &roFileInfo) : InputStreamC(roFileInfo) {}
  334.  
  335.         // Fonctions de gestion (virtuelles)
  336.  
  337.         int   GetFileInfos();                   // Obtenir les informations sur le fichier audio.
  338.         int   OverrideSettings(ULONG iSampleFreq, UBYTE bNumChannels);
  339. };
  340.  
  341.  
  342. //----------------------------------------------------------------------------------------------------
  343. //========================================= Classe RIFF-WAV ==========================================
  344. //----------------------------------------------------------------------------------------------------
  345.  
  346. class WAV_AudioC : public InputStreamC
  347. {
  348.     public:
  349.  
  350.         // Constructeur.
  351.  
  352.         WAV_AudioC(FileInfosC &roFileInfo) : InputStreamC(roFileInfo) {}
  353.  
  354.         // Fonctions de gestion (virtuelles)
  355.  
  356.         int   GetFileInfos();                   // Obtenir les informations sur le fichier audio.
  357.  
  358.     private:
  359.  
  360.         // Fonctions virtuelles.
  361.  
  362.         int   SeekToAudio();                    // Se positionner au début du chunk audio.
  363.  
  364.         // Fonctions de gestion.
  365.  
  366.         ULONG LocateChunk(ULONG iChunkID);      // Chercher un chunk précis.
  367.  
  368.         ULONG istr_iChannelSize;                // Nombre d'échantillons par canal.
  369. };
  370.  
  371.  
  372. //----------------------------------------------------------------------------------------------------
  373. //=========================================== Classe CDDA ============================================
  374. //----------------------------------------------------------------------------------------------------
  375.  
  376. class CDDA_AudioC : public InputStreamC
  377. {
  378.     public:
  379.  
  380.         // Constructeur.
  381.  
  382.         CDDA_AudioC(FileInfosC &roFileInfo) : InputStreamC(roFileInfo) {}
  383.  
  384.         // Fonctions de gestion (virtuelles)
  385.  
  386.         int  GetFileInfos();                   // Obtenir les informations sur le fichier audio.
  387. //      int  OverrideSettings(ULONG iSampleFreq, UBYTE bNumChannels);
  388. };
  389.  
  390.  
  391. //----------------------------------------------------------------------------------------------------
  392.  
  393. #endif          // _INPUTSTREAM_CLASS_HPP
  394.  
  395.