libdts support by (Benjamin Zores <ben at geexbox dot org>)
[ffmpeg.git] / 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 };