?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
audiobargraph_a: fix counter wrapping
[vlc/gmpfix.git] / modules / packetizer / mpeg4audio.c
blobe17cac11e4640c5c964175dbd1238cc627275356
1 /*****************************************************************************
2 * mpeg4audio.c: parse and packetize an MPEG 4 audio stream
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
5 * $Id$
6 *
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Gildas Bazin <gbazin@netcourrier.com>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_block.h>
37 #include <vlc_bits.h>
38
39 #include <vlc_block_helper.h>
40 #include "packetizer_helper.h"
41
42 #include <assert.h>
43
44 /* AAC Config in ES:
45 *
46 * AudioObjectType 5 bits
47 * samplingFrequencyIndex 4 bits
48 * if (samplingFrequencyIndex == 0xF)
49 * samplingFrequency 24 bits
50 * channelConfiguration 4 bits
51 * GA_SpecificConfig
52 * FrameLengthFlag 1 bit 1024 or 960
53 * DependsOnCoreCoder 1 bit (always 0)
54 * ExtensionFlag 1 bit (always 0)
55 */
56
57 /*****************************************************************************
58 * decoder_sys_t : decoder descriptor
59 *****************************************************************************/
60 typedef struct
61 {
62 int i_object_type;
63 int i_samplerate;
64 int i_channel;
65 int i_sbr; // 0: no sbr, 1: sbr, -1: unknown
66 int i_ps; // 0: no ps, 1: ps, -1: unknown
67
68 struct
69 {
70 int i_object_type;
71 int i_samplerate;
72 } extension;
73
74 /* GASpecific */
75 int i_frame_length; // 1024 or 960
76
77 } mpeg4_cfg_t;
78
79 #define LATM_MAX_EXTRA_SIZE 64
80 typedef struct
81 {
82 int i_program;
83 int i_layer;
84
85 int i_frame_length_type;
86 int i_frame_length; // type 1
87 int i_frame_length_index; // type 3 4 5 6 7
88
89 mpeg4_cfg_t cfg;
90
91 /* Raw configuration */
92 int i_extra;
93 uint8_t extra[LATM_MAX_EXTRA_SIZE];
94
95 } latm_stream_t;
96
97 #define LATM_MAX_LAYER (8)
98 #define LATM_MAX_PROGRAM (16)
99 typedef struct
100 {
101 int b_same_time_framing;
102 int i_sub_frames;
103 int i_programs;
104
105 int pi_layers[LATM_MAX_PROGRAM];
106
107 int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
108
109 int i_streams;
110 latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
111
112 int i_other_data;
113 int i_crc; /* -1 if not set */
114 } latm_mux_t;
115
116 struct decoder_sys_t
117 {
118 /*
119 * Input properties
120 */
121 int i_state;
122 int i_type;
123
124 block_bytestream_t bytestream;
125
126 /*
127 * Common properties
128 */
129 date_t end_date;
130 mtime_t i_pts;
131
132 int i_frame_size;
133 unsigned int i_channels;
134 unsigned int i_rate, i_frame_length, i_header_size;
135
136 int i_input_rate;
137
138 /* LOAS */
139 bool b_latm_cfg;
140 latm_mux_t latm;
141 };
142
143 enum {
144 TYPE_NONE,
145 TYPE_RAW,
146 TYPE_ADTS,
147 TYPE_LOAS
148 };
149
150 static const int pi_sample_rates[16] =
151 {
152 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
153 16000, 12000, 11025, 8000, 7350, 0, 0, 0
154 };
155
156 #define ADTS_HEADER_SIZE 9
157 #define LOAS_HEADER_SIZE 3
158
159 /****************************************************************************
160 * Local prototypes
161 ****************************************************************************/
162 static int OpenPacketizer(vlc_object_t *);
163 static void ClosePacketizer(vlc_object_t *);
164
165 static block_t *PacketizeRawBlock (decoder_t *, block_t **);
166 static block_t *PacketizeStreamBlock(decoder_t *, block_t **);
167
168 /*****************************************************************************
169 * Module descriptor
170 *****************************************************************************/
171 vlc_module_begin ()
172 set_category(CAT_SOUT)
173 set_subcategory(SUBCAT_SOUT_PACKETIZER)
174 set_description(N_("MPEG4 audio packetizer"))
175 set_capability("packetizer", 50)
176 set_callbacks(OpenPacketizer, ClosePacketizer)
177 vlc_module_end ()
178
179 /*****************************************************************************
180 * OpenPacketizer: probe the packetizer and return score
181 *****************************************************************************/
182 static int OpenPacketizer(vlc_object_t *p_this)
183 {
184 decoder_t *p_dec = (decoder_t*)p_this;
185 decoder_sys_t *p_sys;
186
187 if (p_dec->fmt_in.i_codec != VLC_CODEC_MP4A)
188 return VLC_EGENERIC;
189
190 /* Allocate the memory needed to store the decoder's structure */
191 if ((p_dec->p_sys = p_sys = (decoder_sys_t *)malloc(sizeof(decoder_sys_t))) == NULL)
192 return VLC_ENOMEM;
193
194 /* Misc init */
195 p_sys->i_state = STATE_NOSYNC;
196 date_Set(&p_sys->end_date, 0);
197 block_BytestreamInit(&p_sys->bytestream);
198 p_sys->b_latm_cfg = false;
199
200 /* Set output properties */
201 p_dec->fmt_out.i_cat = AUDIO_ES;
202 p_dec->fmt_out.i_codec = VLC_CODEC_MP4A;
203
204 msg_Dbg(p_dec, "running MPEG4 audio packetizer");
205
206 if (p_dec->fmt_in.i_extra > 0) {
207 uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
208 int i_index;
209
210 i_index = ((p_config[0] << 1) | (p_config[1] >> 7)) & 0x0f;
211 if (i_index != 0x0f) {
212 p_dec->fmt_out.audio.i_rate = pi_sample_rates[i_index];
213 p_dec->fmt_out.audio.i_frame_length =
214 ((p_config[1] >> 2) & 0x01) ? 960 : 1024;
215 } else {
216 p_dec->fmt_out.audio.i_rate = ((p_config[1] & 0x7f) << 17) |
217 (p_config[2] << 9) | (p_config[3] << 1) |
218 (p_config[4] >> 7);
219 p_dec->fmt_out.audio.i_frame_length =
220 ((p_config[4] >> 2) & 0x01) ? 960 : 1024;
221 }
222
223 p_dec->fmt_out.audio.i_channels =
224 (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
225
226 msg_Dbg(p_dec, "AAC %dHz %d samples/frame",
227 p_dec->fmt_out.audio.i_rate,
228 p_dec->fmt_out.audio.i_frame_length);
229
230 date_Init(&p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1);
231
232 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
233 p_dec->fmt_out.p_extra = malloc(p_dec->fmt_in.i_extra);
234 if (!p_dec->fmt_out.p_extra) {
235 p_dec->fmt_out.i_extra = 0;
236 return VLC_ENOMEM;
237 }
238 memcpy(p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
239 p_dec->fmt_in.i_extra);
240
241 /* Set callback */
242 p_dec->pf_packetize = PacketizeRawBlock;
243 p_sys->i_type = TYPE_RAW;
244 } else {
245 msg_Dbg(p_dec, "no decoder specific info, must be an ADTS or LOAS stream");
246
247 date_Init(&p_sys->end_date, p_dec->fmt_in.audio.i_rate, 1);
248
249 /* We will try to create a AAC Config from adts/loas */
250 p_dec->fmt_out.i_extra = 0;
251 p_dec->fmt_out.p_extra = NULL;
252
253 /* Set callback */
254 p_dec->pf_packetize = PacketizeStreamBlock;
255 p_sys->i_type = TYPE_NONE;
256 }
257
258 return VLC_SUCCESS;
259 }
260
261 /*****************************************************************************
262 * ClosePacketizer: clean up the packetizer
263 *****************************************************************************/
264 static void ClosePacketizer(vlc_object_t *p_this)
265 {
266 decoder_t *p_dec = (decoder_t *)p_this;
267 decoder_sys_t *p_sys = p_dec->p_sys;
268
269 block_BytestreamRelease(&p_sys->bytestream);
270 free(p_sys);
271 }
272
273 /****************************************************************************
274 * PacketizeRawBlock: the whole thing
275 ****************************************************************************
276 * This function must be fed with complete frames.
277 ****************************************************************************/
278 static block_t *PacketizeRawBlock(decoder_t *p_dec, block_t **pp_block)
279 {
280 decoder_sys_t *p_sys = p_dec->p_sys;
281 block_t *p_block;
282
283 if (!pp_block || !*pp_block)
284 return NULL;
285
286 if ((*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED)) {
287 date_Set(&p_sys->end_date, 0);
288 block_Release(*pp_block);
289 return NULL;
290 }
291
292 p_block = *pp_block;
293 *pp_block = NULL; /* Don't reuse this block */
294
295 if (!date_Get(&p_sys->end_date) && p_block->i_pts <= VLC_TS_INVALID) {
296 /* We've just started the stream, wait for the first PTS. */
297 block_Release(p_block);
298 return NULL;
299 } else if (p_block->i_pts > VLC_TS_INVALID &&
300 p_block->i_pts != date_Get(&p_sys->end_date)) {
301 date_Set(&p_sys->end_date, p_block->i_pts);
302 }
303
304 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
305
306 p_block->i_length = date_Increment(&p_sys->end_date,
307 p_dec->fmt_out.audio.i_frame_length) - p_block->i_pts;
308
309 return p_block;
310 }
311
312 /****************************************************************************
313 * ADTS helpers
314 ****************************************************************************/
315 static int ADTSSyncInfo(decoder_t * p_dec, const uint8_t * p_buf,
316 unsigned int * pi_channels,
317 unsigned int * pi_sample_rate,
318 unsigned int * pi_frame_length,
319 unsigned int * pi_header_size)
320 {
321 int i_profile, i_sample_rate_idx, i_frame_size;
322 bool b_crc;
323
324 /* Fixed header between frames */
325 //int i_id = ((p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
326 b_crc = !(p_buf[1] & 0x01);
327 i_profile = p_buf[2] >> 6;
328 i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
329 *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
330 //private_bit = (p_buf[2] >> 1) & 0x01;
331 *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
332 if (*pi_channels == 0) /* workaround broken streams */
333 *pi_channels = 2;
334 //original_copy = (p_buf[3] >> 5) & 0x01;
335 //home = (p_buf[3] >> 4) & 0x01;
336
337 /* Variable header */
338 //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
339 //copyright_id_start = (p_buf[3] >> 2) & 0x01;
340 i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
341 ((p_buf[5] >> 5) /*& 0x7*/);
342 //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
343 unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
344
345 if (!*pi_sample_rate || !i_frame_size) {
346 msg_Warn(p_dec, "Invalid ADTS header");
347 return 0;
348 }
349
350 *pi_frame_length = 1024;
351
352 if (i_raw_blocks_in_frame == 0) {
353 if (b_crc) {
354 msg_Warn(p_dec, "ADTS CRC not supported");
355 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
356 }
357 } else {
358 msg_Err(p_dec, "Multiple blocks per frame in ADTS not supported");
359 return 0;
360 #if 0
361 int i;
362 const uint8_t *p_pos = p_buf + 7;
363 uint16_t crc_block;
364 uint16_t i_block_pos[3];
365 if (b_crc) {
366 for (i = 0 ; i < i_raw_blocks_in_frame ; i++) {
367 /* the 1st block's position is known ... */
368 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
369 p_pos += 2;
370 }
371 crc_block = (*p_pos << 8) | *(p_pos+1);
372 p_pos += 2;
373 }
374 for (i = 0 ; i <= i_raw_blocks_in_frame ; i++) {
375 //read 1 block
376 if (b_crc) {
377 msg_Err(p_dec, "ADTS CRC not supported");
378 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
379 //p_pos += 2;
380 }
381 }
382 #endif
383 }
384
385
386 /* Build the decoder specific info header */
387 if (!p_dec->fmt_out.i_extra) {
388 p_dec->fmt_out.p_extra = malloc(2);
389 if (!p_dec->fmt_out.p_extra) {
390 p_dec->fmt_out.i_extra = 0;
391 return 0;
392 }
393 p_dec->fmt_out.i_extra = 2;
394 ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
395 (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
396 ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
397 ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
398 }
399
400 /* ADTS header length */
401 *pi_header_size = b_crc ? 9 : 7;
402
403 return i_frame_size - *pi_header_size;
404 }
405
406 /****************************************************************************
407 * LOAS helpers
408 ****************************************************************************/
409 static int LOASSyncInfo(uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size)
410 {
411 *pi_header_size = 3;
412 return ((p_header[1] & 0x1f) << 8) + p_header[2];
413 }
414
415 static int Mpeg4GAProgramConfigElement(bs_t *s)
416 {
417 /* TODO compute channels count ? */
418 int i_tag = bs_read(s, 4);
419 if (i_tag != 0x05)
420 return -1;
421 bs_skip(s, 2 + 4); // object type + sampling index
422 int i_num_front = bs_read(s, 4);
423 int i_num_side = bs_read(s, 4);
424 int i_num_back = bs_read(s, 4);
425 int i_num_lfe = bs_read(s, 2);
426 int i_num_assoc_data = bs_read(s, 3);
427 int i_num_valid_cc = bs_read(s, 4);
428
429 if (bs_read1(s))
430 bs_skip(s, 4); // mono downmix
431 if (bs_read1(s))
432 bs_skip(s, 4); // stereo downmix
433 if (bs_read1(s))
434 bs_skip(s, 2+1); // matrix downmix + pseudo_surround
435
436 bs_skip(s, i_num_front * (1+4));
437 bs_skip(s, i_num_side * (1+4));
438 bs_skip(s, i_num_back * (1+4));
439 bs_skip(s, i_num_lfe * (4));
440 bs_skip(s, i_num_assoc_data * (4));
441 bs_skip(s, i_num_valid_cc * (5));
442 bs_align(s);
443 int i_comment = bs_read(s, 8);
444 bs_skip(s, i_comment * 8);
445 return 0;
446 }
447
448 static int Mpeg4GASpecificConfig(mpeg4_cfg_t *p_cfg, bs_t *s)
449 {
450 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
451
452 if (bs_read1(s)) // depend on core coder
453 bs_skip(s, 14); // core coder delay
454
455 int i_extension_flag = bs_read1(s);
456 if (p_cfg->i_channel == 0)
457 Mpeg4GAProgramConfigElement(s);
458 if (p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20)
459 bs_skip(s, 3); // layer
460
461 if (i_extension_flag) {
462 if (p_cfg->i_object_type == 22)
463 bs_skip(s, 5 + 11); // numOfSubFrame + layer length
464 if (p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
465 p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23)
466 bs_skip(s, 1+1+1); // ER data : section scale spectral */
467 if (bs_read1(s)) // extension 3
468 fprintf(stderr, "Mpeg4GASpecificConfig: error 1\n");
469 }
470 return 0;
471 }
472
473 static int Mpeg4ReadAudioObjectType(bs_t *s)
474 {
475 int i_type = bs_read(s, 5);
476 if (i_type == 31)
477 i_type = 32 + bs_read(s, 6);
478 return i_type;
479 }
480
481 static int Mpeg4ReadAudioSamplerate(bs_t *s)
482 {
483 int i_index = bs_read(s, 4);
484 if (i_index != 0x0f)
485 return pi_sample_rates[i_index];
486 return bs_read(s, 24);
487 }
488
489 static int Mpeg4ReadAudioSpecificInfo(mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size)
490 {
491 #if 0
492 static const char *ppsz_otype[] = {
493 "NULL",
494 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
495 "TwinVQ",
496 "CELP", "HVXC",
497 "Reserved", "Reserved",
498 "TTSI",
499 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
500 "Algorithmic Synthesis and Audio FX",
501 "ER AAC LC",
502 "Reserved",
503 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
504 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
505 "SSC",
506 "PS", "Reserved", "Escape",
507 "Layer 1", "Layer 2", "Layer 3",
508 "DST",
509 };
510 #endif
511 const int i_pos_start = bs_pos(s);
512 bs_t s_sav = *s;
513 int i_bits;
514 int i;
515
516 memset(p_cfg, 0, sizeof(*p_cfg));
517 *pi_extra = 0;
518
519 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
520 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate(s);
521
522 p_cfg->i_channel = bs_read(s, 4);
523 if (p_cfg->i_channel == 7)
524 p_cfg->i_channel = 8; // 7.1
525 else if (p_cfg->i_channel >= 8)
526 p_cfg->i_channel = -1;
527
528 p_cfg->i_sbr = -1;
529 p_cfg->i_ps = -1;
530 p_cfg->extension.i_object_type = 0;
531 p_cfg->extension.i_samplerate = 0;
532 if (p_cfg->i_object_type == 5 || p_cfg->i_object_type == 29) {
533 p_cfg->i_sbr = 1;
534 if (p_cfg->i_object_type == 29)
535 p_cfg->i_ps = 1;
536 p_cfg->extension.i_object_type = 5;
537 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
538
539 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
540 }
541
542 switch(p_cfg->i_object_type)
543 {
544 case 1: case 2: case 3: case 4:
545 case 6: case 7:
546 case 17: case 19: case 20: case 21: case 22: case 23:
547 Mpeg4GASpecificConfig(p_cfg, s);
548 break;
549 case 8:
550 // CelpSpecificConfig();
551 break;
552 case 9:
553 // HvxcSpecificConfig();
554 break;
555 case 12:
556 // TTSSSpecificConfig();
557 break;
558 case 13: case 14: case 15: case 16:
559 // StructuredAudioSpecificConfig();
560 break;
561 case 24:
562 // ERCelpSpecificConfig();
563 break;
564 case 25:
565 // ERHvxcSpecificConfig();
566 break;
567 case 26: case 27:
568 // ParametricSpecificConfig();
569 break;
570 case 28:
571 // SSCSpecificConfig();
572 break;
573 case 32: case 33: case 34:
574 // MPEG_1_2_SpecificConfig();
575 break;
576 case 35:
577 // DSTSpecificConfig();
578 break;
579 case 36:
580 // ALSSpecificConfig();
581 break;
582 default:
583 // error
584 break;
585 }
586 switch(p_cfg->i_object_type)
587 {
588 case 17: case 19: case 20: case 21: case 22: case 23:
589 case 24: case 25: case 26: case 27:
590 {
591 int epConfig = bs_read(s, 2);
592 if (epConfig == 2 || epConfig == 3)
593 //ErrorProtectionSpecificConfig();
594 if (epConfig == 3)
595 if (bs_read1(s)) {
596 // TODO : directMapping
597 }
598 break;
599 }
600 default:
601 break;
602 }
603
604 if (p_cfg->extension.i_object_type != 5 && i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 16 &&
605 bs_read(s, 11) == 0x2b7) {
606 p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType(s);
607 if (p_cfg->extension.i_object_type == 5) {
608 p_cfg->i_sbr = bs_read1(s);
609 if (p_cfg->i_sbr == 1) {
610 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
611 if (i_max_size > 0 && i_max_size - (bs_pos(s) - i_pos_start) >= 12 && bs_read(s, 11) == 0x548)
612 p_cfg->i_ps = bs_read1(s);
613 }
614 }
615 }
616
617 //fprintf(stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
618 // ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr);
619
620 i_bits = bs_pos(s) - i_pos_start;
621
622 *pi_extra = __MIN((i_bits + 7) / 8, LATM_MAX_EXTRA_SIZE);
623 for (i = 0; i < *pi_extra; i++) {
624 const int i_read = __MIN(8, i_bits - 8*i);
625 p_extra[i] = bs_read(&s_sav, i_read) << (8-i_read);
626 }
627 return i_bits;
628 }
629
630 static int LatmGetValue(bs_t *s)
631 {
632 int i_bytes = bs_read(s, 2);
633 int v = 0;
634 for (int i = 0; i < i_bytes; i++)
635 v = (v << 8) + bs_read(s, 8);
636
637 return v;
638 }
639
640 static int LatmReadStreamMuxConfiguration(latm_mux_t *m, bs_t *s)
641 {
642 int i_mux_version;
643 int i_mux_versionA;
644
645 i_mux_version = bs_read(s, 1);
646 i_mux_versionA = 0;
647 if (i_mux_version)
648 i_mux_versionA = bs_read(s, 1);
649
650 if (i_mux_versionA != 0) /* support only A=0 */
651 return -1;
652
653 memset(m, 0, sizeof(*m));
654
655 if (i_mux_versionA == 0)
656 if (i_mux_version == 1)
657 LatmGetValue(s); /* taraBufferFullness */
658
659 m->b_same_time_framing = bs_read1(s);
660 m->i_sub_frames = 1 + bs_read(s, 6);
661 m->i_programs = 1 + bs_read(s, 4);
662
663 for (int i_program = 0; i_program < m->i_programs; i_program++) {
664 m->pi_layers[i_program] = 1+bs_read(s, 3);
665
666 for (int i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++) {
667 latm_stream_t *st = &m->stream[m->i_streams];
668 bool b_previous_cfg;
669
670 m->pi_stream[i_program][i_layer] = m->i_streams;
671 st->i_program = i_program;
672 st->i_layer = i_layer;
673
674 b_previous_cfg = false;
675 if (i_program != 0 || i_layer != 0)
676 b_previous_cfg = bs_read1(s);
677
678 if (b_previous_cfg) {
679 assert(m->i_streams > 0);
680 st->cfg = m->stream[m->i_streams-1].cfg;
681 } else {
682 int i_cfg_size = 0;
683 if (i_mux_version == 1)
684 i_cfg_size = LatmGetValue(s);
685 i_cfg_size -= Mpeg4ReadAudioSpecificInfo(&st->cfg, &st->i_extra, st->extra, s, i_cfg_size);
686 if (i_cfg_size > 0)
687 bs_skip(s, i_cfg_size);
688 }
689
690 st->i_frame_length_type = bs_read(s, 3);
691 switch(st->i_frame_length_type)
692 {
693 case 0:
694 {
695 bs_skip(s, 8); /* latmBufferFullnes */
696 if (!m->b_same_time_framing)
697 if (st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
698 st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24)
699 bs_skip(s, 6); /* eFrameOffset */
700 break;
701 }
702 case 1:
703 st->i_frame_length = bs_read(s, 9);
704 break;
705 case 3: case 4: case 5:
706 st->i_frame_length_index = bs_read(s, 6); // celp
707 break;
708 case 6: case 7:
709 st->i_frame_length_index = bs_read(s, 1); // hvxc
710 default:
711 break;
712 }
713 /* Next stream */
714 m->i_streams++;
715 }
716 }
717
718 /* other data */
719 if (bs_read1(s)) {
720 if (i_mux_version == 1)
721 m->i_other_data = LatmGetValue(s);
722 else {
723 int b_continue;
724 do {
725 b_continue = bs_read1(s);
726 m->i_other_data = (m->i_other_data << 8) + bs_read(s, 8);
727 } while (b_continue);
728 }
729 }
730
731 /* crc */
732 m->i_crc = -1;
733 if (bs_read1(s))
734 m->i_crc = bs_read(s, 8);
735
736 return 0;
737 }
738
739 static int LOASParse(decoder_t *p_dec, uint8_t *p_buffer, int i_buffer)
740 {
741 decoder_sys_t *p_sys = p_dec->p_sys;
742 bs_t s;
743 int i_accumulated = 0;
744
745 bs_init(&s, p_buffer, i_buffer);
746
747 /* Read the stream mux configuration if present */
748 if (!bs_read1(&s) && !LatmReadStreamMuxConfiguration(&p_sys->latm, &s) &&
749 p_sys->latm.i_streams > 0) {
750 const latm_stream_t *st = &p_sys->latm.stream[0];
751
752 p_sys->i_channels = st->cfg.i_channel;
753 p_sys->i_rate = st->cfg.i_samplerate;
754 p_sys->i_frame_length = st->cfg.i_frame_length;
755
756 /* FIXME And if it changes ? */
757 if (p_sys->i_channels && p_sys->i_rate && p_sys->i_frame_length > 0) {
758 if (!p_dec->fmt_out.i_extra && st->i_extra > 0) {
759 p_dec->fmt_out.i_extra = st->i_extra;
760 p_dec->fmt_out.p_extra = malloc(st->i_extra);
761 if (!p_dec->fmt_out.p_extra) {
762 p_dec->fmt_out.i_extra = 0;
763 return 0;
764 }
765 memcpy(p_dec->fmt_out.p_extra, st->extra, st->i_extra);
766 }
767 p_sys->b_latm_cfg = true;
768 }
769 }
770
771 /* Wait for the configuration */
772 if (!p_sys->b_latm_cfg)
773 return 0;
774
775 /* FIXME do we need to split the subframe into independent packet ? */
776 if (p_sys->latm.i_sub_frames > 1)
777 msg_Err(p_dec, "latm sub frames not yet supported, please send a sample");
778
779 for (int i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++) {
780 int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
781 if (p_sys->latm.b_same_time_framing) {
782 /* Payload length */
783 for (int i_program = 0; i_program < p_sys->latm.i_programs; i_program++) {
784 for (int i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++) {
785 latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
786 if (st->i_frame_length_type == 0) {
787 int i_payload = 0;
788 for (;;) {
789 int i_tmp = bs_read(&s, 8);
790 i_payload += i_tmp;
791 if (i_tmp != 255)
792 break;
793 }
794 pi_payload[i_program][i_layer] = i_payload;
795 } else if (st->i_frame_length_type == 1) {
796 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
797 } else if ((st->i_frame_length_type == 3) ||
798 (st->i_frame_length_type == 5) ||
799 (st->i_frame_length_type == 7)) {
800 bs_skip(&s, 2); // muxSlotLengthCoded
801 pi_payload[i_program][i_layer] = 0; /* TODO */
802 } else {
803 pi_payload[i_program][i_layer] = 0; /* TODO */
804 }
805 }
806 }
807
808 /* Payload Data */
809 for (int i_program = 0; i_program < p_sys->latm.i_programs; i_program++) {
810 for (int i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++) {
811 /* XXX we only extract 1 stream */
812 if (i_program != 0 || i_layer != 0)
813 break;
814
815 if (pi_payload[i_program][i_layer] <= 0)
816 continue;
817
818 /* FIXME that's slow (and a bit ugly to write in place) */
819 for (int i = 0; i < pi_payload[i_program][i_layer]; i++) {
820 if (i_accumulated >= i_buffer)
821 return 0;
822 p_buffer[i_accumulated++] = bs_read(&s, 8);
823 }
824 }
825 }
826 } else {
827 const int i_chunks = bs_read(&s, 4);
828 #if 0
829 int pi_program[16];
830 int pi_layer[16];
831 #endif
832
833 msg_Err(p_dec, "latm without same time frameing not yet supported, please send a sample");
834
835 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
836 const int streamIndex = bs_read(&s, 4);
837 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
838 const int i_program = st->i_program;
839 const int i_layer = st->i_layer;
840
841 #if 0
842 pi_program[i_chunk] = i_program;
843 pi_layer[i_chunk] = i_layer;
844 #endif
845
846 if (st->i_frame_length_type == 0) {
847 int i_payload = 0;
848 for (;;) {
849 int i_tmp = bs_read(&s, 8);
850 i_payload += i_tmp;
851 if (i_tmp != 255)
852 break;
853 }
854 pi_payload[i_program][i_layer] = i_payload;
855 bs_skip(&s, 1); // auEndFlag
856 } else if (st->i_frame_length_type == 1) {
857 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
858 } else if ((st->i_frame_length_type == 3) ||
859 (st->i_frame_length_type == 5) ||
860 (st->i_frame_length_type == 7)) {
861 bs_read(&s, 2); // muxSlotLengthCoded
862 }
863 }
864 #if 0
865 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
866 //const int i_program = pi_program[i_chunk];
867 //const int i_layer = pi_layer[i_chunk];
868
869 /* TODO ? Payload */
870 }
871 #endif
872 }
873 }
874
875 #if 0
876 if (p_sys->latm.i_other_data > 0)
877 ; // TODO
878 #endif
879 bs_align(&s);
880
881 return i_accumulated;
882 }
883
884 /*****************************************************************************
885 *
886 *****************************************************************************/
887 static void SetupOutput(decoder_t *p_dec, block_t *p_block)
888 {
889 decoder_sys_t *p_sys = p_dec->p_sys;
890
891 if (p_dec->fmt_out.audio.i_rate != p_sys->i_rate) {
892 msg_Info(p_dec, "AAC channels: %d samplerate: %d",
893 p_sys->i_channels, p_sys->i_rate);
894
895 const mtime_t i_end_date = date_Get(&p_sys->end_date);
896 date_Init(&p_sys->end_date, p_sys->i_rate, 1);
897 date_Set(&p_sys->end_date, i_end_date);
898 }
899
900 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
901 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
902 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
903 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
904
905 #if 0
906 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
907 p_dec->fmt_out.audio.i_physical_channels = p_sys->i_channels_conf;
908 #endif
909
910 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
911
912 p_block->i_length =
913 date_Increment(&p_sys->end_date, p_sys->i_frame_length) - p_block->i_pts;
914 }
915
916 /****************************************************************************
917 * PacketizeStreamBlock: ADTS/LOAS packetizer
918 ****************************************************************************/
919 static block_t *PacketizeStreamBlock(decoder_t *p_dec, block_t **pp_block)
920 {
921 decoder_sys_t *p_sys = p_dec->p_sys;
922 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
923 block_t *p_out_buffer;
924 uint8_t *p_buf;
925
926 if (!pp_block || !*pp_block)
927 return NULL;
928
929 if ((*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED)) {
930 if ((*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED) {
931 p_sys->i_state = STATE_NOSYNC;
932 block_BytestreamEmpty(&p_sys->bytestream);
933 }
934 date_Set(&p_sys->end_date, 0);
935 block_Release(*pp_block);
936 return NULL;
937 }
938
939 if (!date_Get(&p_sys->end_date) && (*pp_block)->i_pts <= VLC_TS_INVALID) {
940 /* We've just started the stream, wait for the first PTS. */
941 block_Release(*pp_block);
942 return NULL;
943 }
944
945 block_BytestreamPush(&p_sys->bytestream, *pp_block);
946
947 for (;;) switch(p_sys->i_state) {
948 case STATE_NOSYNC:
949 while (block_PeekBytes(&p_sys->bytestream, p_header, 2) == VLC_SUCCESS) {
950 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
951 if (p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0) {
952 if (p_sys->i_type != TYPE_ADTS)
953 msg_Dbg(p_dec, "detected ADTS format");
954
955 p_sys->i_state = STATE_SYNC;
956 p_sys->i_type = TYPE_ADTS;
957 break;
958 } else if (p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0) {
959 if (p_sys->i_type != TYPE_LOAS)
960 msg_Dbg(p_dec, "detected LOAS format");
961
962 p_sys->i_state = STATE_SYNC;
963 p_sys->i_type = TYPE_LOAS;
964 break;
965 }
966 block_SkipByte(&p_sys->bytestream);
967 }
968 if (p_sys->i_state != STATE_SYNC) {
969 block_BytestreamFlush(&p_sys->bytestream);
970
971 /* Need more data */
972 return NULL;
973 }
974
975 case STATE_SYNC:
976 /* New frame, set the Presentation Time Stamp */
977 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
978 if (p_sys->i_pts > VLC_TS_INVALID &&
979 p_sys->i_pts != date_Get(&p_sys->end_date))
980 date_Set(&p_sys->end_date, p_sys->i_pts);
981 p_sys->i_state = STATE_HEADER;
982 break;
983
984 case STATE_HEADER:
985 if (p_sys->i_type == TYPE_ADTS) {
986 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
987 if (block_PeekBytes(&p_sys->bytestream, p_header,
988 ADTS_HEADER_SIZE) != VLC_SUCCESS)
989 return NULL; /* Need more data */
990
991 /* Check if frame is valid and get frame info */
992 p_sys->i_frame_size = ADTSSyncInfo(p_dec, p_header,
993 &p_sys->i_channels,
994 &p_sys->i_rate,
995 &p_sys->i_frame_length,
996 &p_sys->i_header_size);
997 } else {
998 assert(p_sys->i_type == TYPE_LOAS);
999 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1000 if (block_PeekBytes(&p_sys->bytestream, p_header,
1001 LOAS_HEADER_SIZE) != VLC_SUCCESS)
1002 return NULL; /* Need more data */
1003
1004 /* Check if frame is valid and get frame info */
1005 p_sys->i_frame_size = LOASSyncInfo(p_header, &p_sys->i_header_size);
1006 }
1007
1008 if (p_sys->i_frame_size <= 0) {
1009 msg_Dbg(p_dec, "emulated sync word");
1010 block_SkipByte(&p_sys->bytestream);
1011 p_sys->i_state = STATE_NOSYNC;
1012 break;
1013 }
1014
1015 p_sys->i_state = STATE_NEXT_SYNC;
1016
1017 case STATE_NEXT_SYNC:
1018 /* TODO: If p_block == NULL, flush the buffer without checking the
1019 * next sync word */
1020 if (p_sys->bytestream.p_block == NULL) {
1021 p_sys->i_state = STATE_NOSYNC;
1022 block_BytestreamFlush(&p_sys->bytestream);
1023 return NULL;
1024 }
1025
1026 /* Check if next expected frame contains the sync word */
1027 if (block_PeekOffsetBytes(&p_sys->bytestream, p_sys->i_frame_size
1028 + p_sys->i_header_size, p_header, 2) != VLC_SUCCESS)
1029 return NULL; /* Need more data */
1030
1031 assert((p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS));
1032 if (((p_sys->i_type == TYPE_ADTS) &&
1033 (p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0)) ||
1034 ((p_sys->i_type == TYPE_LOAS) &&
1035 (p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0))) {
1036 msg_Dbg(p_dec, "emulated sync word "
1037 "(no sync on following frame)");
1038 p_sys->i_state = STATE_NOSYNC;
1039 block_SkipByte(&p_sys->bytestream);
1040 break;
1041 }
1042
1043 p_sys->i_state = STATE_SEND_DATA;
1044 break;
1045
1046 case STATE_GET_DATA:
1047 /* Make sure we have enough data.
1048 * (Not useful if we went through NEXT_SYNC) */
1049 if (block_WaitBytes(&p_sys->bytestream, p_sys->i_frame_size +
1050 p_sys->i_header_size) != VLC_SUCCESS)
1051 return NULL; /* Need more data */
1052 p_sys->i_state = STATE_SEND_DATA;
1053
1054 case STATE_SEND_DATA:
1055 /* When we reach this point we already know we have enough
1056 * data available. */
1057
1058 p_out_buffer = block_Alloc(p_sys->i_frame_size);
1059 if (!p_out_buffer) {
1060 //p_dec->b_error = true;
1061 return NULL;
1062 }
1063 p_buf = p_out_buffer->p_buffer;
1064
1065 /* Skip the ADTS/LOAS header */
1066 block_SkipBytes(&p_sys->bytestream, p_sys->i_header_size);
1067
1068 /* Copy the whole frame into the buffer */
1069 block_GetBytes(&p_sys->bytestream, p_buf, p_sys->i_frame_size);
1070 if (p_sys->i_type != TYPE_ADTS) { /* parse/extract the whole frame */
1071 assert(p_sys->i_type == TYPE_LOAS);
1072 p_out_buffer->i_buffer = LOASParse(p_dec, p_buf, p_sys->i_frame_size);
1073 if (p_out_buffer->i_buffer <= 0) {
1074 if (!p_sys->b_latm_cfg)
1075 msg_Warn(p_dec, "waiting for header");
1076
1077 block_Release(p_out_buffer);
1078 p_out_buffer = NULL;
1079 p_sys->i_state = STATE_NOSYNC;
1080 break;
1081 }
1082 }
1083 SetupOutput(p_dec, p_out_buffer);
1084 /* Make sure we don't reuse the same pts twice */
1085 if (p_sys->i_pts == p_sys->bytestream.p_block->i_pts)
1086 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
1087
1088 /* So p_block doesn't get re-added several times */
1089 *pp_block = block_BytestreamPop(&p_sys->bytestream);
1090
1091 p_sys->i_state = STATE_NOSYNC;
1092
1093 return p_out_buffer;
1094 }
1095
1096 return NULL;
1097 }