#include <proto/multimedia.h>
#include <proto/exec.h>
#include <proto/intuition.h>
#include <clib/alib_protos.h>

struct Library* MultimediaBase;

if (MultimediaBase = OpenLibrary("multimedia/multimedia.class", 52))
{
/* Maintenant Reggae est prêt à être utilisé jusqu'à ce que la bibliothèque soit fermée. */
  CloseLibrary(MultimediaBase);
}

struct Library *HttpStreamBase;

HttpStreamBase = OpenLibrary("multimedia/http.stream", 51);

CloseLibrary(HttpStreamBase);

LONG error;

GetAttr(object, MMA_ErrorCode, (ULONG)&error);

error = MediaGetPort(object, 0, MMA_ErrorCode);

Object *obj;
LONG error = 0; /* initialisation est recommandée */

if (obj = MediaNewObjectTags( /* n'importe quelle balise ici */ , MMA_ErrorCode, (IPTR)&error, TAG_END))
{
 /* use object */
}
else
{
 /* le code d'erreur se trouve dans la variable 'error',
    il faut prendre des mesures, informer l'utilisateur, etc. */
}

if ((pulled = DoMethod(MMM_Pull, object, port, buffer, length)) == length)
{
 /* L'extraction des données a réussi. */
}
else
{
 LONG error = 0;

 GetAttr(objet, MMA_ErrorCode, (IPTR)&error);

 /* L'extraction des données a échoué, mais certaines données peuvent être valides (le nombre d'octets
    de données valides est stocké dans 'pulled'). Le code d'erreur est dans 'error'.*/
}

LONG error;

GetAttr(object, MMA_ErrorCode, (IPTR)&error);

if (error) Printf("Operation failed: %s.\n", MediaFault(error));

#define DATA_LENGTH 7465 /* juste une valeur d'exemple */

UBYTE buffer[DATA_LENGTH]; /* place pour les données */
Object *http;

http = NewObject(NULL, "http.stream", MMA_StreamName, "www.morphzone.org", TAG_END);
DoMethod(http, MMM_Pull, 0, buffer, DATA_LENGTH);
DisposeObject(http);

QUAD length;

length = MediaGetPort64(http, 0, MMA_StreamLength);

LONG chunk, error = 0;

while (!error)
{
  chunk = DoMethod(http, MMM_Pull, 0, buffer, BUFFER_SIZE);

  /* Faire quelque chose avec les octets de données de 'chunk' dans 'buffer'. */

  if (chunk < BUFFER_SIZE)
  {
    if (MediaGetPort(http, 0, MMA_ErrorCode) == MMERR_END_OF_DATA))
    {
      break; /* téléchargement terminé */
    }
    else
    {
      error = 1; /* le téléchargement a échoué */
    }
  }
}

Object *pub, *priv;

priv = NewObject(PrivClassPointer, NULL, /* tags */, TAG_END);
pub = NewObject(NULL, "public.class", /* tags */, TAG_END);

Object* media;

media = MediaNewObject(
  MMA_StreamType, (ULONG)"file.stream",
  MMA_StreamName, (ULONG)"RAM:sound",
  MMA_MediaType, MMT_SOUND,
TAG_END);

struct Library* AudioOutputBase;

AudioOutputBase = OpenLibrary("multimedia/audio.output", 51);

Objet* play;

play = NewObject(NULL, "audio.output", TAG_END);

MediaConnectTagList(media, 0, play, 0, NULL);

DoMethod(play, MMM_Play);

DoMethod(play, MMM_Stop);

DoMethod(play, MMM_SignalAtEnd, FindTask(NULL), SIGBREAKB_CTRL_C);
DoMethod(play, MMM_Play);
Wait(SIGBREAKF_CTRL_C);

struct MsgPort *port; /* créé ailleurs */
struct Message *msg; /* alloué ailleurs */

msg->mn_Node.ln_Type = NT_MESSAGE;
msg->mn_Length = sizeof(struct Message);
msg->mn_ReplyPort = port;

DoMethod(play, MMM_Sound_ReplyMsgAtEnd, msg);
DoMethod(play, MMM_Play);
WaitPort(port);
GetMsg(port);

BPTR handle;
LONG size;
APTR buffer;
struct FileInfoBlock *fib;

if (fib = AllocDosObject(DOS_FIB, NULL))
{
  if (handle = Open("PROGDIR:sounds/anysound.wav", MODE_OLDFILE))
  {
    if (ExamineFH(handle, fib))
    {
      size = fib->fib_Size;

      if (buffer = AllocVecTaskPooled(size))
      {
        if (Read(handle, buffer, size) == size)
        {
          /* use buffer as memory.stream data here */
        }
        FreeVecTaskPooled(buffer);
      }
    }
    Close(handle);
  }
  FreeDosObject(DOS_FIB, fib);
}

CONST UBYTE SoundData [12837] = { /* ce sont les déonnées audio */ }; /* La longueur est donnée à titre d'exemple. */
QUAD length = 12837;
Object *sound;

sound = MediaNewObject(
  MMA_StreamType, "memory.stream",
  MMA_StreamHandle, SoundData,
  MMA_StreamLength, &length,
TAG_END);

Object *rawaudio;

rawaudio = NewObject(NULL, "rawaudio.filter",
  MMA_Sound_Channels, 1,
  MMA_Sound_SampleRate, 44100,
  MMA_Sound_Volume, 65536,
TAG_END);

MediaSetPort(rawaudio, 1, MMA_Port_Format, MMFC_AUDIO_INT16);

WORD *Buffer;

Buffer = (WORD*)MediaAllocVec(88200);

LONG i;

for (i = 0; i < 44100; i++) Buffer[i] = (WORD)(sin(2000 * M_PI * i / 44100) * 32767.0);

Object *FormatSelector;

FormatSelector = MediaGetGuiTags(
  MGG_Type, MGG_Type_Muxers,
  MGG_Media, MMT_SOUND,
  MGG_Selector, MGG_Selector_List,
  MUIA_Frame, MUIV_Frame_Group,
  MUIA_Background, MUII_GroupBack,
TAG_END);

Object *stream;
QUAD stream_length = 88200;

stream = NewObject(NULL, "memory.stream",
  MMA_Stream_Handle, (IPTR)Buffer,
  MMA_Stream_Length, (IPTR)&stream_length,
TAG_END);

Object *raw_audio;

raw_audio = NewObject(NULL, "rawaudio.filter",
 MMA_Sound_Channels, 1,
 MMA_Sound_SampleRate, 44100,
TAG_END);

MediaSetPort(raw_audio, 1, MMA_Port_Format, MMFC_AUDIO_INT16);

MediaConnectTagList(stream, 0, raw_audio, 0, NULL);

Object *codec;

codec = MediaBuildFromGuiTags(format_selector, raw_audio, 1, TAG_END);

Object *writer;

writer = NewObject(NULL, "file.output",
  MMA_StreamName, (IPTR)"somefile",
TAG_END);

MediaConnectTagList(codec, 1, writer, 0, NULL);

DoMethod(writer, MMM_SignalAtEnd, (IPTR)FindTask(NULL), SIGBREAKB_CTRL_C);
DoMethod(writer, MMM_Play);
Wait(SIGBREAKF_CTRL_C);

DisposeObject(writer);
DisposeObject(codec);
DisposeObject(raw_audio);
DisposeObject(stream);

WAVE BITS=24

AIFF

Zgrzytor 3 11 22050 somenoise.wav WAVE BITS=32