Initial version of a52towav test viewer plugin for liba52 - output is hardcoded to /ac3test.wav. CUrrently restricted to Stereo AC-3 files, but easy to fix for other types of files (e.g. 5.1)

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@5977 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 455 insertions, 0 deletions

diff --git a/apps/plugins/a52towav.c b/apps/plugins/a52towav.c
new file mode 100644
index 0000000000..17b6c91e51
--- /dev/null
+++ b/apps/plugins/a52towav.c
@@ -0,0 +1,455 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2002 Björn Stenberg
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "plugin.h"
+
+#if (CONFIG_HWCODEC == MASNONE) && !defined(SIMULATOR)
+/* software codec platforms, not for simulator */
+
+#include <inttypes.h>  /* Needed by a52.h */
+
+#include <codecs/liba52/config.h>
+#include <codecs/liba52/a52.h>
+
+/* Currently used for WAV output */
+#ifdef WORDS_BIGENDIAN
+  #warning ************************************* BIG ENDIAN
+  #define LE_S16(x) ( (uint16_t) ( ((uint16_t)(x) >> 8) | ((uint16_t)(x) << 8) ) )
+#else
+  #define LE_S16(x) (x)
+#endif
+
+typedef struct ao_sample_format {
+        int bits; /* bits per sample */
+        int rate; /* samples per second (in a single channel) */
+        int channels; /* number of audio channels */
+        int byte_format; /* Byte ordering in sample, see constants below */
+} ao_sample_format;
+
+#define AO_FMT_LITTLE 1
+#define AO_FMT_BIG    2
+#define AO_FMT_NATIVE 4
+
+/* the main data structure of the program */
+typedef struct {
+    int infile;
+    int outfile;
+    off_t curpos;
+    off_t filesize;
+    ao_sample_format samfmt; /* bits, rate, channels, byte_format */
+  //    ao_device *ao_dev;
+    unsigned long total_samples;
+    unsigned long current_sample;
+    float total_time;        /* seconds */
+    float elapsed_time;      /* seconds */
+} file_info_struct;
+
+file_info_struct file_info;
+
+#define MALLOC_BUFSIZE (512*1024)
+
+int mem_ptr;
+int bufsize;
+unsigned char* mp3buf;     // The actual MP3 buffer from Rockbox
+unsigned char* mallocbuf;  // 512K from the start of MP3 buffer
+unsigned char* filebuf;    // The rest of the MP3 buffer
+
+
+
+#define BUFFER_SIZE 4096
+//static uint8_t buffer[BUFFER_SIZE];
+static float gain = 1;
+static a52_state_t * state;
+
+int output;
+
+// DAVE: I'm not sure what these are for.
+int disable_accel=0;
+int disable_adjust=0;
+int disable_dynrng=0;
+
+/* welcome to the example rockbox plugin */
+
+/* here is a global api struct pointer. while not strictly necessary,
+   it's nice not to have to pass the api pointer in all function calls
+   in the plugin */
+static struct plugin_api* rb;
+
+void* malloc(size_t size) {
+  void* x;
+  char s[32];
+
+  x=&mallocbuf[mem_ptr];
+  mem_ptr+=size+(size%4); // Keep memory 32-bit aligned (if it was already?)
+
+  rb->snprintf(s,30,"Memory used: %d\r",mem_ptr);
+  rb->lcd_putsxy(0,80,s);
+  rb->lcd_update();
+  return(x);
+}
+
+void* calloc(size_t nmemb, size_t size) {
+  void* x;
+  x=malloc(nmemb*size);
+  rb->memset(x,0,nmemb*size);
+  return(x);
+}
+
+void free(void* ptr) {
+  (void)ptr;
+}
+
+void* realloc(void* ptr, size_t size) {
+  void* x;
+  (void)ptr;
+  x=malloc(size);
+  return(x);
+}
+
+void *memcpy(void *dest, const void *src, size_t n) {
+  return(rb->memcpy(dest,src,n));
+}
+
+void *memset(void *s, int c, size_t n) {
+  return(rb->memset(s,c,n));
+}
+
+int memcmp(const void *s1, const void *s2, size_t n) {
+  return(rb->memcmp(s1,s2,n));
+}
+
+void* memmove(const void *s1, const void *s2, size_t n) {
+  char* dest=(char*)s1;
+  char* src=(char*)s2;
+  size_t i;
+
+  for (i=0;i<n;i++) { dest[i]=src[i]; }
+  //  while(n>0) { *(dest++)=*(src++); n--; }
+  return(dest);
+}
+
+void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)) {
+  rb->qsort(base,nmemb,size,compar);
+}
+
+
+
+
+static unsigned char wav_header[44]={'R','I','F','F',    //  0 - ChunkID
+                              0,0,0,0,            //  4 - ChunkSize (filesize-8)
+                              'W','A','V','E',    //  8 - Format
+                              'f','m','t',' ',    // 12 - SubChunkID
+                              16,0,0,0,           // 16 - SubChunk1ID  // 16 for PCM
+                              1,0,                // 20 - AudioFormat (1=16-bit)
+                              2,0,                // 22 - NumChannels
+                              0,0,0,0,            // 24 - SampleRate in Hz
+                              0,0,0,0,            // 28 - Byte Rate (SampleRate*NumChannels*(BitsPerSample/8)
+                              4,0,                // 32 - BlockAlign (== NumChannels * BitsPerSample/8)
+                              16,0,               // 34 - BitsPerSample
+                              'd','a','t','a',    // 36 - Subchunk2ID
+                              0,0,0,0             // 40 - Subchunk2Size
+                             };
+
+void close_wav(file_info_struct* file_info) {
+  int x;
+  int filesize=rb->filesize(file_info->outfile);
+
+  /* We assume 16-bit, Stereo */
+
+  rb->lseek(file_info->outfile,0,SEEK_SET);
+
+  // ChunkSize
+  x=filesize-8;
+  wav_header[4]=(x&0xff);
+  wav_header[5]=(x&0xff00)>>8;
+  wav_header[6]=(x&0xff0000)>>16;
+  wav_header[7]=(x&0xff000000)>>24;
+
+  // Samplerate
+  wav_header[24]=file_info->samfmt.rate&0xff;
+  wav_header[25]=(file_info->samfmt.rate&0xff00)>>8;
+  wav_header[26]=(file_info->samfmt.rate&0xff0000)>>16;
+  wav_header[27]=(file_info->samfmt.rate&0xff000000)>>24;
+
+  // ByteRate
+  x=file_info->samfmt.rate*4;
+  wav_header[28]=(x&0xff);
+  wav_header[29]=(x&0xff00)>>8;
+  wav_header[30]=(x&0xff0000)>>16;
+  wav_header[31]=(x&0xff000000)>>24;
+  
+  // Subchunk2Size
+  x=filesize-44;
+  wav_header[40]=(x&0xff);
+  wav_header[41]=(x&0xff00)>>8;
+  wav_header[42]=(x&0xff0000)>>16;
+  wav_header[43]=(x&0xff000000)>>24;
+
+  rb->write(file_info->outfile,wav_header,sizeof(wav_header));
+  rb->close(file_info->outfile);
+}
+
+static inline int16_t convert (int32_t i)
+{
+    i >>= 15;
+    return (i > 32767) ? 32767 : ((i < -32768) ? -32768 : i);
+}
+
+void convert2s16_2 (sample_t * _f, int16_t * s16)
+{
+    int i;
+    int32_t * f = (int32_t *) _f;
+    for (i = 0; i < 256; i++) {
+        s16[2*i] = LE_S16(convert (f[i]));
+        s16[2*i+1] = LE_S16(convert (f[i+256]));
+    }
+}
+
+void ao_play(file_info_struct* file_info,sample_t* samples,int flags) {
+  int i;
+  static int16_t int16_samples[256*2];
+
+  flags &= A52_CHANNEL_MASK | A52_LFE;
+
+  if (flags==A52_STEREO) {
+//    convert2s16_2(samples,int16_samples,flags);
+    for (i = 0; i < 256; i++) {
+        int16_samples[2*i] = LE_S16(convert (samples[i]));
+        int16_samples[2*i+1] = LE_S16(convert (samples[i+256]));
+    }
+  } else {
+#ifdef SIMULATOR
+    fprintf(stderr,"ERROR: unsupported format: %d\n",flags);
+#endif
+  }
+
+  i=rb->write(file_info->outfile,int16_samples,256*2*2);
+
+#ifdef SIMULATOR
+  if (i!=(256*2*2)) {
+    fprintf(stderr,"Attempted to write %d bytes, wrote %d bytes\n",256*2*2,i);
+  }
+#endif
+}
+
+
+void a52_decode_data (file_info_struct* file_info, uint8_t * start, uint8_t * end)
+{
+    static uint8_t buf[3840];
+    static uint8_t * bufptr = buf;
+    static uint8_t * bufpos = buf + 7;
+
+    /*
+     * sample_rate and flags are static because this routine could
+     * exit between the a52_syncinfo() and the ao_setup(), and we want
+     * to have the same values when we get back !
+     */
+
+    static int sample_rate;
+    static int flags;
+    int bit_rate;
+    int len;
+
+    while (1) {
+	len = end - start;
+	if (!len)
+	    break;
+	if (len > bufpos - bufptr)
+	    len = bufpos - bufptr;
+	memcpy (bufptr, start, len);
+	bufptr += len;
+	start += len;
+	if (bufptr == bufpos) {
+	    if (bufpos == buf + 7) {
+		int length;
+
+		length = a52_syncinfo (buf, &flags, &sample_rate, &bit_rate);
+		if (!length) {
+#ifdef SIMULATOR
+		    fprintf (stderr, "skip\n");
+#endif
+		    for (bufptr = buf; bufptr < buf + 6; bufptr++)
+			bufptr[0] = bufptr[1];
+		    continue;
+		}
+		bufpos = buf + length;
+	    } else {
+                // The following two defaults are taken from audio_out_oss.c:
+		level_t level;
+		sample_t bias;
+		int i;
+
+                /* This is the configuration for the downmixing: */
+                flags=A52_STEREO|A52_ADJUST_LEVEL|A52_LFE;
+                level=(1 << 26);
+                bias=0;
+
+		level = (level_t) (level * gain);
+
+		if (a52_frame (state, buf, &flags, &level, bias))
+		    goto error;
+
+                if (output==0) {
+                  file_info->samfmt.bits=16;
+                  file_info->samfmt.rate=sample_rate;
+                  output=1;
+//                  output=ao_open(&format);
+                }
+
+                // An A52 frame consists of 6 blocks of 256 samples
+                // So we decode and output them one block at a time
+		for (i = 0; i < 6; i++) {
+		    if (a52_block (state)) {
+			goto error;
+                    }
+		    ao_play (file_info, a52_samples (state),flags);
+                    file_info->current_sample+=256;
+		}
+		bufptr = buf;
+		bufpos = buf + 7;
+//		print_fps (0);
+		continue;
+	    error:
+#ifdef SIMULATOR
+		fprintf (stderr, "error\n");
+#endif
+		bufptr = buf;
+		bufpos = buf + 7;
+	    }
+	}
+    }
+}
+
+/* this is the plugin entry point */
+enum plugin_status plugin_start(struct plugin_api* api, void* file)
+{
+  int i,n,bytesleft;
+  char s[32];
+  unsigned long ticks_taken;
+  unsigned long start_tick;
+  unsigned long long speed;
+  unsigned long xspeed;
+  int accel=0;  // ??? This is the parameter to a52_init().
+
+  /* this macro should be called as the first thing you do in the plugin.
+     it test that the api version and model the plugin was compiled for
+     matches the machine it is running on */
+  TEST_PLUGIN_API(api);
+
+  /* if you are using a global api pointer, don't forget to copy it!
+     otherwise you will get lovely "I04: IllInstr" errors... :-) */
+  rb = api;
+
+  /* now go ahead and have fun! */
+  //    rb->splash(HZ*2, true, "Hello world!");
+
+  mem_ptr=0;
+  mp3buf=rb->plugin_get_mp3_buffer(&bufsize);
+  mallocbuf=mp3buf;
+  filebuf=&mp3buf[MALLOC_BUFSIZE];
+
+  rb->snprintf(s,32,"mp3 bufsize: %d\r",bufsize);
+  rb->lcd_putsxy(0,100,s);
+  rb->lcd_update();
+
+  file_info.infile=rb->open(file,O_RDONLY);
+  file_info.outfile=rb->creat("/ac3test.wav",O_WRONLY);
+  rb->write(file_info.outfile,wav_header,sizeof(wav_header));
+  file_info.curpos=0;
+  file_info.filesize=rb->filesize(file_info.infile);
+
+  if (file_info.filesize > (bufsize-MALLOC_BUFSIZE)) {
+    rb->close(file_info.infile);
+    rb->splash(HZ*2, true, "File too large");
+    return PLUGIN_ERROR;
+  }
+
+  rb->snprintf(s,32,"Loading file...");
+  rb->lcd_putsxy(0,0,s);
+  rb->lcd_update();
+
+  bytesleft=file_info.filesize;
+  i=0;
+  while (bytesleft > 0) {
+    n=rb->read(file_info.infile,&filebuf[i],bytesleft);
+    if (n < 0) {
+      rb->close(file_info.infile);
+      rb->splash(HZ*2, true, "ERROR READING FILE");
+      return PLUGIN_ERROR;
+    }      
+    i+=n; bytesleft-=n;
+  }
+  rb->close(file_info.infile);
+
+  state = a52_init (accel);
+  if (state == NULL) {
+    //fprintf (stderr, "A52 init failed\n");
+    return PLUGIN_ERROR;
+  }
+
+  i=0;
+  start_tick=*(rb->current_tick);
+  while (file_info.curpos < file_info.filesize) {
+    i++;
+    if ((file_info.curpos+BUFFER_SIZE) < file_info.filesize) {   
+      a52_decode_data (&file_info,&filebuf[file_info.curpos],&filebuf[file_info.curpos+BUFFER_SIZE]);
+      file_info.curpos+=BUFFER_SIZE;
+    } else {
+      a52_decode_data (&file_info,&filebuf[file_info.curpos],&filebuf[file_info.filesize-1]);
+      file_info.curpos=file_info.filesize;
+    }
+
+    rb->snprintf(s,32,"Bytes read: %d\r",file_info.curpos);
+    rb->lcd_putsxy(0,0,s);
+    rb->snprintf(s,32,"Samples Decoded: %d\r",file_info.current_sample);
+    rb->lcd_putsxy(0,20,s);
+    rb->snprintf(s,32,"Frames Decoded: %d\r",i);
+    rb->lcd_putsxy(0,40,s);
+
+    ticks_taken=*(rb->current_tick)-start_tick;
+
+    /* e.g.:
+    ticks_taken=500
+    sam_fmt.rate=44,100
+    samples_decoded=172,400
+    (samples_decoded/sam_fmt.rate)*100=400 (time it should have taken)
+    % Speed=(400/500)*100=80%
+
+    */
+
+    if (ticks_taken==0) { ticks_taken=1; } // Avoid fp exception.
+
+    speed=(100*file_info.current_sample)/file_info.samfmt.rate;
+    xspeed=(speed*10000)/ticks_taken;
+    rb->snprintf(s,32,"Speed %ld.%02ld %% Secs: %d",(xspeed/100),(xspeed%100),ticks_taken/100); 
+    rb->lcd_putsxy(0,60,s);
+
+    rb->lcd_update();
+    if (rb->button_get(false)!=BUTTON_NONE) {
+      close_wav(&file_info);
+      return PLUGIN_OK;
+    }
+  }
+  close_wav(&file_info);
+
+//NO NEED:  a52_free (state);
+  rb->splash(HZ*2, true, "FINISHED!");
+  return PLUGIN_OK;
+}
+#endif /* CONFIG_HWCODEC == MASNONE */