apps/codecs/libpcm/dvi_adpcm.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Dave Chapman
  11  * Copyright (C) 2009 Yoshihisa Uchida
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include "codeclib.h"
  23 #include "ima_adpcm_common.h"
  24 #include "support_formats.h"
  25
  26 /*
  27  * Intel DVI ADPCM (IMA ADPCM)
  28  *
  29  * References
  30  * [1] The IMA Digital Audio Focus and Technical Working Groups,
  31  *     Recommended Practices for Enhancing Digital Audio Compatibility
  32  *     in Multimedia Systems Revision 3.00, 1992
  33  * [2] Microsoft Corporation, New Multimedia Data Types and Data Techniques,
  34  *     Revision:3.0, 1994
  35  * [3] ffmpeg source code, libavcodec/adpcm.c
  36  */
  37
  38 static struct pcm_format *fmt;
  39
  40 static bool set_format(struct pcm_format *format)
  41 {
  42     fmt = format;
  43
  44     if (fmt->bitspersample < 2 || fmt->bitspersample > 5)
  45     {
  46         DEBUGF("CODEC_ERROR: dvi adpcm must be 2, 3, 4 or 5 bitspersample: %d\n",
  47                              fmt->bitspersample);
  48         return false;
  49     }
  50
  51     fmt->chunksize = fmt->blockalign;
  52
  53     init_ima_adpcm_decoder(fmt->bitspersample, NULL);
  54     return true;
  55 }
  56
  57 static struct pcm_pos *get_seek_pos(long seek_time,
  58                                     uint8_t *(*read_buffer)(size_t *realsize))
  59 {
  60     static struct pcm_pos newpos;
  61     uint32_t newblock = ((uint64_t)seek_time * ci->id3->frequency)
  62                                              / (1000LL * fmt->samplesperblock);
  63
  64     (void)read_buffer;
  65     newpos.pos     = newblock * fmt->blockalign;
  66     newpos.samples = newblock * fmt->samplesperblock;
  67     return &newpos;
  68 }
  69
  70 static inline void decode_2bit(const uint8_t **inbuf, size_t inbufsize,
  71                                int32_t **outbuf, int *outbufcount)
  72 {
  73     int ch;
  74     int i;
  75     int32_t *pcmbuf;
  76     int samples;
  77
  78     samples = inbufsize / (4 * fmt->channels) - 1;
  79     *outbufcount += (samples << 4);
  80     while (samples-- > 0)
  81     {
  82         for (ch = 0; ch < fmt->channels; ch++)
  83         {
  84             pcmbuf = *outbuf + ch;
  85             for (i = 0; i < 4; i++)
  86             {
  87                 *pcmbuf = create_pcmdata(ch, **inbuf     ) << IMA_ADPCM_INC_DEPTH;
  88                 pcmbuf += fmt->channels;
  89                 *pcmbuf = create_pcmdata(ch, **inbuf >> 2) << IMA_ADPCM_INC_DEPTH;
  90                 pcmbuf += fmt->channels;
  91                 *pcmbuf = create_pcmdata(ch, **inbuf >> 4) << IMA_ADPCM_INC_DEPTH;
  92                 pcmbuf += fmt->channels;
  93                 *pcmbuf = create_pcmdata(ch, **inbuf >> 6) << IMA_ADPCM_INC_DEPTH;
  94                 pcmbuf += fmt->channels;
  95                 (*inbuf)++;
  96             }
  97         }
  98         *outbuf += 16 * fmt->channels;
  99     }
 100 }
 101
 102 static inline void decode_3bit(const uint8_t **inbuf, size_t inbufsize,
 103                                int32_t **outbuf, int *outbufcount)
 104 {
 105     const uint8_t *adpcmbuf;
 106     uint32_t adpcms;
 107     int ch;
 108     int i;
 109     int32_t *pcmbuf;
 110     int samples;
 111
 112     samples = (inbufsize - 4 * fmt->channels) / (12 * fmt->channels);
 113     *outbufcount += (samples << 5);
 114     while (samples--)
 115     {
 116         for (ch = 0; ch < fmt->channels; ch++)
 117         {
 118             adpcmbuf = *inbuf + ch * 4;
 119             pcmbuf = *outbuf + ch;
 120             adpcms = *adpcmbuf++;
 121             adpcms |= (*adpcmbuf++) << 8;
 122             adpcms |= (*adpcmbuf++) << 16;
 123             for (i = 0; i < 8; i++)
 124             {
 125                 *pcmbuf = create_pcmdata(ch, adpcms >> (3 * i)) << IMA_ADPCM_INC_DEPTH;
 126                 pcmbuf += fmt->channels;
 127             }
 128             adpcms = *adpcmbuf++;
 129             adpcmbuf += (fmt->channels - 1) * 4;
 130             adpcms |= (*adpcmbuf++) << 8;
 131             adpcms |= (*adpcmbuf++) << 16;
 132             for (i = 0; i < 8; i++)
 133             {
 134                 *pcmbuf = create_pcmdata(ch, adpcms >> (3 * i)) << IMA_ADPCM_INC_DEPTH;
 135                 pcmbuf += fmt->channels;
 136             }
 137             adpcms = *adpcmbuf++;
 138             adpcms |= (*adpcmbuf++) << 8;
 139             adpcmbuf += (fmt->channels - 1) * 4;
 140             adpcms |= (*adpcmbuf++) << 16;
 141             for (i = 0; i < 8; i++)
 142             {
 143                 *pcmbuf = create_pcmdata(ch, adpcms >> (3 * i)) << IMA_ADPCM_INC_DEPTH;
 144                 pcmbuf += fmt->channels;
 145             }
 146             adpcms = *adpcmbuf++;
 147             adpcms |= (*adpcmbuf++) << 8;
 148             adpcms |= (*adpcmbuf++) << 16;
 149             for (i = 0; i < 8; i++)
 150             {
 151                 *pcmbuf = create_pcmdata(ch, adpcms >> (3 * i)) << IMA_ADPCM_INC_DEPTH;
 152                 pcmbuf += fmt->channels;
 153             }
 154         }
 155         *outbuf += 32 * fmt->channels;
 156         *inbuf += 12 * fmt->channels;
 157     }
 158 }
 159
 160 static inline void decode_4bit(const uint8_t **inbuf, size_t inbufsize,
 161                                int32_t **outbuf, int *outbufcount)
 162 {
 163     int ch;
 164     int i;
 165     int32_t *pcmbuf;
 166     int samples;
 167
 168     samples = inbufsize / (4 * fmt->channels) - 1;
 169     *outbufcount += (samples << 3);
 170     while (samples-- > 0)
 171     {
 172         for (ch = 0; ch < fmt->channels; ch++)
 173         {
 174             pcmbuf = *outbuf + ch;
 175             for (i = 0; i < 4; i++)
 176             {
 177                 *pcmbuf = create_pcmdata_size4(ch, **inbuf     ) << IMA_ADPCM_INC_DEPTH;
 178                 pcmbuf += fmt->channels;
 179                 *pcmbuf = create_pcmdata_size4(ch, **inbuf >> 4) << IMA_ADPCM_INC_DEPTH;
 180                 pcmbuf += fmt->channels;
 181                 (*inbuf)++;
 182             }
 183         }
 184         *outbuf += 8 * fmt->channels;
 185     }
 186 }
 187
 188 static inline void decode_5bit(const uint8_t **inbuf, size_t inbufsize,
 189                                int32_t **outbuf, int *outbufcount)
 190 {
 191     const uint8_t *adpcmbuf;
 192     uint64_t adpcms;
 193     int ch;
 194     int i;
 195     int32_t *pcmbuf;
 196     int samples;
 197
 198     samples = (inbufsize - 4 * fmt->channels) / (20 * fmt->channels);
 199     *outbufcount += (samples << 5);
 200     while (samples--)
 201     {
 202         for (ch = 0; ch < fmt->channels; ch++)
 203         {
 204             adpcmbuf = *inbuf + ch * 4;
 205             pcmbuf = *outbuf + ch;
 206             adpcms = *adpcmbuf++;
 207             adpcms |= (*adpcmbuf++) << 8;
 208             adpcms |= (*adpcmbuf++) << 16;
 209             adpcms |= (uint64_t)(*adpcmbuf++) << 24;
 210             adpcmbuf += (fmt->channels - 1) * 4;
 211             adpcms |= (uint64_t)(*adpcmbuf++) << 32;
 212             for (i = 0; i < 8; i++)
 213             {
 214                 *pcmbuf = create_pcmdata(ch, adpcms >> (5 * i)) << IMA_ADPCM_INC_DEPTH;
 215                 pcmbuf += fmt->channels;
 216             }
 217             adpcms = *adpcmbuf++;
 218             adpcms |= (*adpcmbuf++) << 8;
 219             adpcms |= (*adpcmbuf++) << 16;
 220             adpcmbuf += (fmt->channels - 1) * 4;
 221             adpcms |= (uint64_t)(*adpcmbuf++) << 24;
 222             adpcms |= (uint64_t)(*adpcmbuf++) << 32;
 223             for (i = 0; i < 8; i++)
 224             {
 225                 *pcmbuf = create_pcmdata(ch, adpcms >> (5 * i)) << IMA_ADPCM_INC_DEPTH;
 226                 pcmbuf += fmt->channels;
 227             }
 228             adpcms = *adpcmbuf++;
 229             adpcms |= (*adpcmbuf++) << 8;
 230             adpcmbuf += (fmt->channels - 1) * 4;
 231             adpcms |= (*adpcmbuf++) << 16;
 232             adpcms |= (uint64_t)(*adpcmbuf++) << 24;
 233             adpcms |= (uint64_t)(*adpcmbuf++) << 32;
 234             for (i = 0; i < 8; i++)
 235             {
 236                 *pcmbuf = create_pcmdata(ch, adpcms >> (5 * i)) << IMA_ADPCM_INC_DEPTH;
 237                 pcmbuf += fmt->channels;
 238             }
 239             adpcms = *adpcmbuf++;
 240             adpcmbuf += (fmt->channels - 1) * 4;
 241             adpcms |= (*adpcmbuf++) << 8;
 242             adpcms |= (*adpcmbuf++) << 16;
 243             adpcms |= (uint64_t)(*adpcmbuf++) << 24;
 244             adpcms |= (uint64_t)(*adpcmbuf++) << 32;
 245             for (i = 0; i < 8; i++)
 246             {
 247                 *pcmbuf = create_pcmdata(ch, adpcms >> (5 * i)) << IMA_ADPCM_INC_DEPTH;
 248                 pcmbuf += fmt->channels;
 249             }
 250         }
 251         *outbuf += 32 * fmt->channels;
 252         *inbuf += 20 * fmt->channels;
 253     }
 254 }
 255
 256 static int decode(const uint8_t *inbuf, size_t inbufsize,
 257                   int32_t *outbuf, int *outbufcount)
 258 {
 259     int ch;
 260     int32_t init_pcmdata[2];
 261     int8_t init_index[2];
 262
 263     *outbufcount = 0;
 264     for (ch = 0; ch < fmt->channels; ch++)
 265     {
 266         init_pcmdata[ch] = inbuf[0] | (inbuf[1] << 8);
 267         if (init_pcmdata[ch] > 32767)
 268             init_pcmdata[ch] -= 65536;
 269
 270         init_index[ch] = inbuf[2];
 271         if (init_index[ch] > 88 || init_index[ch] < 0)
 272         {
 273             DEBUGF("CODEC_ERROR: dvi adpcm illegal step index=%d > 88\n",
 274                                  init_index[ch]);
 275             return CODEC_ERROR;
 276         }
 277         inbuf += 4;
 278
 279         *outbuf++ = init_pcmdata[ch] << IMA_ADPCM_INC_DEPTH;
 280     }
 281
 282     *outbufcount += 1;
 283     set_decode_parameters(fmt->channels, init_pcmdata, init_index);
 284
 285     if (fmt->bitspersample == 4)
 286         decode_4bit(&inbuf, inbufsize, &outbuf, outbufcount);
 287     else if (fmt->bitspersample == 3)
 288         decode_3bit(&inbuf, inbufsize, &outbuf, outbufcount);
 289     else if (fmt->bitspersample == 5)
 290         decode_5bit(&inbuf, inbufsize, &outbuf, outbufcount);
 291     else /* fmt->bitspersample == 2 */
 292         decode_2bit(&inbuf, inbufsize, &outbuf, outbufcount);
 293
 294     return CODEC_OK;
 295 }
 296
 297 static const struct pcm_codec codec = {
 298                                           set_format,
 299                                           get_seek_pos,
 300                                           decode,
 301                                       };
 302
 303 const struct pcm_codec *get_dvi_adpcm_codec(void)
 304 {
 305     return &codec;
 306 }