0
|
1 /*
|
|
2 * AC3 decoder
|
|
3 * Copyright (c) 2001 Gerard Lantau.
|
|
4 *
|
|
5 * This program is free software; you can redistribute it and/or modify
|
|
6 * it under the terms of the GNU General Public License as published by
|
|
7 * the Free Software Foundation; either version 2 of the License, or
|
|
8 * (at your option) any later version.
|
|
9 *
|
|
10 * This program is distributed in the hope that it will be useful,
|
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
13 * GNU General Public License for more details.
|
|
14 *
|
|
15 * You should have received a copy of the GNU General Public License
|
|
16 * along with this program; if not, write to the Free Software
|
|
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
18 */
|
|
19 #include "avcodec.h"
|
|
20 #include "libac3/ac3.h"
|
|
21
|
|
22 /* currently, I use libac3 which is Copyright (C) Aaron Holtzman and
|
|
23 released under the GPL license. I may reimplement it someday... */
|
|
24 typedef struct AC3DecodeState {
|
|
25 UINT8 inbuf[4096]; /* input buffer */
|
|
26 UINT8 *inbuf_ptr;
|
|
27 int frame_size;
|
|
28 int flags;
|
314
|
29 int channels;
|
0
|
30 ac3_state_t state;
|
|
31 } AC3DecodeState;
|
|
32
|
|
33 static int ac3_decode_init(AVCodecContext *avctx)
|
|
34 {
|
|
35 AC3DecodeState *s = avctx->priv_data;
|
|
36
|
|
37 ac3_init ();
|
|
38 s->inbuf_ptr = s->inbuf;
|
|
39 s->frame_size = 0;
|
|
40 return 0;
|
|
41 }
|
|
42
|
|
43 stream_samples_t samples;
|
|
44
|
|
45 /**** the following two functions comes from ac3dec */
|
|
46 static inline int blah (int32_t i)
|
|
47 {
|
|
48 if (i > 0x43c07fff)
|
|
49 return 32767;
|
|
50 else if (i < 0x43bf8000)
|
|
51 return -32768;
|
|
52 else
|
|
53 return i - 0x43c00000;
|
|
54 }
|
|
55
|
314
|
56 static inline void float_to_int (float * _f, INT16 * s16, int nchannels)
|
0
|
57 {
|
314
|
58 int i, j, c;
|
0
|
59 int32_t * f = (int32_t *) _f; // XXX assumes IEEE float format
|
|
60
|
314
|
61 j = 0;
|
|
62 nchannels *= 256;
|
0
|
63 for (i = 0; i < 256; i++) {
|
314
|
64 for (c = 0; c < nchannels; c += 256)
|
|
65 s16[j++] = blah (f[i + c]);
|
0
|
66 }
|
|
67 }
|
|
68
|
|
69 /**** end */
|
|
70
|
|
71 #define HEADER_SIZE 7
|
|
72
|
|
73 static int ac3_decode_frame(AVCodecContext *avctx,
|
|
74 void *data, int *data_size,
|
|
75 UINT8 *buf, int buf_size)
|
|
76 {
|
|
77 AC3DecodeState *s = avctx->priv_data;
|
|
78 UINT8 *buf_ptr;
|
|
79 int flags, i, len;
|
|
80 int sample_rate, bit_rate;
|
|
81 short *out_samples = data;
|
|
82 float level;
|
314
|
83 static int ac3_channels[8] = {
|
|
84 2, 1, 2, 3, 3, 4, 4, 5
|
|
85 };
|
0
|
86
|
|
87 *data_size = 0;
|
|
88 buf_ptr = buf;
|
|
89 while (buf_size > 0) {
|
|
90 len = s->inbuf_ptr - s->inbuf;
|
|
91 if (s->frame_size == 0) {
|
|
92 /* no header seen : find one. We need at least 7 bytes to parse it */
|
|
93 len = HEADER_SIZE - len;
|
|
94 if (len > buf_size)
|
|
95 len = buf_size;
|
|
96 memcpy(s->inbuf_ptr, buf_ptr, len);
|
|
97 buf_ptr += len;
|
|
98 s->inbuf_ptr += len;
|
|
99 buf_size -= len;
|
|
100 if ((s->inbuf_ptr - s->inbuf) == HEADER_SIZE) {
|
|
101 len = ac3_syncinfo (s->inbuf, &s->flags, &sample_rate, &bit_rate);
|
|
102 if (len == 0) {
|
|
103 /* no sync found : move by one byte (inefficient, but simple!) */
|
|
104 memcpy(s->inbuf, s->inbuf + 1, HEADER_SIZE - 1);
|
|
105 s->inbuf_ptr--;
|
|
106 } else {
|
|
107 s->frame_size = len;
|
|
108 /* update codec info */
|
|
109 avctx->sample_rate = sample_rate;
|
314
|
110 s->channels = ac3_channels[s->flags & 7];
|
|
111 if (s->flags & AC3_LFE)
|
|
112 s->channels++;
|
|
113 if (s->channels < avctx->channels) {
|
|
114 fprintf(stderr, "Source channels are less than specified: output to %d channels..\n", s->channels);
|
|
115 avctx->channels = s->channels;
|
|
116 }
|
0
|
117 avctx->bit_rate = bit_rate;
|
|
118 }
|
|
119 }
|
|
120 } else if (len < s->frame_size) {
|
|
121 len = s->frame_size - len;
|
|
122 if (len > buf_size)
|
|
123 len = buf_size;
|
|
124
|
|
125 memcpy(s->inbuf_ptr, buf_ptr, len);
|
|
126 buf_ptr += len;
|
|
127 s->inbuf_ptr += len;
|
|
128 buf_size -= len;
|
|
129 } else {
|
314
|
130 #if 0
|
0
|
131 if (avctx->channels == 1)
|
|
132 flags = AC3_MONO;
|
|
133 else
|
|
134 flags = AC3_STEREO;
|
314
|
135 #else
|
|
136 flags = s->flags;
|
|
137 #endif
|
0
|
138 flags |= AC3_ADJUST_LEVEL;
|
|
139 level = 1;
|
|
140 if (ac3_frame (&s->state, s->inbuf, &flags, &level, 384)) {
|
|
141 fail:
|
|
142 s->inbuf_ptr = s->inbuf;
|
|
143 s->frame_size = 0;
|
|
144 continue;
|
|
145 }
|
|
146 for (i = 0; i < 6; i++) {
|
|
147 if (ac3_block (&s->state))
|
|
148 goto fail;
|
314
|
149 float_to_int (*samples, out_samples + i * 256 * avctx->channels, avctx->channels);
|
0
|
150 }
|
|
151 s->inbuf_ptr = s->inbuf;
|
|
152 s->frame_size = 0;
|
|
153 *data_size = 6 * avctx->channels * 256 * sizeof(INT16);
|
|
154 break;
|
|
155 }
|
|
156 }
|
|
157 return buf_ptr - buf;
|
|
158 }
|
|
159
|
|
160 static int ac3_decode_end(AVCodecContext *s)
|
|
161 {
|
|
162 return 0;
|
|
163 }
|
|
164
|
|
165 AVCodec ac3_decoder = {
|
|
166 "ac3",
|
|
167 CODEC_TYPE_AUDIO,
|
|
168 CODEC_ID_AC3,
|
|
169 sizeof(AC3DecodeState),
|
|
170 ac3_decode_init,
|
|
171 NULL,
|
|
172 ac3_decode_end,
|
|
173 ac3_decode_frame,
|
|
174 };
|