1 /*
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 */
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
30 #include "stream/stream.h"
31 #include "aviprint.h"
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')
41 #define FOURCC_SIPR mmioFOURCC('s','i','p','r')
42 #define INTLID_INT4 mmioFOURCC('I','n','t','4')
43 #define INTLID_SIPR mmioFOURCC('s','i','p','r')
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
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;
68 unsigned intl_id;
69 unsigned char *audio_buf;
70 } ra_priv_t;
71
72
73
ra_check_file(demuxer_t * demuxer)74 static int ra_check_file(demuxer_t* demuxer)
75 {
76 unsigned int chunk_id;
77
78 chunk_id = stream_read_dword_le(demuxer->stream);
79 if (chunk_id == FOURCC_DOTRA)
80 return DEMUXER_TYPE_REALAUDIO;
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
demux_ra_fill_buffer(demuxer_t * demuxer,demux_stream_t * dsds)90 static int demux_ra_fill_buffer(demuxer_t *demuxer, demux_stream_t *dsds)
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;
98 int x, y;
99
100 if (demuxer->stream->eof)
101 return 0;
102
103 len = wf->nBlockAlign;
104 demuxer->filepos = stream_tell(demuxer->stream);
105
106 if ((ra_priv->intl_id == INTLID_INT4) || (ra_priv->intl_id == INTLID_SIPR)) {
107 if (ra_priv->intl_id == INTLID_SIPR) {
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 {
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);
136 }
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 {
147 dp = new_demux_packet(len);
148 stream_read(demuxer->stream, dp->buffer, len);
149
150 dp->pts = demuxer->filepos / ra_priv->data_size;
151 dp->pos = demuxer->filepos;
152 dp->flags = 0;
153 ds_add_packet(ds, dp);
154 }
155
156 return 1;
157 }
158
159
read_demux_info(demuxer_t * demuxer,const char * name)160 static void read_demux_info(demuxer_t *demuxer, const char *name)
161 {
162 char *buf = NULL;
163 int len = stream_read_char(demuxer->stream);
164 if (len <= 0) return;
165 buf = malloc(len+1);
166 if (!buf) return;
167 if (stream_read(demuxer->stream, buf, len) != len) goto out;
168 buf[len] = 0;
169 demux_info_add(demuxer, name, buf);
170 out:
171 free(buf);
172 }
173
demux_open_ra(demuxer_t * demuxer)174 static demuxer_t* demux_open_ra(demuxer_t* demuxer)
175 {
176 ra_priv_t* ra_priv = demuxer->priv;
177 sh_audio_t *sh;
178 int i;
179
180 if ((ra_priv = malloc(sizeof(ra_priv_t))) == NULL) {
181 mp_msg(MSGT_DEMUX, MSGL_ERR, "[RealAudio] Can't allocate memory for private data.\n");
182 return 0;
183 }
184 memset(ra_priv, 0, sizeof(ra_priv_t));
185
186 demuxer->priv = ra_priv;
187 sh = new_sh_audio(demuxer, 0, NULL);
188 demuxer->audio->id = 0;
189 demuxer->audio->sh = sh;
190
191 ra_priv->version = stream_read_word(demuxer->stream);
192 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] File version: %d\n", ra_priv->version);
193 if ((ra_priv->version < 3) || (ra_priv->version > 4)) {
194 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] ra version %d is not supported yet, please "
195 "contact MPlayer developers\n", ra_priv->version);
196 return 0;
197 }
198 if (ra_priv->version == 3) {
199 ra_priv->hdr_size = stream_read_word(demuxer->stream);
200 stream_skip(demuxer->stream, 10);
201 ra_priv->data_size = stream_read_dword(demuxer->stream);
202 } else {
203 stream_skip(demuxer->stream, 2);
204 ra_priv->dotranum = stream_read_dword(demuxer->stream);
205 ra_priv->data_size = stream_read_dword(demuxer->stream);
206 ra_priv->version2 = stream_read_word(demuxer->stream);
207 ra_priv->hdr_size = stream_read_dword(demuxer->stream);
208 ra_priv->codec_flavor = stream_read_word(demuxer->stream);
209 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Flavor: %d\n", ra_priv->codec_flavor);
210 ra_priv->coded_framesize = stream_read_dword(demuxer->stream);
211 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Coded frame size: %d\n", ra_priv->coded_framesize);
212 stream_skip(demuxer->stream, 4); // data size?
213 stream_skip(demuxer->stream, 8);
214 ra_priv->sub_packet_h = stream_read_word(demuxer->stream);
215 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Sub packet h: %d\n", ra_priv->sub_packet_h);
216 ra_priv->frame_size = stream_read_word(demuxer->stream);
217 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Frame size: %d\n", ra_priv->frame_size);
218 ra_priv->sub_packet_size = stream_read_word(demuxer->stream);
219 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] Sub packet size: %d\n", ra_priv->sub_packet_size);
220 stream_skip(demuxer->stream, 2);
221 sh->samplerate = stream_read_word(demuxer->stream);
222 stream_skip(demuxer->stream, 2);
223 sh->samplesize = stream_read_word(demuxer->stream);
224 sh->channels = stream_read_word(demuxer->stream);
225 mp_msg(MSGT_DEMUX,MSGL_V,"[RealAudio] %d channel, %d bit, %dHz\n", sh->channels,
226 sh->samplesize, sh->samplerate);
227 i = stream_read_char(demuxer->stream);
228 ra_priv->intl_id = stream_read_dword_le(demuxer->stream);
229 if (i != 4) {
230 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] Interleaver Id size is not 4 (%d), please report to "
231 "MPlayer developers\n", i);
232 stream_skip(demuxer->stream, i - 4);
233 }
234 i = stream_read_char(demuxer->stream);
235 sh->format = stream_read_dword_le(demuxer->stream);
236 if (i != 4) {
237 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] FourCC size is not 4 (%d), please report to "
238 "MPlayer developers\n", i);
239 stream_skip(demuxer->stream, i - 4);
240 }
241 stream_skip(demuxer->stream, 3);
242 }
243
244 read_demux_info(demuxer, "Title");
245 read_demux_info(demuxer, "Author");
246 read_demux_info(demuxer, "Copyright");
247 read_demux_info(demuxer, "Comment");
248
249 if (ra_priv->version == 3) {
250 if(ra_priv->hdr_size + 8 > stream_tell(demuxer->stream)) {
251 stream_skip(demuxer->stream, 1);
252 i = stream_read_char(demuxer->stream);
253 sh->format = stream_read_dword_le(demuxer->stream);
254 if (i != 4) {
255 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] FourCC size is not 4 (%d), please report to "
256 "MPlayer developers\n", i);
257 stream_skip(demuxer->stream, i - 4);
258 }
259
260 if (sh->format != FOURCC_LPCJ) {
261 mp_msg(MSGT_DEMUX,MSGL_WARN,"[RealAudio] Version 3 with FourCC %8x, please report to "
262 "MPlayer developers\n", sh->format);
263 }
264 } else
265 // If a stream does not have fourcc, let's assume it's 14.4
266 sh->format = FOURCC_LPCJ;
267
268 sh->channels = 1;
269 sh->samplesize = 16;
270 sh->samplerate = 8000;
271 ra_priv->frame_size = 240;
272 sh->format = FOURCC_144;
273 }
274
275 /* Fill WAVEFORMATEX */
276 sh->wf = calloc(1, sizeof(*sh->wf));
277 sh->wf->nChannels = sh->channels;
278 sh->wf->wBitsPerSample = sh->samplesize;
279 sh->wf->nSamplesPerSec = sh->samplerate;
280 sh->wf->nAvgBytesPerSec = sh->samplerate*sh->samplesize/8;
281 sh->wf->nBlockAlign = ra_priv->frame_size;
282 sh->wf->cbSize = 0;
283 sh->wf->wFormatTag = sh->format;
284
285 switch (sh->format) {
286 case FOURCC_144:
287 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: 14_4\n");
288 sh->wf->nBlockAlign = 0x14;
289 break;
290 case FOURCC_288:
291 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: 28_8\n");
292 sh->wf->nBlockAlign = ra_priv->coded_framesize;
293 ra_priv->audio_buf = calloc(ra_priv->sub_packet_h, ra_priv->frame_size);
294 break;
295 case FOURCC_DNET:
296 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: DNET -> AC3\n");
297 break;
298 case FOURCC_SIPR:
299 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: SIPR\n");
300 sh->wf->nBlockAlign = ra_priv->coded_framesize;
301 sh->wf->nAvgBytesPerSec = sipr_fl2bps[ra_priv->codec_flavor];
302 ra_priv->audio_buf = calloc(ra_priv->sub_packet_h, ra_priv->frame_size);
303 break;
304 default:
305 mp_msg(MSGT_DEMUX,MSGL_V,"Audio: Unknown (%d)\n", sh->format);
306 }
307
308 print_wave_header(sh->wf, MSGL_V);
309
310 /* disable seeking */
311 demuxer->seekable = 0;
312
313 if(!ds_fill_buffer(demuxer->audio))
314 mp_msg(MSGT_DEMUXER,MSGL_INFO,"[RealAudio] No data.\n");
315
316 return demuxer;
317 }
318
319
320
demux_close_ra(demuxer_t * demuxer)321 static void demux_close_ra(demuxer_t *demuxer)
322 {
323 ra_priv_t* ra_priv = demuxer->priv;
324
325 if (ra_priv) {
326 free(ra_priv->audio_buf);
327 free(ra_priv);
328 }
329 }
330
331
332 #if 0
333 /* please upload RV10 samples WITH INDEX CHUNK */
334 int demux_seek_ra(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
335 {
336 real_priv_t *priv = demuxer->priv;
337 demux_stream_t *d_audio = demuxer->audio;
338 sh_audio_t *sh_audio = d_audio->sh;
339 int aid = d_audio->id;
340 int next_offset = 0;
341 int rel_seek_frames = 0;
342 int streams = 0;
343
344 return stream_seek(demuxer->stream, next_offset);
345 }
346 #endif
347
348
349 const demuxer_desc_t demuxer_desc_realaudio = {
350 "Realaudio demuxer",
351 "realaudio",
352 "REALAUDIO",
353 "Roberto Togni",
354 "handles old audio only .ra files",
355 DEMUXER_TYPE_REALAUDIO,
356 1, // safe autodetect
357 ra_check_file,
358 demux_ra_fill_buffer,
359 demux_open_ra,
360 demux_close_ra,
361 NULL,
362 NULL
363 };
364