10034
|
1 /*
|
29238
|
2 * Realaudio demuxer
|
|
3 * copyright (c) 2003, 2005 Roberto Togni
|
|
4 *
|
|
5 * This file is part of MPlayer.
|
|
6 *
|
|
7 * MPlayer is free software; you can redistribute it and/or modify
|
|
8 * it under the terms of the GNU General Public License as published by
|
|
9 * the Free Software Foundation; either version 2 of the License, or
|
|
10 * (at your option) any later version.
|
|
11 *
|
|
12 * MPlayer 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
|
|
15 * GNU General Public License for more details.
|
|
16 *
|
|
17 * You should have received a copy of the GNU General Public License along
|
|
18 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
20 */
|
10034
|
21
|
|
22 #include <stdio.h>
|
|
23 #include <stdlib.h>
|
|
24 #include <unistd.h>
|
|
25
|
|
26 #include "config.h"
|
|
27 #include "mp_msg.h"
|
|
28 #include "help_mp.h"
|
|
29
|
22605
|
30 #include "stream/stream.h"
|
30589
|
31 #include "aviprint.h"
|
10034
|
32 #include "demuxer.h"
|
|
33 #include "stheader.h"
|
|
34
|
|
35
|
|
36 #define FOURCC_DOTRA mmioFOURCC('.','r','a', 0xfd)
|
|
37 #define FOURCC_144 mmioFOURCC('1','4','_','4')
|
|
38 #define FOURCC_288 mmioFOURCC('2','8','_','8')
|
|
39 #define FOURCC_DNET mmioFOURCC('d','n','e','t')
|
|
40 #define FOURCC_LPCJ mmioFOURCC('l','p','c','J')
|
17400
|
41 #define FOURCC_SIPR mmioFOURCC('s','i','p','r')
|
21987
|
42 #define INTLID_INT4 mmioFOURCC('I','n','t','4')
|
|
43 #define INTLID_SIPR mmioFOURCC('s','i','p','r')
|
17400
|
44
|
|
45
|
|
46 static unsigned char sipr_swaps[38][2]={
|
|
47 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
|
|
48 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
|
|
49 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
|
|
50 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
|
|
51 {77,80} };
|
|
52
|
|
53 // Map flavour to bytes per second
|
|
54 static int sipr_fl2bps[4] = {813, 1062, 625, 2000}; // 6.5, 8.5, 5, 16 kbit per second
|
10034
|
55
|
|
56
|
|
57 typedef struct {
|
|
58 unsigned short version;
|
|
59 unsigned int dotranum;
|
|
60 unsigned int data_size;
|
|
61 unsigned short version2;
|
|
62 unsigned int hdr_size;
|
|
63 unsigned short codec_flavor;
|
|
64 unsigned int coded_framesize;
|
|
65 unsigned short sub_packet_h;
|
|
66 unsigned short frame_size;
|
|
67 unsigned short sub_packet_size;
|
21987
|
68 unsigned intl_id;
|
17400
|
69 unsigned char *audio_buf;
|
10034
|
70 } ra_priv_t;
|
|
71
|
|
72
|
|
73
|
16175
|
74 static int ra_check_file(demuxer_t* demuxer)
|
10034
|
75 {
|
|
76 unsigned int chunk_id;
|
29263
|
77
|
10034
|
78 chunk_id = stream_read_dword_le(demuxer->stream);
|
|
79 if (chunk_id == FOURCC_DOTRA)
|
16175
|
80 return DEMUXER_TYPE_REALAUDIO;
|
10034
|
81 else
|
|
82 return 0;
|
|
83 }
|
|
84
|
|
85
|
|
86
|
|
87 // return value:
|
|
88 // 0 = EOF or no stream found
|
|
89 // 1 = successfully read a packet
|
16175
|
90 static int demux_ra_fill_buffer(demuxer_t *demuxer, demux_stream_t *dsds)
|
10034
|
91 {
|
|
92 ra_priv_t *ra_priv = demuxer->priv;
|
|
93 int len;
|
|
94 demux_stream_t *ds = demuxer->audio;
|
|
95 sh_audio_t *sh = ds->sh;
|
|
96 WAVEFORMATEX *wf = sh->wf;
|
|
97 demux_packet_t *dp;
|
17149
|
98 int x, y;
|
10034
|
99
|
|
100 if (demuxer->stream->eof)
|
|
101 return 0;
|
|
102
|
|
103 len = wf->nBlockAlign;
|
|
104 demuxer->filepos = stream_tell(demuxer->stream);
|
|
105
|
21987
|
106 if ((ra_priv->intl_id == INTLID_INT4) || (ra_priv->intl_id == INTLID_SIPR)) {
|
|
107 if (ra_priv->intl_id == INTLID_SIPR) {
|
17400
|
108 int n;
|
|
109 int bs = ra_priv->sub_packet_h * ra_priv->frame_size * 2 / 96; // nibbles per subpacket
|
|
110 stream_read(demuxer->stream, ra_priv->audio_buf, ra_priv->sub_packet_h * ra_priv->frame_size);
|
|
111 // Perform reordering
|
|
112 for(n = 0; n < 38; n++) {
|
|
113 int j;
|
|
114 int i = bs * sipr_swaps[n][0];
|
|
115 int o = bs * sipr_swaps[n][1];
|
|
116 // swap nibbles of block 'i' with 'o' TODO: optimize
|
|
117 for(j = 0; j < bs; j++) {
|
|
118 int x = (i & 1) ? (ra_priv->audio_buf[i >> 1] >> 4) : (ra_priv->audio_buf[i >> 1] & 0x0F);
|
|
119 int y = (o & 1) ? (ra_priv->audio_buf[o >> 1] >> 4) : (ra_priv->audio_buf[o >> 1] & 0x0F);
|
|
120 if(o & 1)
|
|
121 ra_priv->audio_buf[o >> 1] = (ra_priv->audio_buf[o >> 1] & 0x0F) | (x << 4);
|
|
122 else
|
|
123 ra_priv->audio_buf[o >> 1] = (ra_priv->audio_buf[o >> 1] & 0xF0) | x;
|
|
124 if(i & 1)
|
|
125 ra_priv->audio_buf[i >> 1] = (ra_priv->audio_buf[i >> 1] & 0x0F) | (y << 4);
|
|
126 else
|
|
127 ra_priv->audio_buf[i >> 1] = (ra_priv->audio_buf[i >> 1] & 0xF0) | y;
|
|
128 ++i; ++o;
|
|
129 }
|
|
130 }
|
|
131 } else {
|
17149
|
132 for (y = 0; y < ra_priv->sub_packet_h; y++)
|
|
133 for (x = 0; x < ra_priv->sub_packet_h / 2; x++)
|
|
134 stream_read(demuxer->stream, ra_priv->audio_buf + x * 2 *ra_priv->frame_size +
|
|
135 y * ra_priv->coded_framesize, ra_priv->coded_framesize);
|
17400
|
136 }
|
17149
|
137 // Release all the audio packets
|
|
138 for (x = 0; x < ra_priv->sub_packet_h * ra_priv->frame_size / len; x++) {
|
|
139 dp = new_demux_packet(len);
|
|
140 memcpy(dp->buffer, ra_priv->audio_buf + x * len, len);
|
|
141 dp->pts = x ? 0 : demuxer->filepos / ra_priv->data_size;
|
|
142 dp->pos = demuxer->filepos; // all equal
|
|
143 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
|
|
144 ds_add_packet(ds, dp);
|
|
145 }
|
|
146 } else {
|
10034
|
147 dp = new_demux_packet(len);
|
|
148 stream_read(demuxer->stream, dp->buffer, len);
|
|
149
|
10035
|
150 dp->pts = demuxer->filepos / ra_priv->data_size;
|
10034
|
151 dp->pos = demuxer->filepos;
|
|
152 dp->flags = 0;
|
|
153 ds_add_packet(ds, dp);
|
17149
|
154 }
|
10034
|
155
|
|
156 return 1;
|
|
157 }
|
|
158
|
|
159
|
|
160
|
16175
|
161 static demuxer_t* demux_open_ra(demuxer_t* demuxer)
|
10034
|
162 {
|
|
163 ra_priv_t* ra_priv = demuxer->priv;
|
|
164 sh_audio_t *sh;
|
|
165 int i;
|
|
166 char *buf;
|
|
167
|
19062
|
168 if ((ra_priv = malloc(sizeof(ra_priv_t))) == NULL) {
|
10034
|
169 mp_msg(MSGT_DEMUX, MSGL_ERR, "[RealAudio] Can't allocate memory for private data.\n");
|
10232
|
170 return 0;
|
10034
|
171 }
|
|
172 memset(ra_priv, 0, sizeof(ra_priv_t));
|
|
173
|
|
174 demuxer->priv = ra_priv;
|
31609
|
175 sh = new_sh_audio(demuxer, 0, NULL);
|
10034
|
176 demuxer->audio->id = 0;
|
|
177 sh->ds=demuxer->audio;
|
|
178 demuxer->audio->sh = sh;
|
|
179
|
|
180 ra_priv->version = stream_read_word(demuxer->stream);
|
|
181 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] File version: %d\n", ra_priv->version);
|
|
182 if ((ra_priv->version < 3) || (ra_priv->version > 4)) {
|
|
183 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] ra version %d is not supported yet, please "
|
|
184 "contact MPlayer developers\n", ra_priv->version);
|
10232
|
185 return 0;
|
10034
|
186 }
|
|
187 if (ra_priv->version == 3) {
|
|
188 ra_priv->hdr_size = stream_read_word(demuxer->stream);
|
|
189 stream_skip(demuxer->stream, 10);
|
|
190 ra_priv->data_size = stream_read_dword(demuxer->stream);
|
|
191 } else {
|
|
192 stream_skip(demuxer->stream, 2);
|
|
193 ra_priv->dotranum = stream_read_dword(demuxer->stream);
|
|
194 ra_priv->data_size = stream_read_dword(demuxer->stream);
|
|
195 ra_priv->version2 = stream_read_word(demuxer->stream);
|
|
196 ra_priv->hdr_size = stream_read_dword(demuxer->stream);
|
|
197 ra_priv->codec_flavor = stream_read_word(demuxer->stream);
|
17400
|
198 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Flavor: %d\n", ra_priv->codec_flavor);
|
10034
|
199 ra_priv->coded_framesize = stream_read_dword(demuxer->stream);
|
17400
|
200 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Coded frame size: %d\n", ra_priv->coded_framesize);
|
10034
|
201 stream_skip(demuxer->stream, 4); // data size?
|
|
202 stream_skip(demuxer->stream, 8);
|
|
203 ra_priv->sub_packet_h = stream_read_word(demuxer->stream);
|
17400
|
204 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Sub packet h: %d\n", ra_priv->sub_packet_h);
|
10034
|
205 ra_priv->frame_size = stream_read_word(demuxer->stream);
|
|
206 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Frame size: %d\n", ra_priv->frame_size);
|
|
207 ra_priv->sub_packet_size = stream_read_word(demuxer->stream);
|
|
208 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Sub packet size: %d\n", ra_priv->sub_packet_size);
|
|
209 stream_skip(demuxer->stream, 2);
|
|
210 sh->samplerate = stream_read_word(demuxer->stream);
|
|
211 stream_skip(demuxer->stream, 2);
|
|
212 sh->samplesize = stream_read_word(demuxer->stream);
|
|
213 sh->channels = stream_read_word(demuxer->stream);
|
|
214 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] %d channel, %d bit, %dHz\n", sh->channels,
|
|
215 sh->samplesize, sh->samplerate);
|
|
216 i = stream_read_char(demuxer->stream);
|
21987
|
217 ra_priv->intl_id = stream_read_dword_le(demuxer->stream);
|
10034
|
218 if (i != 4) {
|
21987
|
219 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] Interleaver Id size is not 4 (%d), please report to "
|
10034
|
220 "MPlayer developers\n", i);
|
|
221 stream_skip(demuxer->stream, i - 4);
|
|
222 }
|
|
223 i = stream_read_char(demuxer->stream);
|
|
224 sh->format = stream_read_dword_le(demuxer->stream);
|
|
225 if (i != 4) {
|
|
226 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] FourCC size is not 4 (%d), please report to "
|
|
227 "MPlayer developers\n", i);
|
|
228 stream_skip(demuxer->stream, i - 4);
|
|
229 }
|
|
230 stream_skip(demuxer->stream, 3);
|
|
231 }
|
|
232
|
|
233 if ((i = stream_read_char(demuxer->stream)) != 0) {
|
|
234 buf = malloc(i+1);
|
|
235 stream_read(demuxer->stream, buf, i);
|
|
236 buf[i] = 0;
|
|
237 demux_info_add(demuxer, "Title", buf);
|
|
238 free(buf);
|
|
239 }
|
|
240 if ((i = stream_read_char(demuxer->stream)) != 0) {
|
|
241 buf = malloc(i+1);
|
|
242 stream_read(demuxer->stream, buf, i);
|
|
243 buf[i] = 0;
|
|
244 demux_info_add(demuxer, "Author", buf);
|
|
245 free(buf);
|
|
246 }
|
|
247 if ((i = stream_read_char(demuxer->stream)) != 0) {
|
|
248 buf = malloc(i+1);
|
|
249 stream_read(demuxer->stream, buf, i);
|
|
250 buf[i] = 0;
|
|
251 demux_info_add(demuxer, "Copyright", buf);
|
|
252 free(buf);
|
|
253 }
|
|
254
|
14908
|
255 if ((i = stream_read_char(demuxer->stream)) != 0) {
|
|
256 buf = malloc(i+1);
|
|
257 stream_read(demuxer->stream, buf, i);
|
|
258 buf[i] = 0;
|
|
259 demux_info_add(demuxer, "Comment", buf);
|
|
260 free(buf);
|
|
261 }
|
10034
|
262
|
|
263 if (ra_priv->version == 3) {
|
14909
|
264 if(ra_priv->hdr_size + 8 > stream_tell(demuxer->stream)) {
|
10034
|
265 stream_skip(demuxer->stream, 1);
|
|
266 i = stream_read_char(demuxer->stream);
|
|
267 sh->format = stream_read_dword_le(demuxer->stream);
|
|
268 if (i != 4) {
|
|
269 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] FourCC size is not 4 (%d), please report to "
|
|
270 "MPlayer developers\n", i);
|
|
271 stream_skip(demuxer->stream, i - 4);
|
|
272 }
|
|
273
|
|
274 if (sh->format != FOURCC_LPCJ) {
|
|
275 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] Version 3 with FourCC %8x, please report to "
|
|
276 "MPlayer developers\n", sh->format);
|
|
277 }
|
14909
|
278 } else
|
|
279 // If a stream does not have fourcc, let's assume it's 14.4
|
|
280 sh->format = FOURCC_LPCJ;
|
10034
|
281
|
|
282 sh->channels = 1;
|
|
283 sh->samplesize = 16;
|
|
284 sh->samplerate = 8000;
|
|
285 ra_priv->frame_size = 240;
|
|
286 sh->format = FOURCC_144;
|
|
287 }
|
|
288
|
|
289 /* Fill WAVEFORMATEX */
|
32111
|
290 sh->wf = calloc(1, sizeof(*sh->wf));
|
10034
|
291 sh->wf->nChannels = sh->channels;
|
|
292 sh->wf->wBitsPerSample = sh->samplesize;
|
|
293 sh->wf->nSamplesPerSec = sh->samplerate;
|
|
294 sh->wf->nAvgBytesPerSec = sh->samplerate*sh->samplesize/8;
|
|
295 sh->wf->nBlockAlign = ra_priv->frame_size;
|
|
296 sh->wf->cbSize = 0;
|
|
297 sh->wf->wFormatTag = sh->format;
|
|
298
|
|
299 switch (sh->format) {
|
|
300 case FOURCC_144:
|
|
301 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: 14_4\n");
|
17149
|
302 sh->wf->nBlockAlign = 0x14;
|
10034
|
303 break;
|
|
304 case FOURCC_288:
|
|
305 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: 28_8\n");
|
17149
|
306 sh->wf->nBlockAlign = ra_priv->coded_framesize;
|
18505
|
307 ra_priv->audio_buf = calloc(ra_priv->sub_packet_h, ra_priv->frame_size);
|
10034
|
308 break;
|
|
309 case FOURCC_DNET:
|
|
310 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: DNET -> AC3\n");
|
|
311 break;
|
17400
|
312 case FOURCC_SIPR:
|
|
313 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: SIPR\n");
|
|
314 sh->wf->nBlockAlign = ra_priv->coded_framesize;
|
|
315 sh->wf->nAvgBytesPerSec = sipr_fl2bps[ra_priv->codec_flavor];
|
18505
|
316 ra_priv->audio_buf = calloc(ra_priv->sub_packet_h, ra_priv->frame_size);
|
17400
|
317 break;
|
10034
|
318 default:
|
|
319 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: Unknown (%d)\n", sh->format);
|
|
320 }
|
|
321
|
17977
|
322 print_wave_header(sh->wf, MSGL_V);
|
10034
|
323
|
|
324 /* disable seeking */
|
|
325 demuxer->seekable = 0;
|
|
326
|
|
327 if(!ds_fill_buffer(demuxer->audio))
|
|
328 mp_msg(MSGT_DEMUXER,MSGL_INFO,"[RealAudio] No data.\n");
|
10232
|
329
|
16175
|
330 return demuxer;
|
10034
|
331 }
|
|
332
|
|
333
|
|
334
|
16175
|
335 static void demux_close_ra(demuxer_t *demuxer)
|
10034
|
336 {
|
32537
|
337 ra_priv_t* ra_priv = demuxer->priv;
|
29263
|
338
|
17149
|
339 if (ra_priv) {
|
32537
|
340 free(ra_priv->audio_buf);
|
|
341 free(ra_priv);
|
17149
|
342 }
|
10034
|
343 }
|
|
344
|
|
345
|
|
346 #if 0
|
|
347 /* please upload RV10 samples WITH INDEX CHUNK */
|
17636
|
348 int demux_seek_ra(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
|
10034
|
349 {
|
|
350 real_priv_t *priv = demuxer->priv;
|
|
351 demux_stream_t *d_audio = demuxer->audio;
|
|
352 sh_audio_t *sh_audio = d_audio->sh;
|
|
353 int aid = d_audio->id;
|
|
354 int next_offset = 0;
|
|
355 int rel_seek_frames = 0;
|
|
356 int streams = 0;
|
|
357
|
|
358 return stream_seek(demuxer->stream, next_offset);
|
|
359 }
|
|
360 #endif
|
16175
|
361
|
|
362
|
25707
|
363 const demuxer_desc_t demuxer_desc_realaudio = {
|
16175
|
364 "Realaudio demuxer",
|
|
365 "realaudio",
|
|
366 "REALAUDIO",
|
|
367 "Roberto Togni",
|
|
368 "handles old audio only .ra files",
|
|
369 DEMUXER_TYPE_REALAUDIO,
|
|
370 1, // safe autodetect
|
|
371 ra_check_file,
|
|
372 demux_ra_fill_buffer,
|
|
373 demux_open_ra,
|
|
374 demux_close_ra,
|
|
375 NULL,
|
|
376 NULL
|
|
377 };
|