git.sesse.net Git - ffmpeg/blob - libavcodec/dtsdec.c

   1 /*
   2  * dtsdec.c : free DTS Coherent Acoustics stream decoder.
   3  * Copyright (C) 2004 Benjamin Zores <ben@geexbox.org>
   4  *
   5  * This file is part of libavcodec.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #ifdef HAVE_AV_CONFIG_H
  23 #undef HAVE_AV_CONFIG_H
  24 #endif
  25
  26 #include "avcodec.h"
  27 #include <dts.h>
  28 #include "dts_internal.h"
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <malloc.h>
  33 #include <math.h>
  34
  35 #define INBUF_SIZE 4096
  36 #define BUFFER_SIZE 4096
  37 #define HEADER_SIZE 14
  38
  39 #ifdef LIBDTS_FIXED
  40 #define CONVERT_LEVEL (1 << 26)
  41 #define CONVERT_BIAS 0
  42 #else
  43 #define CONVERT_LEVEL 1
  44 #define CONVERT_BIAS 384
  45 #endif
  46
  47 static void
  48 pre_calc_cosmod (dts_state_t * state)
  49 {
  50   int i, j, k;
  51
  52   for (j=0,k=0;k<16;k++)
  53     for (i=0;i<16;i++)
  54       state->cos_mod[j++] = cos((2*i+1)*(2*k+1)*M_PI/64);
  55
  56   for (k=0;k<16;k++)
  57     for (i=0;i<16;i++)
  58       state->cos_mod[j++] = cos((i)*(2*k+1)*M_PI/32);
  59
  60   for (k=0;k<16;k++)
  61     state->cos_mod[j++] = 0.25/(2*cos((2*k+1)*M_PI/128));
  62
  63   for (k=0;k<16;k++)
  64     state->cos_mod[j++] = -0.25/(2.0*sin((2*k+1)*M_PI/128));
  65 }
  66
  67 static inline
  68 int16_t convert (int32_t i)
  69 {
  70 #ifdef LIBDTS_FIXED
  71     i >>= 15;
  72 #else
  73     i -= 0x43c00000;
  74 #endif
  75     return (i > 32767) ? 32767 : ((i < -32768) ? -32768 : i);
  76 }
  77
  78 void
  79 convert2s16_2 (sample_t * _f, int16_t * s16)
  80 {
  81   int i;
  82   int32_t * f = (int32_t *) _f;
  83
  84   for (i = 0; i < 256; i++)
  85     {
  86       s16[2*i] = convert (f[i]);
  87       s16[2*i+1] = convert (f[i+256]);
  88     }
  89 }
  90
  91 void
  92 convert2s16_4 (sample_t * _f, int16_t * s16)
  93 {
  94   int i;
  95   int32_t * f = (int32_t *) _f;
  96
  97   for (i = 0; i < 256; i++)
  98     {
  99       s16[4*i] = convert (f[i]);
 100       s16[4*i+1] = convert (f[i+256]);
 101       s16[4*i+2] = convert (f[i+512]);
 102       s16[4*i+3] = convert (f[i+768]);
 103     }
 104 }
 105
 106 void
 107 convert2s16_5 (sample_t * _f, int16_t * s16)
 108 {
 109   int i;
 110   int32_t * f = (int32_t *) _f;
 111
 112   for (i = 0; i < 256; i++)
 113     {
 114       s16[5*i] = convert (f[i]);
 115       s16[5*i+1] = convert (f[i+256]);
 116       s16[5*i+2] = convert (f[i+512]);
 117       s16[5*i+3] = convert (f[i+768]);
 118       s16[5*i+4] = convert (f[i+1024]);
 119     }
 120 }
 121
 122 static void
 123 convert2s16_multi (sample_t * _f, int16_t * s16, int flags)
 124 {
 125   int i;
 126   int32_t * f = (int32_t *) _f;
 127
 128   switch (flags)
 129     {
 130     case DTS_MONO:
 131       for (i = 0; i < 256; i++)
 132         {
 133           s16[5*i] = s16[5*i+1] = s16[5*i+2] = s16[5*i+3] = 0;
 134           s16[5*i+4] = convert (f[i]);
 135         }
 136       break;
 137     case DTS_CHANNEL:
 138     case DTS_STEREO:
 139     case DTS_DOLBY:
 140       convert2s16_2 (_f, s16);
 141       break;
 142     case DTS_3F:
 143       for (i = 0; i < 256; i++)
 144         {
 145           s16[5*i] = convert (f[i]);
 146           s16[5*i+1] = convert (f[i+512]);
 147           s16[5*i+2] = s16[5*i+3] = 0;
 148           s16[5*i+4] = convert (f[i+256]);
 149         }
 150       break;
 151     case DTS_2F2R:
 152       convert2s16_4 (_f, s16);
 153       break;
 154     case DTS_3F2R:
 155       convert2s16_5 (_f, s16);
 156       break;
 157     case DTS_MONO | DTS_LFE:
 158       for (i = 0; i < 256; i++)
 159         {
 160           s16[6*i] = s16[6*i+1] = s16[6*i+2] = s16[6*i+3] = 0;
 161           s16[6*i+4] = convert (f[i+256]);
 162           s16[6*i+5] = convert (f[i]);
 163         }
 164       break;
 165     case DTS_CHANNEL | DTS_LFE:
 166     case DTS_STEREO | DTS_LFE:
 167     case DTS_DOLBY | DTS_LFE:
 168       for (i = 0; i < 256; i++)
 169         {
 170           s16[6*i] = convert (f[i+256]);
 171           s16[6*i+1] = convert (f[i+512]);
 172           s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
 173           s16[6*i+5] = convert (f[i]);
 174         }
 175       break;
 176     case DTS_3F | DTS_LFE:
 177       for (i = 0; i < 256; i++)
 178         {
 179           s16[6*i] = convert (f[i+256]);
 180           s16[6*i+1] = convert (f[i+768]);
 181           s16[6*i+2] = s16[6*i+3] = 0;
 182           s16[6*i+4] = convert (f[i+512]);
 183           s16[6*i+5] = convert (f[i]);
 184         }
 185       break;
 186     case DTS_2F2R | DTS_LFE:
 187       for (i = 0; i < 256; i++)
 188         {
 189           s16[6*i] = convert (f[i+256]);
 190           s16[6*i+1] = convert (f[i+512]);
 191           s16[6*i+2] = convert (f[i+768]);
 192           s16[6*i+3] = convert (f[i+1024]);
 193           s16[6*i+4] = 0;
 194           s16[6*i+5] = convert (f[i]);
 195         }
 196       break;
 197     case DTS_3F2R | DTS_LFE:
 198       for (i = 0; i < 256; i++)
 199         {
 200           s16[6*i] = convert (f[i+256]);
 201           s16[6*i+1] = convert (f[i+768]);
 202           s16[6*i+2] = convert (f[i+1024]);
 203           s16[6*i+3] = convert (f[i+1280]);
 204           s16[6*i+4] = convert (f[i+512]);
 205           s16[6*i+5] = convert (f[i]);
 206         }
 207       break;
 208     }
 209 }
 210
 211 static int
 212 channels_multi (int flags)
 213 {
 214   if (flags & DTS_LFE)
 215     return 6;
 216   else if (flags & 1)   /* center channel */
 217     return 5;
 218   else if ((flags & DTS_CHANNEL_MASK) == DTS_2F2R)
 219     return 4;
 220   else
 221     return 2;
 222 }
 223
 224 static int
 225 dts_decode_frame (AVCodecContext *avctx, void *data, int *data_size,
 226                   uint8_t *buff, int buff_size)
 227 {
 228   uint8_t * start = buff;
 229   uint8_t * end = buff + buff_size;
 230   *data_size = 0;
 231
 232   static uint8_t buf[BUFFER_SIZE];
 233   static uint8_t * bufptr = buf;
 234   static uint8_t * bufpos = buf + HEADER_SIZE;
 235
 236   static int sample_rate;
 237   static int frame_length;
 238   static int flags;
 239   int bit_rate;
 240   int len;
 241   dts_state_t *state = avctx->priv_data;
 242
 243   while (1)
 244     {
 245       len = end - start;
 246       if (!len)
 247         break;
 248       if (len > bufpos - bufptr)
 249         len = bufpos - bufptr;
 250       memcpy (bufptr, start, len);
 251       bufptr += len;
 252       start += len;
 253       if (bufptr == bufpos)
 254         {
 255           if (bufpos == buf + HEADER_SIZE)
 256             {
 257               int length;
 258
 259               length = dts_syncinfo (state, buf, &flags, &sample_rate,
 260                                      &bit_rate, &frame_length);
 261               if (!length)
 262                 {
 263                   av_log (NULL, AV_LOG_INFO, "skip\n");
 264                   for (bufptr = buf; bufptr < buf + HEADER_SIZE-1; bufptr++)
 265                     bufptr[0] = bufptr[1];
 266                   continue;
 267                 }
 268               bufpos = buf + length;
 269             }
 270           else
 271             {
 272               level_t level;
 273               sample_t bias;
 274               int i;
 275
 276               flags = 2; /* ???????????? */
 277               level = CONVERT_LEVEL;
 278               bias = CONVERT_BIAS;
 279
 280               flags |= DTS_ADJUST_LEVEL;
 281               if (dts_frame (state, buf, &flags, &level, bias))
 282                 goto error;
 283               for (i = 0; i < dts_blocks_num (state); i++)
 284                 {
 285                   if (dts_block (state))
 286                     goto error;
 287                   {
 288                     int chans;
 289                     chans = channels_multi (flags);
 290                     convert2s16_multi (dts_samples (state), data,
 291                                        flags & (DTS_CHANNEL_MASK | DTS_LFE));
 292
 293                     data += 256 * sizeof (int16_t) * chans;
 294                     *data_size += 256 * sizeof (int16_t) * chans;
 295                   }
 296                 }
 297               bufptr = buf;
 298               bufpos = buf + HEADER_SIZE;
 299               continue;
 300             error:
 301               av_log (NULL, AV_LOG_ERROR, "error\n");
 302               bufptr = buf;
 303               bufpos = buf + HEADER_SIZE;
 304             }
 305         }
 306     }
 307
 308   return buff_size;
 309 }
 310
 311 static int
 312 dts_decode_init (AVCodecContext *avctx)
 313 {
 314   dts_state_t * state;
 315   int i;
 316
 317   state = avctx->priv_data;
 318   memset (state, 0, sizeof (dts_state_t));
 319
 320   state->samples = (sample_t *) memalign (16, 256 * 12 * sizeof (sample_t));
 321   if (state->samples == NULL)
 322     return 1;
 323
 324   for (i = 0; i < 256 * 12; i++)
 325     state->samples[i] = 0;
 326
 327   /* Pre-calculate cosine modulation coefficients */
 328   pre_calc_cosmod (state);
 329   state->downmixed = 1;
 330
 331   return 0;
 332 }
 333
 334 static int
 335 dts_decode_end (AVCodecContext *s)
 336 {
 337   return 0;
 338 }
 339
 340 AVCodec dts_decoder = {
 341   "dts",
 342   CODEC_TYPE_AUDIO,
 343   CODEC_ID_DTS,
 344   sizeof (dts_state_t),
 345   dts_decode_init,
 346   NULL,
 347   dts_decode_end,
 348   dts_decode_frame,
 349 };