开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
dts_parse.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：41k
源码类别：

多媒体编程

开发平台：

Visual C++

dts_parse.c：源码内容
  1. /*
  2.  * parse.c
  3.  * Copyright (C) 2004 Gildas Bazin <gbazin@videolan.org>
  4.  *
  5.  * This file is part of dtsdec, a free DTS Coherent Acoustics stream decoder.
  6.  * See http://www.videolan.org/dtsdec.html for updates.
  7.  *
  8.  * dtsdec is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * dtsdec is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  23. #include "config.h"
  25. #include <stdio.h>
  27. //#include <stdlib.h>
  29. void    __cdecl free(void *);
  30. void *  __cdecl malloc(size_t);
  32. #include <string.h>
  33. #include <inttypes.h>
  35. #include <math.h>
  37. #ifndef M_PI
  38. #define M_PI 3.1415926535897932384626433832795029
  39. #endif
  41. #include "dts.h"
  42. #include "dts_internal.h"
  43. #include "bitstream.h"
  45. #include "tables.h"
  46. #include "tables_huffman.h"
  47. #include "tables_quantization.h"
  48. #include "tables_adpcm.h"
  49. #include "tables_fir.h"
  50. #include "tables_vq.h"
  52. /* #define DEBUG */
  54. #if defined(HAVE_MEMALIGN) && !defined(__cplusplus)
  55. /* some systems have memalign() but no declaration for it */
  56. void * memalign (size_t align, size_t size);
  57. #else
  58. /* assume malloc alignment is sufficient */
  59. #define memalign(align,size) malloc (size)
  60. #endif
  62. static int decode_blockcode (int code, int levels, int *values);
  64. static void qmf_32_subbands (dts_state_t * state, int chans,
  65.                              double samples_in[32][8], sample_t *samples_out,
  66.                              double rScale, sample_t bias);
  68. static void lfe_interpolation_fir (int nDecimationSelect, int nNumDeciSample,
  69.                                    double *samples_in, sample_t *samples_out,
  70.                                    double rScale, sample_t bias );
  72. static void pre_calc_cosmod( dts_state_t * state );
  74. dts_state_t * dts_init (uint32_t mm_accel)
  75. {
  76.     dts_state_t * state;
  77.     int i;
  79.     state = (dts_state_t *) malloc (sizeof (dts_state_t));
  80.     if (state == NULL)
  81.         return NULL;
  83.     memset (state, 0, sizeof(dts_state_t));
  85.     state->samples = (sample_t *) memalign (16, 256 * 12 * sizeof (sample_t));
  86.     if (state->samples == NULL) {
  87.         free (state);
  88.         return NULL;
  89.     }
  91.     for (i = 0; i < 256 * 12; i++)
  92.         state->samples[i] = 0;
  94.     /* Pre-calculate cosine modulation coefficients */
  95.     pre_calc_cosmod( state );
  97.     state->downmixed = 1;
  99.     return state;
  100. }
  102. sample_t * dts_samples (dts_state_t * state)
  103. {
  104.     return state->samples;
  105. }
  107. int dts_blocks_num (dts_state_t * state)
  108. {
  109.     /* 8 samples per subsubframe and per subband */
  110.     return state->sample_blocks / 8;
  111. }
  113. static int syncinfo (dts_state_t * state, int * flags,
  114.                      int * sample_rate, int * bit_rate, int * frame_length)
  115. {
  116.     int frame_size;
  118.     /* Sync code */
  119.     bitstream_get (state, 32);
  120.     /* Frame type */
  121.     bitstream_get (state, 1);
  122.     /* Samples deficit */
  123.     bitstream_get (state, 5);
  124.     /* CRC present */
  125.     bitstream_get (state, 1);
  127.     *frame_length = (bitstream_get (state, 7) + 1) * 32;
  128.     frame_size = bitstream_get (state, 14) + 1;
  129.     if (!state->word_mode) frame_size = frame_size * 8 / 14 * 2;
  131.     /* Audio channel arrangement */
  132.     *flags = bitstream_get (state, 6);
  133.     if (*flags > 63)
  134.         return 0;
  136.     *sample_rate = bitstream_get (state, 4);
  137.     if (*sample_rate >= sizeof (dts_sample_rates) / sizeof (int))
  138.         return 0;
  139.     *sample_rate = dts_sample_rates[ *sample_rate ];
  140.     if (!*sample_rate) return 0;
  142.     *bit_rate = bitstream_get (state, 5);
  143.     if (*bit_rate >= sizeof (dts_bit_rates) / sizeof (int))
  144.         return 0;
  145.     *bit_rate = dts_bit_rates[ *bit_rate ];
  146.     if (!*bit_rate) return 0;
  148.     /* LFE */
  149.     bitstream_get (state, 10);
  150.     if (bitstream_get (state, 2)) *flags |= DTS_LFE;
  152.     return frame_size;
  153. }
  155. int dts_syncinfo (dts_state_t * state, uint8_t * buf, int * flags,
  156.                   int * sample_rate, int * bit_rate, int * frame_length)
  157. {
  158.     /*
  159.      * Look for sync code
  160.      */
  162.     /* 14 bits and little endian bitstream */
  163.     if (buf[0] == 0xff && buf[1] == 0x1f &&
  164.         buf[2] == 0x00 && buf[3] == 0xe8 &&
  165.         (buf[4] & 0xf0) == 0xf0 && buf[5] == 0x07)
  166.     {
  167.         int frame_size;
  168.         dts_bitstream_init (state, buf, 0, 0);
  169.         frame_size = syncinfo (state, flags, sample_rate,
  170.                                bit_rate, frame_length);
  171.         return frame_size;
  172.     }
  174.     /* 14 bits and big endian bitstream */
  175.     if (buf[0] == 0x1f && buf[1] == 0xff &&
  176.         buf[2] == 0xe8 && buf[3] == 0x00 &&
  177.         buf[4] == 0x07 && (buf[5] & 0xf0) == 0xf0)
  178.     {
  179.         int frame_size;
  180.         dts_bitstream_init (state, buf, 0, 1);
  181.         frame_size = syncinfo (state, flags, sample_rate,
  182.                                bit_rate, frame_length);
  183.         return frame_size;
  184.     }
  186.     /* 16 bits and little endian bitstream */
  187.     if (buf[0] == 0xfe && buf[1] == 0x7f &&
  188.         buf[2] == 0x01 && buf[3] == 0x80)
  189.     {
  190.         int frame_size;
  191.         dts_bitstream_init (state, buf, 1, 0);
  192.         frame_size = syncinfo (state, flags, sample_rate,
  193.                                bit_rate, frame_length);
  194.         return frame_size;
  195.     }
  197.     /* 16 bits and big endian bitstream */
  198.     if (buf[0] == 0x7f && buf[1] == 0xfe &&
  199.         buf[2] == 0x80 && buf[3] == 0x01)
  200.     {
  201.         int frame_size;
  202.         dts_bitstream_init (state, buf, 1, 1);
  203.         frame_size = syncinfo (state, flags, sample_rate,
  204.                                bit_rate, frame_length);
  205.         return frame_size;
  206.     }
  208.     return 0;
  209. }
  211. int dts_frame (dts_state_t * state, uint8_t * buf, int * flags,
  212.                level_t * level, sample_t bias)
  213. {
  214.     int i, j;
  215.     static float adj_table[] = { 1.0, 1.1250, 1.2500, 1.4375 };
  217.     dts_bitstream_init (state, buf, state->word_mode, state->bigendian_mode);
  219.     /* Sync code */
  220.     bitstream_get (state, 32);
  222.     /* Frame header */
  223.     state->frame_type = bitstream_get (state, 1);
  224.     state->samples_deficit = bitstream_get (state, 5) + 1;
  225.     state->crc_present = bitstream_get (state, 1);
  226.     state->sample_blocks = bitstream_get (state, 7) + 1;
  227.     state->frame_size = bitstream_get (state, 14) + 1;
  228.     state->amode = bitstream_get (state, 6);
  229.     state->sample_rate = bitstream_get (state, 4);
  230.     state->bit_rate = bitstream_get (state, 5);
  232.     state->downmix = bitstream_get (state, 1);
  233.     state->dynrange = bitstream_get (state, 1);
  234.     state->timestamp = bitstream_get (state, 1);
  235.     state->aux_data = bitstream_get (state, 1);
  236.     state->hdcd = bitstream_get (state, 1);
  237.     state->ext_descr = bitstream_get (state, 3);
  238.     state->ext_coding = bitstream_get (state, 1);
  239.     state->aspf = bitstream_get (state, 1);
  240.     state->lfe = bitstream_get (state, 2);
  241.     state->predictor_history = bitstream_get (state, 1);
  243.     /* TODO: check CRC */
  244.     if (state->crc_present) state->header_crc = bitstream_get (state, 16);
  246.     state->multirate_inter = bitstream_get (state, 1);
  247.     state->version = bitstream_get (state, 4);
  248.     state->copy_history = bitstream_get (state, 2);
  249.     state->source_pcm_res = bitstream_get (state, 3);
  250.     state->front_sum = bitstream_get (state, 1);
  251.     state->surround_sum = bitstream_get (state, 1);
  252.     state->dialog_norm = bitstream_get (state, 4);
  254.     /* FIME: channels mixing levels */
  255.     state->clev = state->slev = 1;
  256.     state->output = dts_downmix_init (state->amode, *flags, level,
  257.                                       state->clev, state->slev);
  258.     if (state->output < 0)
  259.         return 1;
  261.     if (state->lfe && (*flags & DTS_LFE))
  262.         state->output |= DTS_LFE;
  264.     *flags = state->output;
  266.     state->dynrng = state->level = MUL_C (*level, 2);
  267.     state->bias = bias;
  268.     state->dynrnge = 1;
  269.     state->dynrngcall = NULL;
  271. #ifdef DEBUG
  272.     fprintf (stderr, "frame type: %in", state->frame_type);
  273.     fprintf (stderr, "samples deficit: %in", state->samples_deficit);
  274.     fprintf (stderr, "crc present: %in", state->crc_present);
  275.     fprintf (stderr, "sample blocks: %i (%i samples)n",
  276.              state->sample_blocks, state->sample_blocks * 32);
  277.     fprintf (stderr, "frame size: %i bytesn", state->frame_size);
  278.     fprintf (stderr, "amode: %i (%i channels)n",
  279.              state->amode, dts_channels[state->amode]);
  280.     fprintf (stderr, "sample rate: %i (%i Hz)n",
  281.              state->sample_rate, dts_sample_rates[state->sample_rate]);
  282.     fprintf (stderr, "bit rate: %i (%i bits/s)n",
  283.              state->bit_rate, dts_bit_rates[state->bit_rate]);
  284.     fprintf (stderr, "downmix: %in", state->downmix);
  285.     fprintf (stderr, "dynrange: %in", state->dynrange);
  286.     fprintf (stderr, "timestamp: %in", state->timestamp);
  287.     fprintf (stderr, "aux_data: %in", state->aux_data);
  288.     fprintf (stderr, "hdcd: %in", state->hdcd);
  289.     fprintf (stderr, "ext descr: %in", state->ext_descr);
  290.     fprintf (stderr, "ext coding: %in", state->ext_coding);
  291.     fprintf (stderr, "aspf: %in", state->aspf);
  292.     fprintf (stderr, "lfe: %in", state->lfe);
  293.     fprintf (stderr, "predictor history: %in", state->predictor_history);
  294.     fprintf (stderr, "header crc: %in", state->header_crc);
  295.     fprintf (stderr, "multirate inter: %in", state->multirate_inter);
  296.     fprintf (stderr, "version number: %in", state->version);
  297.     fprintf (stderr, "copy history: %in", state->copy_history);
  298.     fprintf (stderr, "source pcm resolution: %i (%i bits/sample)n",
  299.              state->source_pcm_res,
  300.              dts_bits_per_sample[state->source_pcm_res]);
  301.     fprintf (stderr, "front sum: %in", state->front_sum);
  302.     fprintf (stderr, "surround sum: %in", state->surround_sum);
  303.     fprintf (stderr, "dialog norm: %in", state->dialog_norm);
  304.     fprintf (stderr, "n");
  305. #endif
  307.     /* Primary audio coding header */
  308.     state->subframes = bitstream_get (state, 4) + 1;
  309.     state->prim_channels = bitstream_get (state, 3) + 1;
  311. #ifdef DEBUG
  312.     fprintf (stderr, "subframes: %in", state->subframes);
  313.     fprintf (stderr, "prim channels: %in", state->prim_channels);
  314. #endif
  316.     for (i = 0; i < state->prim_channels; i++)
  317.     {
  318.         state->subband_activity[i] = bitstream_get (state, 5) + 2;
  319. #ifdef DEBUG
  320.         fprintf (stderr, "subband activity: %in", state->subband_activity[i]);
  321. #endif
  322.         if (state->subband_activity[i] > DTS_SUBBANDS)
  323.             state->subband_activity[i] = DTS_SUBBANDS;
  324.     }
  325.     for (i = 0; i < state->prim_channels; i++)
  326.     {
  327.         state->vq_start_subband[i] = bitstream_get (state, 5) + 1;
  328. #ifdef DEBUG
  329.         fprintf (stderr, "vq start subband: %in", state->vq_start_subband[i]);
  330. #endif
  331.         if (state->vq_start_subband[i] > DTS_SUBBANDS)
  332.             state->vq_start_subband[i] = DTS_SUBBANDS;
  333.     }
  334.     for (i = 0; i < state->prim_channels; i++)
  335.     {
  336.         state->joint_intensity[i] = bitstream_get (state, 3);
  337. #ifdef DEBUG
  338.         fprintf (stderr, "joint intensity: %in", state->joint_intensity[i]);
  339.         if (state->joint_intensity[i]) {fprintf (stderr, "JOINTINTENSITYn");}
  340. #endif
  341.     }
  342.     for (i = 0; i < state->prim_channels; i++)
  343.     {
  344.         state->transient_huffman[i] = bitstream_get (state, 2);
  345. #ifdef DEBUG
  346.         fprintf (stderr, "transient mode codebook: %in",
  347.                  state->transient_huffman[i]);
  348. #endif
  349.     }
  350.     for (i = 0; i < state->prim_channels; i++)
  351.     {
  352.         state->scalefactor_huffman[i] = bitstream_get (state, 3);
  353. #ifdef DEBUG
  354.         fprintf (stderr, "scale factor codebook: %in",
  355.                  state->scalefactor_huffman[i]);
  356. #endif
  357.     }
  358.     for (i = 0; i < state->prim_channels; i++)
  359.     {
  360.         state->bitalloc_huffman[i] = bitstream_get (state, 3);
  361.         /* if (state->bitalloc_huffman[i] == 7) bailout */
  362. #ifdef DEBUG
  363.         fprintf (stderr, "bit allocation quantizer: %in",
  364.                  state->bitalloc_huffman[i]);
  365. #endif
  366.     }
  368.     /* Get codebooks quantization indexes */
  369.     for (i = 0; i < state->prim_channels; i++)
  370.     {
  371.         state->quant_index_huffman[i][0] = 0; /* Not transmitted */
  372.         state->quant_index_huffman[i][1] = bitstream_get (state, 1);
  373.     }
  374.     for (j = 2; j < 6; j++)
  375.         for (i = 0; i < state->prim_channels; i++)
  376.             state->quant_index_huffman[i][j] = bitstream_get (state, 2);
  377.     for (j = 6; j < 11; j++)
  378.         for (i = 0; i < state->prim_channels; i++)
  379.             state->quant_index_huffman[i][j] = bitstream_get (state, 3);
  380.     for (j = 11; j < 27; j++)
  381.         for (i = 0; i < state->prim_channels; i++)
  382.             state->quant_index_huffman[i][j] = 0; /* Not transmitted */
  384. #ifdef DEBUG
  385.     for (i = 0; i < state->prim_channels; i++)
  386.     {
  387.         fprintf( stderr, "quant index huff:" );
  388.         for (j = 0; j < 11; j++)
  389.             fprintf (stderr, " %i", state->quant_index_huffman[i][j]);
  390.         fprintf (stderr, "n");
  391.     }
  392. #endif
  394.     /* Get scale factor adjustment */
  395.     for (j = 0; j < 11; j++)
  396.     {
  397.         for (i = 0; i < state->prim_channels; i++)
  398.             state->scalefactor_adj[i][j] = 1;
  399.     }
  400.     for (i = 0; i < state->prim_channels; i++)
  401.     {
  402.         if (state->quant_index_huffman[i][1] == 0)
  403.         {
  404.             /* Transmitted only if quant_index_huffman=0 (Huffman code used) */
  405.             state->scalefactor_adj[i][1] = adj_table[bitstream_get (state, 2)];
  406.         }
  407.     }
  408.     for (j = 2; j < 6; j++)
  409.         for (i = 0; i < state->prim_channels; i++)
  410.             if (state->quant_index_huffman[i][j] < 3)
  411.             {
  412.                 /* Transmitted only if quant_index_huffman < 3 */
  413.                 state->scalefactor_adj[i][j] =
  414.                     adj_table[bitstream_get (state, 2)];
  415.             }
  416.     for (j = 6; j < 11; j++)
  417.         for (i = 0; i < state->prim_channels; i++)
  418.             if (state->quant_index_huffman[i][j] < 7)
  419.             {
  420.                 /* Transmitted only if quant_index_huffman < 7 */
  421.                 state->scalefactor_adj[i][j] =
  422.                     adj_table[bitstream_get (state, 2)];
  423.             }
  425. #ifdef DEBUG
  426.     for (i = 0; i < state->prim_channels; i++)
  427.     {
  428.         fprintf (stderr, "scalefac adj:");
  429.         for (j = 0; j < 11; j++)
  430.             fprintf (stderr, " %1.3f", state->scalefactor_adj[i][j]);
  431.         fprintf (stderr, "n");
  432.     }
  433. #endif
  435.     if (state->crc_present)
  436.     {
  437.         /* Audio header CRC check */
  438.         bitstream_get (state, 16);
  439.     }
  441.     state->current_subframe = 0;
  442.     state->current_subsubframe = 0;
  444.     return 0;
  445. }
  447. int dts_subframe_header (dts_state_t * state)
  448. {
  449.     /* Primary audio coding side information */
  450.     int j, k;
  452.     /* Subsubframe count */
  453.     state->subsubframes = bitstream_get (state, 2) + 1;
  454. #ifdef DEBUG
  455.     fprintf (stderr, "subsubframes: %in", state->subsubframes);
  456. #endif
  458.     /* Partial subsubframe sample count */
  459.     state->partial_samples = bitstream_get (state, 3);
  460. #ifdef DEBUG
  461.     fprintf (stderr, "partial samples: %in", state->partial_samples);
  462. #endif
  464.     /* Get prediction mode for each subband */
  465.     for (j = 0; j < state->prim_channels; j++)
  466.     {
  467.         for (k = 0; k < state->subband_activity[j]; k++)
  468.             state->prediction_mode[j][k] = bitstream_get (state, 1);
  469. #ifdef DEBUG
  470.         fprintf (stderr, "prediction mode:");
  471.         for (k = 0; k < state->subband_activity[j]; k++)
  472.             fprintf (stderr, " %i", state->prediction_mode[j][k]);
  473.         fprintf (stderr, "n");
  474. #endif
  475.     }
  477.     /* Get prediction codebook */
  478.     for (j = 0; j < state->prim_channels; j++)
  479.     {
  480.         for (k = 0; k < state->subband_activity[j]; k++)
  481.         {
  482.             if (state->prediction_mode[j][k] > 0)
  483.             {
  484.                 /* (Prediction coefficient VQ address) */
  485.                 state->prediction_vq[j][k] = bitstream_get (state, 12);
  486. #ifdef DEBUG
  487.                 fprintf (stderr, "prediction coefs: %f, %f, %f, %fn",
  488.                          (double)adpcm_vb[state->prediction_vq[j][k]][0]/8192,
  489.                          (double)adpcm_vb[state->prediction_vq[j][k]][1]/8192,
  490.                          (double)adpcm_vb[state->prediction_vq[j][k]][2]/8192,
  491.                          (double)adpcm_vb[state->prediction_vq[j][k]][3]/8192);
  492. #endif
  493.             }
  494.         }
  495.     }
  497.     /* Bit allocation index */
  498.     for (j = 0; j < state->prim_channels; j++)
  499.     {
  500.         for (k = 0; k < state->vq_start_subband[j]; k++)
  501.         {
  502.             if (state->bitalloc_huffman[j] == 6)
  503.                 state->bitalloc[j][k] = bitstream_get (state, 5);
  504.             else if (state->bitalloc_huffman[j] == 5)
  505.                 state->bitalloc[j][k] = bitstream_get (state, 4);
  506.             else
  507.             {
  508.                 state->bitalloc[j][k] = InverseQ (state,
  509.                     bitalloc_12[state->bitalloc_huffman[j]]);
  510.             }
  512.             if (state->bitalloc[j][k] > 26)
  513.             {
  514.                 fprintf (stderr, "bitalloc index [%i][%i] too big (%i)n",
  515.                          j, k, state->bitalloc[j][k]);
  516.                 return -1;
  517.             }
  518.         }
  520. #ifdef DEBUG
  521.         fprintf (stderr, "bitalloc index: ");
  522.         for (k = 0; k < state->vq_start_subband[j]; k++)
  523.             fprintf (stderr, "%2.2i ", state->bitalloc[j][k]);
  524.         fprintf (stderr, "n");
  525. #endif
  526.     }
  528.     /* Transition mode */
  529.     for (j = 0; j < state->prim_channels; j++)
  530.     {
  531.         for (k = 0; k < state->subband_activity[j]; k++)
  532.         {
  533.             state->transition_mode[j][k] = 0;
  534.             if (state->subsubframes > 1 &&
  535.                 k < state->vq_start_subband[j] &&
  536.                 state->bitalloc[j][k] > 0)
  537.             {
  538.                 state->transition_mode[j][k] = InverseQ (state,
  539.                     tmode[state->transient_huffman[j]]);
  540.             }
  541.         }
  542. #ifdef DEBUG
  543.         fprintf (stderr, "Transition mode:");
  544.         for (k = 0; k < state->subband_activity[j]; k++)
  545.             fprintf (stderr, " %i", state->transition_mode[j][k]);
  546.         fprintf (stderr, "n");
  547. #endif
  548.     }
  550.     /* Scale factors */
  551.     for (j = 0; j < state->prim_channels; j++)
  552.     {
  553.         int *scale_table;
  554.         int scale_sum;
  556.         for (k = 0; k < state->subband_activity[j]; k++)
  557.         {
  558.             state->scale_factor[j][k][0] = 0;
  559.             state->scale_factor[j][k][1] = 0;
  560.         }
  562.         if (state->scalefactor_huffman[j] == 6)
  563.             scale_table = scale_factor_quant7;
  564.         else
  565.             scale_table = scale_factor_quant6;
  567.         /* When huffman coded, only the difference is encoded */
  568.         scale_sum = 0;
  570.         for (k = 0; k < state->subband_activity[j]; k++)
  571.         {
  572.             if (k >= state->vq_start_subband[j] || state->bitalloc[j][k] > 0)
  573.             {
  574.                 if (state->scalefactor_huffman[j] < 5)
  575.                 {
  576.                     /* huffman encoded */
  577.                     scale_sum += InverseQ (state,
  578.                         scales_129[state->scalefactor_huffman[j]]);
  579.                 }
  580.                 else if (state->scalefactor_huffman[j] == 5)
  581.                 {
  582.                     scale_sum = bitstream_get (state, 6);
  583.                 }
  584.                 else if (state->scalefactor_huffman[j] == 6)
  585.                 {
  586.                     scale_sum = bitstream_get (state, 7);
  587.                 }
  589.                 state->scale_factor[j][k][0] = scale_table[scale_sum];
  590.             }
  592.             if (k < state->vq_start_subband[j] && state->transition_mode[j][k])
  593.             {
  594.                 /* Get second scale factor */
  595.                 if (state->scalefactor_huffman[j] < 5)
  596.                 {
  597.                     /* huffman encoded */
  598.                     scale_sum += InverseQ (state,
  599.                         scales_129[state->scalefactor_huffman[j]]);
  600.                 }
  601.                 else if (state->scalefactor_huffman[j] == 5)
  602.                 {
  603.                     scale_sum = bitstream_get (state, 6);
  604.                 }
  605.                 else if (state->scalefactor_huffman[j] == 6)
  606.                 {
  607.                     scale_sum = bitstream_get (state, 7);
  608.                 }
  610.                 state->scale_factor[j][k][1] = scale_table[scale_sum];
  611.             }
  612.         }
  614. #ifdef DEBUG
  615.         fprintf (stderr, "Scale factor:");
  616.         for (k = 0; k < state->subband_activity[j]; k++)
  617.         {
  618.             if (k >= state->vq_start_subband[j] || state->bitalloc[j][k] > 0)
  619.                 fprintf (stderr, " %i", state->scale_factor[j][k][0]);
  620.             if (k < state->vq_start_subband[j] && state->transition_mode[j][k])
  621.                 fprintf (stderr, " %i(t)", state->scale_factor[j][k][1]);
  622.         }
  623.         fprintf (stderr, "n");
  624. #endif
  625.     }
  627.     /* Joint subband scale factor codebook select */
  628.     for (j = 0; j < state->prim_channels; j++)
  629.     {
  630.         /* Transmitted only if joint subband coding enabled */
  631.         if (state->joint_intensity[j] > 0)
  632.             state->joint_huff[j] = bitstream_get (state, 3);
  633.     }
  635.     /* Scale factors for joint subband coding */
  636.     for (j = 0; j < state->prim_channels; j++)
  637.     {
  638.         int source_channel;
  640.         /* Transmitted only if joint subband coding enabled */
  641.         if (state->joint_intensity[j] > 0)
  642.         {
  643.             int scale = 0;
  644.             source_channel = state->joint_intensity[j] - 1;
  646.             /* When huffman coded, only the difference is encoded
  647.              * (is this valid as well for joint scales ???) */
  649.             for (k = state->subband_activity[j];
  650.                  k < state->subband_activity[source_channel]; k++)
  651.             {
  652.                 if (state->joint_huff[j] < 5)
  653.                 {
  654.                     /* huffman encoded */
  655.                     scale = InverseQ (state,
  656.                         scales_129[state->joint_huff[j]]);
  657.                 }
  658.                 else if (state->joint_huff[j] == 5)
  659.                 {
  660.                     scale = bitstream_get (state, 6);
  661.                 }
  662.                 else if (state->joint_huff[j] == 6)
  663.                 {
  664.                     scale = bitstream_get (state, 7);
  665.                 }
  667.                 scale += 64; /* bias */
  668.                 state->joint_scale_factor[j][k] = scale;/*joint_scale_table[scale];*/
  669.             }
  671.             if (!state->debug_flag & 0x02)
  672.             {
  673.                 fprintf (stderr, "Joint stereo coding not supportedn");
  674.                 state->debug_flag |= 0x02;
  675.             }
  677. #ifdef DEBUG
  678.             fprintf (stderr, "Joint scale factor index:n");
  679.             for (k = state->subband_activity[j];
  680.                  k < state->subband_activity[source_channel]; k++)
  681.                 fprintf (stderr, " %i", state->joint_scale_factor[j][k]);
  682.             fprintf (stderr, "n");
  683. #endif
  684.         }
  685.     }
  687.     /* Stereo downmix coefficients */
  688.     if (state->prim_channels > 2 && state->downmix)
  689.     {
  690.         for (j = 0; j < state->prim_channels; j++)
  691.         {
  692.             state->downmix_coef[j][0] = bitstream_get (state, 7);
  693.             state->downmix_coef[j][1] = bitstream_get (state, 7);
  694.         }
  695.     }
  697.     /* Dynamic range coefficient */
  698.     if (state->dynrange) state->dynrange_coef = bitstream_get (state, 8);
  700.     /* Side information CRC check word */
  701.     if (state->crc_present)
  702.     {
  703.         bitstream_get (state, 16);
  704.     }
  706.     /*
  707.      * Primary audio data arrays
  708.      */
  710.     /* VQ encoded high frequency subbands */
  711.     for (j = 0; j < state->prim_channels; j++)
  712.     {
  713.         for (k = state->vq_start_subband[j];
  714.              k < state->subband_activity[j]; k++)
  715.         {
  716.             /* 1 vector -> 32 samples */
  717.             state->high_freq_vq[j][k] = bitstream_get (state, 10);
  719. #ifdef DEBUG
  720.             fprintf( stderr, "VQ index: %in", state->high_freq_vq[j][k] );
  721. #endif
  722.         }
  723.     }
  725.     /* Low frequency effect data */
  726.     if (state->lfe)
  727.     {
  728.         /* LFE samples */
  729.         int lfe_samples = 2 * state->lfe * state->subsubframes;
  730.         double lfe_scale;
  732.         for (j = lfe_samples; j < lfe_samples * 2; j++)
  733.         {
  734.             /* Signed 8 bits int */
  735.             state->lfe_data[j] =
  736.                 (signed int)(signed char)bitstream_get (state, 8);
  737.         }
  739.         /* Scale factor index */
  740.         state->lfe_scale_factor =
  741.             scale_factor_quant7[bitstream_get (state, 8)];
  743.         /* Quantization step size * scale factor */
  744.         lfe_scale = 0.035 * state->lfe_scale_factor;
  746.         for (j = lfe_samples; j < lfe_samples * 2; j++)
  747.             state->lfe_data[j] *= lfe_scale;
  749. #ifdef DEBUG
  750.         fprintf (stderr, "LFE samples:n");
  751.         for (j = lfe_samples; j < lfe_samples * 2; j++)
  752.             fprintf (stderr, " %f", state->lfe_data[j]);
  753.         fprintf (stderr, "n");
  754. #endif
  756.     }
  758.     return 0;
  759. }
  761. int dts_subsubframe (dts_state_t * state)
  762. {
  763.     int k, l;
  764.     int subsubframe = state->current_subsubframe;
  766.     double *quant_step_table;
  768.     /* FIXME */
  769.     double subband_samples[DTS_PRIM_CHANNELS_MAX][DTS_SUBBANDS][8];
  771.     /*
  772.      * Audio data
  773.      */
  775.     /* Select quantization step size table */
  776.     if (state->bit_rate == 0x1f) 
  777.         quant_step_table = lossless_quant_d;
  778.     else
  779.         quant_step_table = lossy_quant_d;
  781.     for (k = 0; k < state->prim_channels; k++)
  782.     {
  783.         for (l = 0; l < state->vq_start_subband[k] ; l++)
  784.         {
  785.             int m;
  787.             /* Select the mid-tread linear quantizer */
  788.             int abits = state->bitalloc[k][l];
  790.             double quant_step_size = quant_step_table[abits];
  791.             double rscale;
  793.             /*
  794.              * Determine quantization index code book and its type 
  795.              */
  797.             /* Select quantization index code book */
  798.             int sel = state->quant_index_huffman[k][abits]; 
  800.             /* Determine its type */
  801.             int q_type = 1; /* (Assume Huffman type by default) */
  802.             if (abits >= 11 || !bitalloc_select[abits][sel])
  803.             {
  804.                 /* Not Huffman type */
  805.                 if (abits <= 7) q_type = 3; /* Block code */
  806.                 else q_type = 2; /* No further encoding */
  807.             }
  809.             if (abits == 0) q_type = 0; /* No bits allocated */
  811.             /*
  812.              * Extract bits from the bit stream 
  813.              */
  814.             switch (q_type)
  815.             {
  816.             case 0: /* No bits allocated */
  817.                 for (m=0; m<8; m++)
  818.                     subband_samples[k][l][m] = 0;
  819.                 break;
  821.             case 1: /* Huffman code */
  822.                 for (m=0; m<8; m++)
  823.                     subband_samples[k][l][m] =
  824.                         InverseQ (state, bitalloc_select[abits][sel]);
  825.                 break;
  827.             case 2: /* No further encoding */
  828.                 for (m=0; m<8; m++)
  829.                 {
  830.                     /* Extract (signed) quantization index */
  831.                     int q_index = bitstream_get (state, abits - 3);
  832.                     if( q_index & (1 << (abits - 4)) )
  833.                     {
  834.                         q_index = (1 << (abits - 3)) - q_index;
  835.                         q_index = -q_index;
  836.                     }
  837.                     subband_samples[k][l][m] = q_index;
  838.                 }
  839.                 break;
  841.             case 3: /* Block code */
  842.                 {
  843.                     int block_code1, block_code2, size, levels;
  844.                     int block[8];
  846.                     switch (abits)
  847.                     {
  848.                     case 1:
  849.                         size = 7;
  850.                         levels = 3;
  851.                         break;
  852.                     case 2:
  853.                         size = 10;
  854.                         levels = 5;
  855.                         break;
  856.                     case 3:
  857.                         size = 12;
  858.                         levels = 7;
  859.                         break;
  860.                     case 4:
  861.                         size = 13;
  862.                         levels = 9;
  863.                         break;
  864.                     case 5:
  865.                         size = 15;
  866.                         levels = 13;
  867.                         break;
  868.                     case 6:
  869.                         size = 17;
  870.                         levels = 17;
  871.                         break;
  872.                     case 7:
  873.                     default:
  874.                         size = 19;
  875.                         levels = 25;
  876.                         break;
  877.                     }
  879.                     block_code1 = bitstream_get (state, size);
  880.                     /* Should test return value */
  881.                     decode_blockcode (block_code1, levels, block);
  882.                     block_code2 = bitstream_get (state, size);
  883.                     decode_blockcode (block_code2, levels, &block[4]);
  884.                     for (m=0; m<8; m++)
  885.                         subband_samples[k][l][m] = block[m];
  887.                 }
  888.                 break;
  890.             default: /* Undefined */
  891.                 fprintf (stderr, "Unknown quantization index codebook");
  892.                 return -1;
  893.             }
  895.             /*
  896.              * Account for quantization step and scale factor
  897.              */
  899.             /* Deal with transients */
  900.             if (state->transition_mode[k][l] &&
  901.                 subsubframe >= state->transition_mode[k][l])
  902.                 rscale = quant_step_size * state->scale_factor[k][l][1];
  903.             else
  904.                 rscale = quant_step_size * state->scale_factor[k][l][0];
  906.             /* Adjustment */
  907.             rscale *= state->scalefactor_adj[k][sel];
  908.             for (m=0; m<8; m++) subband_samples[k][l][m] *= rscale;
  910.             /*
  911.              * Inverse ADPCM if in prediction mode
  912.              */
  913.             if (state->prediction_mode[k][l])
  914.             {
  915.                 int n;
  916.                 for (m=0; m<8; m++)
  917.                 {
  918.                     for (n=1; n<=4; n++)
  919.                         if (m-n >= 0)
  920.                             subband_samples[k][l][m] +=
  921.                               (adpcm_vb[state->prediction_vq[k][l]][n-1] *
  922.                                 subband_samples[k][l][m-n]/8192);
  923.                         else if (state->predictor_history)
  924.                             subband_samples[k][l][m] +=
  925.                               (adpcm_vb[state->prediction_vq[k][l]][n-1] *
  926.                                state->subband_samples_hist[k][l][m-n+4]/8192);
  927.                 }
  928.             }
  929.         }
  931.         /*
  932.          * Decode VQ encoded high frequencies
  933.          */
  934.         for (l = state->vq_start_subband[k];
  935.              l < state->subband_activity[k]; l++)
  936.         {
  937.             /* 1 vector -> 32 samples but we only need the 8 samples
  938.              * for this subsubframe. */
  939.             int m;
  941.             if (!state->debug_flag & 0x01)
  942.             {
  943.                 fprintf (stderr, "Stream with high frequencies VQ codingn");
  944.                 state->debug_flag |= 0x01;
  945.             }
  947.             for (m=0; m<8; m++)
  948.             {
  949.                 subband_samples[k][l][m] = 
  950.                     high_freq_vq[state->high_freq_vq[k][l]][subsubframe*8+m]
  951.                         * (double)state->scale_factor[k][l][0] / 16.0;
  952.             }
  953.         }
  954.     }
  956.     /* Check for DSYNC after subsubframe */
  957.     if (state->aspf || subsubframe == state->subsubframes - 1)
  958.     {
  959.         if (0xFFFF == bitstream_get (state, 16)) /* 0xFFFF */
  960.         {
  961. #ifdef DEBUG
  962.             fprintf( stderr, "Got subframe DSYNCn" );
  963. #endif
  964.         }
  965.         else
  966.         {
  967.             fprintf( stderr, "Didn't get subframe DSYNCn" );
  968.         }
  969.     }
  971.     /* Backup predictor history for adpcm */
  972.     for (k = 0; k < state->prim_channels; k++)
  973.     {
  974.         for (l = 0; l < state->vq_start_subband[k] ; l++)
  975.         {
  976.             int m;
  977.             for (m = 0; m < 4; m++)
  978.                 state->subband_samples_hist[k][l][m] =
  979.                     subband_samples[k][l][4+m];
  980.         }
  981.     }
  983.     /* 32 subbands QMF */
  984.     for (k = 0; k < state->prim_channels; k++)
  985.     {
  986.         static double pcm_to_float[8] =
  987.             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};
  989.         qmf_32_subbands (state, k,
  990.                          subband_samples[k],
  991.                          &state->samples[256*k],
  992.           /*WTF ???*/    32768.0*3/2/*pcm_to_float[state->source_pcm_res]*/,
  993.                          0/*state->bias*/);
  994.     }
  996.     /* Down/Up mixing */
  997.     if (state->prim_channels < dts_channels[state->output & DTS_CHANNEL_MASK])
  998.     {
  999.         dts_upmix (state->samples, state->amode, state->output);
  1000.     } else
  1001.     if (state->prim_channels > dts_channels[state->output & DTS_CHANNEL_MASK])
  1002.     {
  1003.         dts_downmix (state->samples, state->amode, state->output, state->bias,
  1004.                      state->clev, state->slev);
  1005.     }
  1007.     /* Generate LFE samples for this subsubframe FIXME!!! */
  1008.     if (state->output & DTS_LFE)
  1009.     {
  1010.         int lfe_samples = 2 * state->lfe * state->subsubframes;
  1011.         int i_channels = dts_channels[state->output & DTS_CHANNEL_MASK];
  1013.         lfe_interpolation_fir (state->lfe, 2 * state->lfe,
  1014.                                state->lfe_data + lfe_samples +
  1015.                                2 * state->lfe * subsubframe,
  1016.                                &state->samples[256*i_channels],
  1017.                                8388608.0, state->bias);
  1018.         /* Outputs 20bits pcm samples */
  1019.     }
  1021.     return 0;
  1022. }
  1024. int dts_subframe_footer (dts_state_t * state)
  1025. {
  1026.     int aux_data_count = 0, i;
  1027.     int lfe_samples;
  1029.     /*
  1030.      * Unpack optional information
  1031.      */
  1033.     /* Time code stamp */
  1034.     if (state->timestamp) bitstream_get (state, 32);
  1036.     /* Auxiliary data byte count */
  1037.     if (state->aux_data) aux_data_count = bitstream_get (state, 6);
  1039.     /* Auxiliary data bytes */
  1040.     for(i = 0; i < aux_data_count; i++)
  1041.         bitstream_get (state, 8);
  1043.     /* Optional CRC check bytes */
  1044.     if (state->crc_present && (state->downmix || state->dynrange))
  1045.         bitstream_get (state, 16);
  1047.     /* Backup LFE samples history */
  1048.     lfe_samples = 2 * state->lfe * state->subsubframes;
  1049.     for (i = 0; i < lfe_samples; i++)
  1050.     {
  1051.         state->lfe_data[i] = state->lfe_data[i+lfe_samples];
  1052.     }
  1054. #ifdef DEBUG
  1055.     fprintf( stderr, "n" );
  1056. #endif
  1058.     return 0;
  1059. }
  1061. int dts_block (dts_state_t * state)
  1062. {
  1063.     /* Sanity check */
  1064.     if (state->current_subframe >= state->subframes)
  1065.     {
  1066.         fprintf (stderr, "check failed: %i>%i",
  1067.                  state->current_subframe, state->subframes);
  1068.         return -1;
  1069.     }
  1071.     if (!state->current_subsubframe)
  1072.     {
  1073. #ifdef DEBUG
  1074.         fprintf (stderr, "DSYNC dts_subframe_headern");
  1075. #endif
  1076.         /* Read subframe header */
  1077.         if (dts_subframe_header (state)) return -1;
  1078.     }
  1080.     /* Read subsubframe */
  1081. #ifdef DEBUG
  1082.     fprintf (stderr, "DSYNC dts_subsubframen");
  1083. #endif
  1084.     if (dts_subsubframe (state)) return -1;
  1086.     /* Update state */
  1087.     state->current_subsubframe++;
  1088.     if (state->current_subsubframe >= state->subsubframes)
  1089.     {
  1090.         state->current_subsubframe = 0;
  1091.         state->current_subframe++;
  1092.     }
  1093.     if (state->current_subframe >= state->subframes)
  1094.     {
  1095. #ifdef DEBUG
  1096.         fprintf(stderr, "DSYNC dts_subframe_footern");
  1097. #endif
  1098.         /* Read subframe footer */
  1099.         if (dts_subframe_footer (state)) return -1;
  1100.     }
  1102.     return 0;
  1103. }
  1105. /* Very compact version of the block code decoder that does not use table
  1106.  * look-up but is slightly slower */
  1107. int decode_blockcode( int code, int levels, int *values )
  1108. { 
  1109.     int i;
  1110.     int offset = (levels - 1) >> 1;
  1112.     for (i = 0; i < 4; i++)
  1113.     {
  1114.         values[i] = (code % levels) - offset;
  1115.         code /= levels;
  1116.     }
  1118.     if (code == 0)
  1119.         return 1;
  1120.     else
  1121.     {
  1122.         fprintf (stderr, "ERROR: block code look-up failedn");
  1123.         return 0;
  1124.     }
  1125. }
  1127. static void pre_calc_cosmod( dts_state_t * state )
  1128. {
  1129.     int i, j, k;
  1131.     for (j=0,k=0;k<16;k++)
  1132.         for (i=0;i<16;i++)
  1133.             state->cos_mod[j++] = cos((2*i+1)*(2*k+1)*M_PI/64);
  1135.     for (k=0;k<16;k++)
  1136.         for (i=0;i<16;i++)
  1137.             state->cos_mod[j++] = cos((i)*(2*k+1)*M_PI/32);
  1139.     for (k=0;k<16;k++)
  1140.         state->cos_mod[j++] = 0.25/(2*cos((2*k+1)*M_PI/128));
  1142.     for (k=0;k<16;k++)
  1143.         state->cos_mod[j++] = -0.25/(2.0*sin((2*k+1)*M_PI/128));
  1144. }
  1146. static void qmf_32_subbands (dts_state_t * state, int chans,
  1147.                              double samples_in[32][8], sample_t *samples_out,
  1148.                              double scale, sample_t bias)
  1149. {
  1150.     double *prCoeff;
  1151.     int i, j, k;
  1152.     double raXin[32];
  1154.     double *subband_fir_hist = state->subband_fir_hist[chans];
  1155.     double *subband_fir_hist2 = state->subband_fir_noidea[chans];
  1157.     int nChIndex = 0, NumSubband = 32, nStart = 0, nEnd = 8, nSubIndex;
  1159.     /* Select filter */
  1160.     if (!state->multirate_inter) /* Non-perfect reconstruction */
  1161.         prCoeff = fir_32bands_nonperfect;
  1162.     else /* Perfect reconstruction */
  1163.         prCoeff = fir_32bands_perfect;
  1165.     /* Reconstructed channel sample index */
  1166.     for (nSubIndex=nStart; nSubIndex<nEnd; nSubIndex++)
  1167.     {
  1168.         double A[16], B[16], SUM[16], DIFF[16];
  1170.         /* Load in one sample from each subband */
  1171.         for (i=0; i<state->subband_activity[chans]; i++)
  1172.             raXin[i] = samples_in[i][nSubIndex];
  1174.         /* Clear inactive subbands */
  1175.         for (i=state->subband_activity[chans]; i<NumSubband; i++)
  1176.             raXin[i] = 0.0;
  1178.         /* Multiply by cosine modulation coefficients and
  1179.          * create temporary arrays SUM and DIFF */
  1180.         for (j=0,k=0;k<16;k++)
  1181.         {
  1182.             A[k] = 0.0;
  1183.             for (i=0;i<16;i++)
  1184.                 A[k]+=(raXin[2*i]+raXin[2*i+1])*state->cos_mod[j++];
  1185.         }
  1187.         for (k=0;k<16;k++)
  1188.         {
  1189.             B[k] = 0.0;
  1190.             for (i=0;i<16;i++)
  1191.             {
  1192.                 if(i>0) B[k]+=(raXin[2*i]+raXin[2*i-1])*state->cos_mod[j++];
  1193.                 else B[k]+=(raXin[2*i])*state->cos_mod[j++];
  1194.             }
  1195.             SUM[k]=A[k]+B[k];
  1196.             DIFF[k]=A[k]-B[k];
  1197.         }
  1199.         /* Store history */
  1200.         for (k=0;k<16;k++)
  1201.             subband_fir_hist[k]=state->cos_mod[j++]*SUM[k];
  1202.         for (k=0;k<16;k++)
  1203.             subband_fir_hist[32-k-1]=state->cos_mod[j++]*DIFF[k];
  1204.         /* Multiply by filter coefficients */
  1205.         for (k=31,i=0;i<32;i++,k--)
  1206.             for (j=0;j<512;j+=64)
  1207.                 subband_fir_hist2[i] += prCoeff[i+j]*
  1208.                    (subband_fir_hist[i+j] - subband_fir_hist[j+k]);
  1209.         for (k=31,i=0;i<32;i++,k--)
  1210.             for (j=0;j<512;j+=64)
  1211.                 subband_fir_hist2[32+i] += prCoeff[32+i+j]*
  1212.                     (-subband_fir_hist[i+j] - subband_fir_hist[j+k]);
  1214.         /* Create 32 PCM output samples */
  1215.         for (i=0;i<32;i++)
  1216.             samples_out[nChIndex++] = subband_fir_hist2[i] / scale + bias;
  1218.         /* Update working arrays */
  1219.         for (i=511;i>=32;i--)
  1220.             subband_fir_hist[i] = subband_fir_hist[i-32];
  1221.         for (i=0;i<NumSubband;i++)
  1222.             subband_fir_hist2[i] = subband_fir_hist2[i+32];
  1223.         for (i=0;i<NumSubband;i++)
  1224.             subband_fir_hist2[i+32] = 0.0;
  1225.     }
  1226. }
  1228. static void lfe_interpolation_fir (int nDecimationSelect, int nNumDeciSample,
  1229.                                    double *samples_in, sample_t *samples_out,
  1230.                                    double scale, sample_t bias)
  1231. {
  1232.     /* samples_in: An array holding decimated samples.
  1233.      *   Samples in current subframe starts from samples_in[0],
  1234.      *   while samples_in[-1], samples_in[-2], ..., stores samples
  1235.      *   from last subframe as history.
  1236.      *
  1237.      * samples_out: An array holding interpolated samples
  1238.      */
  1240.     int nDeciFactor, k, J;
  1241.     double *prCoeff;
  1243.     int NumFIRCoef = 512; /* Number of FIR coefficients */
  1244.     int nInterpIndex = 0; /* Index to the interpolated samples */
  1245.     int nDeciIndex;
  1247.     /* Select decimation filter */
  1248.     if (nDecimationSelect==1)
  1249.     {
  1250.         /* 128 decimation */
  1251.         nDeciFactor = 128;
  1252.         /* Pointer to the FIR coefficients array */
  1253.         prCoeff = lfe_fir_128;
  1254.     } else {
  1255.         /* 64 decimation */
  1256.         nDeciFactor = 64;
  1257.         prCoeff = lfe_fir_64;
  1258.     }
  1260.     /* Interpolation */
  1261.     for (nDeciIndex=0; nDeciIndex<nNumDeciSample; nDeciIndex++)
  1262.     {
  1263.         /* One decimated sample generates nDeciFactor interpolated ones */
  1264.         for (k=0; k<nDeciFactor; k++)
  1265.         {
  1266.             /* Clear accumulation */
  1267.             double rTmp = 0.0;
  1269.             /* Accumulate */
  1270.             for (J=0; J<NumFIRCoef/nDeciFactor; J++)
  1271.                 rTmp += samples_in[nDeciIndex-J]*prCoeff[k+J*nDeciFactor];
  1273.             /* Save interpolated samples */
  1274.             samples_out[nInterpIndex++] = rTmp / scale + bias;
  1275.         }
  1276.     }
  1277. }
  1279. void dts_dynrng (dts_state_t * state,
  1280.                  level_t (* call) (level_t, void *), void * data)
  1281. {
  1282.     state->dynrange = 0;
  1283.     if (call) {
  1284.         state->dynrange = 1;
  1285.         state->dynrngcall = call;
  1286.         state->dynrngdata = data;
  1287.     }
  1288. }
  1290. void dts_free (dts_state_t * state)
  1291. {
  1292.     free (state->samples);
  1293.     free (state);
  1294. }