come riprodurre blocchi di byte mp3 dal server sql, trasferiti al client desktop (tramite wcf) usando C#?

Question

Ho "chunks" di audio (in formato mp3) su un cioè sql database, è possibile immaginare un file mp3, diviso alla parità di dimensioni di pezzi e ogni blocco viene salvata su un disco su un db sql server. questi chunks vengono restituiti ai client desktop tramite un servizio WCF. ovviamente il cliente chiede il prossimo pezzo quando ne riceve uno (saranno ricevuti in ordine, quindi l'intestazione viene prima!) ecco la domanda, come posso riprodurre questo ricevuto nella mia app desktop uno per uno in sequent? posso riprodurli di nuovo usando ciascun blocco per bufferizzare il lettore?

noti prego: -la client desktop è in C# -Il giocatore può essere WMP se funziona per questo scopo! -chunks vengono salvati in byte -per alcune ragioni il sistema "pezzo su SQL" è già in atto da qualcuno else..i solo bisogno di trovare un modo per giocare loro come un ruscello sul desktop

grazie!

Answer 1

Supponendo che si disponga di un metodo per ordinarli correttamente nel database quando l'utente li richiede, la suddivisione è abbastanza semplice. In pseudo codice

1. utente richiede mp3
2. fare:
3. controllo e inviare al cliente i pezzi disponibili
4. se ci sono pezzi da giocare, loro (aggiungerli al flusso) giocare in nell'ordine definito
5. mentre: piè non è stato rilevato nei blocchi // fine fare

essenzialmente, invia i blocchi come disponibili per l'utente fino alla f ooter si incontra, giocando i blocchi come se fossero completi.

Answer 2

Assumendo che il lettore mp3 può giocare da un oggetto System.IO.Stream, implementare la propria classe di flusso con la seguente

private byte[] GetDataBlock() 
    { 
     while (data.Count == 0) 
     { 
      //TODO: Read More Data from the database 
      index = 0; 
     } 
     return data.Peek(); 
    } 
    private void RemoveDataBlock() 
    { 
     data.Dequeue(); 
     index = 0; 
    } 

    Queue<byte[]> data = new Queue<byte[]>(); 
    int index = 0; 
    public override int Read(byte[] buffer, int offset, int count) 
    {    
     int left = count; 
     int dstIndex = 0; 

     while (left > 0) 
     { 
      byte[] front = GetDataBlock(); 

      int available = front.Length - index; 
      // how much from the current block can we copy? 
      int length = (available <= left) ? available : left; 
      Array.Copy(front, index, buffer, dstIndex, length); 
      dstIndex += length; 
      left -= length; 
      index += length; 
      // read all the bytes in the array? 
      if (length == available) 
      { 
       RemoveDataBlock(); 
      } 
     } 

     return count; 
    } 

Quello che fa è posto i blocchi di dati in una coda. Il metodo di lettura li legge nell'ordine in cui sono stati aggiunti.

Questo codice legge solo 1 blocco alla volta, ma può essere espanso per essere letto su un thread separato e bufferizzare un numero di blocchi.