1 /*****************************************************************************
2 * mpeg4audio.c: parse and packetize an MPEG 4 audio stream
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Gildas Bazin <gbazin@netcourrier.com>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_block.h>
39 #include <vlc_block_helper.h>
40 #include "packetizer_helper.h"
46 * AudioObjectType 5 bits
47 * samplingFrequencyIndex 4 bits
48 * if (samplingFrequencyIndex == 0xF)
49 * samplingFrequency 24 bits
50 * channelConfiguration 4 bits
52 * FrameLengthFlag 1 bit 1024 or 960
53 * DependsOnCoreCoder 1 bit (always 0)
54 * ExtensionFlag 1 bit (always 0)
57 /*****************************************************************************
58 * decoder_sys_t : decoder descriptor
59 *****************************************************************************/
65 int i_sbr; // 0: no sbr, 1: sbr, -1: unknown
66 int i_ps; // 0: no ps, 1: ps, -1: unknown
75 int i_frame_length; // 1024 or 960
79 #define LATM_MAX_EXTRA_SIZE 64
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
91 /* Raw configuration */
93 uint8_t extra[LATM_MAX_EXTRA_SIZE];
97 #define LATM_MAX_LAYER (8)
98 #define LATM_MAX_PROGRAM (16)
101 int b_same_time_framing;
105 int pi_layers[LATM_MAX_PROGRAM];
107 int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
110 latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
113 int i_crc; /* -1 if not set */
124 block_bytestream_t bytestream;
133 unsigned int i_channels;
134 unsigned int i_rate, i_frame_length, i_header_size;
150 static const int pi_sample_rates[16] =
152 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
153 16000, 12000, 11025, 8000, 7350, 0, 0, 0
156 #define ADTS_HEADER_SIZE 9
157 #define LOAS_HEADER_SIZE 3
159 /****************************************************************************
161 ****************************************************************************/
162 static int OpenPacketizer(vlc_object_t *);
163 static void ClosePacketizer(vlc_object_t *);
165 static block_t *PacketizeRawBlock (decoder_t *, block_t **);
166 static block_t *PacketizeStreamBlock(decoder_t *, block_t **);
168 /*****************************************************************************
170 *****************************************************************************/
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)
179 /*****************************************************************************
180 * OpenPacketizer: probe the packetizer and return score
181 *****************************************************************************/
182 static int OpenPacketizer(vlc_object_t *p_this)
184 decoder_t *p_dec = (decoder_t*)p_this;
185 decoder_sys_t *p_sys;
187 if (p_dec->fmt_in.i_codec != VLC_CODEC_MP4A)
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)
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;
200 /* Set output properties */
201 p_dec->fmt_out.i_cat = AUDIO_ES;
202 p_dec->fmt_out.i_codec = VLC_CODEC_MP4A;
204 msg_Dbg(p_dec, "running MPEG4 audio packetizer");
206 if (p_dec->fmt_in.i_extra > 0) {
207 uint8_t *p_config = (uint8_t*)p_dec->fmt_in.p_extra;
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;
216 p_dec->fmt_out.audio.i_rate = ((p_config[1] & 0x7f) << 17) |
217 (p_config[2] << 9) | (p_config[3] << 1) |
219 p_dec->fmt_out.audio.i_frame_length =
220 ((p_config[4] >> 2) & 0x01) ? 960 : 1024;
223 p_dec->fmt_out.audio.i_channels =
224 (p_config[i_index == 0x0f ? 4 : 1] >> 3) & 0x0f;
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);
230 date_Init(&p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1);
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;
238 memcpy(p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
239 p_dec->fmt_in.i_extra);
242 p_dec->pf_packetize = PacketizeRawBlock;
243 p_sys->i_type = TYPE_RAW;
245 msg_Dbg(p_dec, "no decoder specific info, must be an ADTS or LOAS stream");
247 date_Init(&p_sys->end_date, p_dec->fmt_in.audio.i_rate, 1);
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;
254 p_dec->pf_packetize = PacketizeStreamBlock;
255 p_sys->i_type = TYPE_NONE;
261 /*****************************************************************************
262 * ClosePacketizer: clean up the packetizer
263 *****************************************************************************/
264 static void ClosePacketizer(vlc_object_t *p_this)
266 decoder_t *p_dec = (decoder_t *)p_this;
267 decoder_sys_t *p_sys = p_dec->p_sys;
269 block_BytestreamRelease(&p_sys->bytestream);
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)
280 decoder_sys_t *p_sys = p_dec->p_sys;
283 if (!pp_block || !*pp_block)
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);
293 *pp_block = NULL; /* Don't reuse this block */
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);
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);
304 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
306 p_block->i_length = date_Increment(&p_sys->end_date,
307 p_dec->fmt_out.audio.i_frame_length) - p_block->i_pts;
312 /****************************************************************************
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)
321 int i_profile, i_sample_rate_idx, i_frame_size;
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 */
334 //original_copy = (p_buf[3] >> 5) & 0x01;
335 //home = (p_buf[3] >> 4) & 0x01;
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;
345 if (!*pi_sample_rate || !i_frame_size) {
346 msg_Warn(p_dec, "Invalid ADTS header");
350 *pi_frame_length = 1024;
352 if (i_raw_blocks_in_frame == 0) {
354 msg_Warn(p_dec, "ADTS CRC not supported");
355 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
358 msg_Err(p_dec, "Multiple blocks per frame in ADTS not supported");
362 const uint8_t *p_pos = p_buf + 7;
364 uint16_t i_block_pos[3];
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);
371 crc_block = (*p_pos << 8) | *(p_pos+1);
374 for (i = 0 ; i <= i_raw_blocks_in_frame ; i++) {
377 msg_Err(p_dec, "ADTS CRC not supported");
378 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
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;
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);
400 /* ADTS header length */
401 *pi_header_size = b_crc ? 9 : 7;
403 return i_frame_size - *pi_header_size;
406 /****************************************************************************
408 ****************************************************************************/
409 static int LOASSyncInfo(uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size)
412 return ((p_header[1] & 0x1f) << 8) + p_header[2];
415 static int Mpeg4GAProgramConfigElement(bs_t *s)
417 /* TODO compute channels count ? */
418 int i_tag = bs_read(s, 4);
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);
430 bs_skip(s, 4); // mono downmix
432 bs_skip(s, 4); // stereo downmix
434 bs_skip(s, 2+1); // matrix downmix + pseudo_surround
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));
443 int i_comment = bs_read(s, 8);
444 bs_skip(s, i_comment * 8);
448 static int Mpeg4GASpecificConfig(mpeg4_cfg_t *p_cfg, bs_t *s)
450 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
452 if (bs_read1(s)) // depend on core coder
453 bs_skip(s, 14); // core coder delay
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
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");
473 static int Mpeg4ReadAudioObjectType(bs_t *s)
475 int i_type = bs_read(s, 5);
477 i_type = 32 + bs_read(s, 6);
481 static int Mpeg4ReadAudioSamplerate(bs_t *s)
483 int i_index = bs_read(s, 4);
485 return pi_sample_rates[i_index];
486 return bs_read(s, 24);
489 static int Mpeg4ReadAudioSpecificInfo(mpeg4_cfg_t *p_cfg, int *pi_extra, uint8_t *p_extra, bs_t *s, int i_max_size)
492 static const char *ppsz_otype[] = {
494 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
497 "Reserved", "Reserved",
499 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
500 "Algorithmic Synthesis and Audio FX",
503 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
504 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
506 "PS", "Reserved", "Escape",
507 "Layer 1", "Layer 2", "Layer 3",
511 const int i_pos_start = bs_pos(s);
516 memset(p_cfg, 0, sizeof(*p_cfg));
519 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
520 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate(s);
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;
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) {
534 if (p_cfg->i_object_type == 29)
536 p_cfg->extension.i_object_type = 5;
537 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
539 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
542 switch(p_cfg->i_object_type)
544 case 1: case 2: case 3: case 4:
546 case 17: case 19: case 20: case 21: case 22: case 23:
547 Mpeg4GASpecificConfig(p_cfg, s);
550 // CelpSpecificConfig();
553 // HvxcSpecificConfig();
556 // TTSSSpecificConfig();
558 case 13: case 14: case 15: case 16:
559 // StructuredAudioSpecificConfig();
562 // ERCelpSpecificConfig();
565 // ERHvxcSpecificConfig();
568 // ParametricSpecificConfig();
571 // SSCSpecificConfig();
573 case 32: case 33: case 34:
574 // MPEG_1_2_SpecificConfig();
577 // DSTSpecificConfig();
580 // ALSSpecificConfig();
586 switch(p_cfg->i_object_type)
588 case 17: case 19: case 20: case 21: case 22: case 23:
589 case 24: case 25: case 26: case 27:
591 int epConfig = bs_read(s, 2);
592 if (epConfig == 2 || epConfig == 3)
593 //ErrorProtectionSpecificConfig();
596 // TODO : directMapping
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);
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);
620 i_bits = bs_pos(s) - i_pos_start;
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);
630 static int LatmGetValue(bs_t *s)
632 int i_bytes = bs_read(s, 2);
634 for (int i = 0; i < i_bytes; i++)
635 v = (v << 8) + bs_read(s, 8);
640 static int LatmReadStreamMuxConfiguration(latm_mux_t *m, bs_t *s)
645 i_mux_version = bs_read(s, 1);
648 i_mux_versionA = bs_read(s, 1);
650 if (i_mux_versionA != 0) /* support only A=0 */
653 memset(m, 0, sizeof(*m));
655 if (i_mux_versionA == 0)
656 if (i_mux_version == 1)
657 LatmGetValue(s); /* taraBufferFullness */
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);
663 for (int i_program = 0; i_program < m->i_programs; i_program++) {
664 m->pi_layers[i_program] = 1+bs_read(s, 3);
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];
670 m->pi_stream[i_program][i_layer] = m->i_streams;
671 st->i_program = i_program;
672 st->i_layer = i_layer;
674 b_previous_cfg = false;
675 if (i_program != 0 || i_layer != 0)
676 b_previous_cfg = bs_read1(s);
678 if (b_previous_cfg) {
679 assert(m->i_streams > 0);
680 st->cfg = m->stream[m->i_streams-1].cfg;
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);
687 bs_skip(s, i_cfg_size);
690 st->i_frame_length_type = bs_read(s, 3);
691 switch(st->i_frame_length_type)
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 */
703 st->i_frame_length = bs_read(s, 9);
705 case 3: case 4: case 5:
706 st->i_frame_length_index = bs_read(s, 6); // celp
709 st->i_frame_length_index = bs_read(s, 1); // hvxc
720 if (i_mux_version == 1)
721 m->i_other_data = LatmGetValue(s);
725 b_continue = bs_read1(s);
726 m->i_other_data = (m->i_other_data << 8) + bs_read(s, 8);
727 } while (b_continue);
734 m->i_crc = bs_read(s, 8);
739 static int LOASParse(decoder_t *p_dec, uint8_t *p_buffer, int i_buffer)
741 decoder_sys_t *p_sys = p_dec->p_sys;
743 int i_accumulated = 0;
745 bs_init(&s, p_buffer, i_buffer);
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];
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;
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;
765 memcpy(p_dec->fmt_out.p_extra, st->extra, st->i_extra);
767 p_sys->b_latm_cfg = true;
771 /* Wait for the configuration */
772 if (!p_sys->b_latm_cfg)
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");
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) {
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) {
789 int i_tmp = bs_read(&s, 8);
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 */
803 pi_payload[i_program][i_layer] = 0; /* TODO */
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)
815 if (pi_payload[i_program][i_layer] <= 0)
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)
822 p_buffer[i_accumulated++] = bs_read(&s, 8);
827 const int i_chunks = bs_read(&s, 4);
831 msg_Err(p_dec, "latm without same time frameing not yet supported, please send a sample");
833 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
834 const int streamIndex = bs_read(&s, 4);
835 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
836 const int i_program = st->i_program;
837 const int i_layer = st->i_layer;
839 pi_program[i_chunk] = i_program;
840 pi_layer[i_chunk] = i_layer;
842 if (st->i_frame_length_type == 0) {
845 int i_tmp = bs_read(&s, 8);
850 pi_payload[i_program][i_layer] = i_payload;
851 bs_skip(&s, 1); // auEndFlag
852 } else if (st->i_frame_length_type == 1) {
853 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
854 } else if ((st->i_frame_length_type == 3) ||
855 (st->i_frame_length_type == 5) ||
856 (st->i_frame_length_type == 7)) {
857 bs_read(&s, 2); // muxSlotLengthCoded
860 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
861 //const int i_program = pi_program[i_chunk];
862 //const int i_layer = pi_layer[i_chunk];
870 if (p_sys->latm.i_other_data > 0)
875 return i_accumulated;
878 /*****************************************************************************
880 *****************************************************************************/
881 static void SetupOutput(decoder_t *p_dec, block_t *p_block)
883 decoder_sys_t *p_sys = p_dec->p_sys;
885 if (p_dec->fmt_out.audio.i_rate != p_sys->i_rate) {
886 msg_Info(p_dec, "AAC channels: %d samplerate: %d",
887 p_sys->i_channels, p_sys->i_rate);
889 const mtime_t i_end_date = date_Get(&p_sys->end_date);
890 date_Init(&p_sys->end_date, p_sys->i_rate, 1);
891 date_Set(&p_sys->end_date, i_end_date);
894 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
895 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
896 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
897 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
900 p_dec->fmt_out.audio.i_original_channels = p_sys->i_channels_conf;
901 p_dec->fmt_out.audio.i_physical_channels = p_sys->i_channels_conf;
904 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
907 date_Increment(&p_sys->end_date, p_sys->i_frame_length) - p_block->i_pts;
910 /****************************************************************************
911 * PacketizeStreamBlock: ADTS/LOAS packetizer
912 ****************************************************************************/
913 static block_t *PacketizeStreamBlock(decoder_t *p_dec, block_t **pp_block)
915 decoder_sys_t *p_sys = p_dec->p_sys;
916 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
917 block_t *p_out_buffer;
920 if (!pp_block || !*pp_block)
923 if ((*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED)) {
924 if ((*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED) {
925 p_sys->i_state = STATE_NOSYNC;
926 block_BytestreamEmpty(&p_sys->bytestream);
928 date_Set(&p_sys->end_date, 0);
929 block_Release(*pp_block);
933 if (!date_Get(&p_sys->end_date) && (*pp_block)->i_pts <= VLC_TS_INVALID) {
934 /* We've just started the stream, wait for the first PTS. */
935 block_Release(*pp_block);
939 block_BytestreamPush(&p_sys->bytestream, *pp_block);
941 for (;;) switch(p_sys->i_state) {
943 while (block_PeekBytes(&p_sys->bytestream, p_header, 2) == VLC_SUCCESS) {
944 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
945 if (p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0) {
946 if (p_sys->i_type != TYPE_ADTS)
947 msg_Dbg(p_dec, "detected ADTS format");
949 p_sys->i_state = STATE_SYNC;
950 p_sys->i_type = TYPE_ADTS;
952 } else if (p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0) {
953 if (p_sys->i_type != TYPE_LOAS)
954 msg_Dbg(p_dec, "detected LOAS format");
956 p_sys->i_state = STATE_SYNC;
957 p_sys->i_type = TYPE_LOAS;
960 block_SkipByte(&p_sys->bytestream);
962 if (p_sys->i_state != STATE_SYNC) {
963 block_BytestreamFlush(&p_sys->bytestream);
970 /* New frame, set the Presentation Time Stamp */
971 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
972 if (p_sys->i_pts > VLC_TS_INVALID &&
973 p_sys->i_pts != date_Get(&p_sys->end_date))
974 date_Set(&p_sys->end_date, p_sys->i_pts);
975 p_sys->i_state = STATE_HEADER;
979 if (p_sys->i_type == TYPE_ADTS) {
980 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
981 if (block_PeekBytes(&p_sys->bytestream, p_header,
982 ADTS_HEADER_SIZE) != VLC_SUCCESS)
983 return NULL; /* Need more data */
985 /* Check if frame is valid and get frame info */
986 p_sys->i_frame_size = ADTSSyncInfo(p_dec, p_header,
989 &p_sys->i_frame_length,
990 &p_sys->i_header_size);
992 assert(p_sys->i_type == TYPE_LOAS);
993 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
994 if (block_PeekBytes(&p_sys->bytestream, p_header,
995 LOAS_HEADER_SIZE) != VLC_SUCCESS)
996 return NULL; /* Need more data */
998 /* Check if frame is valid and get frame info */
999 p_sys->i_frame_size = LOASSyncInfo(p_header, &p_sys->i_header_size);
1002 if (p_sys->i_frame_size <= 0) {
1003 msg_Dbg(p_dec, "emulated sync word");
1004 block_SkipByte(&p_sys->bytestream);
1005 p_sys->i_state = STATE_NOSYNC;
1009 p_sys->i_state = STATE_NEXT_SYNC;
1011 case STATE_NEXT_SYNC:
1012 /* TODO: If p_block == NULL, flush the buffer without checking the
1014 if (p_sys->bytestream.p_block == NULL) {
1015 p_sys->i_state = STATE_NOSYNC;
1016 block_BytestreamFlush(&p_sys->bytestream);
1020 /* Check if next expected frame contains the sync word */
1021 if (block_PeekOffsetBytes(&p_sys->bytestream, p_sys->i_frame_size
1022 + p_sys->i_header_size, p_header, 2) != VLC_SUCCESS)
1023 return NULL; /* Need more data */
1025 assert((p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS));
1026 if (((p_sys->i_type == TYPE_ADTS) &&
1027 (p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0)) ||
1028 ((p_sys->i_type == TYPE_LOAS) &&
1029 (p_header[0] != 0x56 || (p_header[1] & 0xe0) != 0xe0))) {
1030 msg_Dbg(p_dec, "emulated sync word "
1031 "(no sync on following frame)");
1032 p_sys->i_state = STATE_NOSYNC;
1033 block_SkipByte(&p_sys->bytestream);
1037 p_sys->i_state = STATE_SEND_DATA;
1040 case STATE_GET_DATA:
1041 /* Make sure we have enough data.
1042 * (Not useful if we went through NEXT_SYNC) */
1043 if (block_WaitBytes(&p_sys->bytestream, p_sys->i_frame_size +
1044 p_sys->i_header_size) != VLC_SUCCESS)
1045 return NULL; /* Need more data */
1046 p_sys->i_state = STATE_SEND_DATA;
1048 case STATE_SEND_DATA:
1049 /* When we reach this point we already know we have enough
1050 * data available. */
1052 p_out_buffer = block_Alloc(p_sys->i_frame_size);
1053 if (!p_out_buffer) {
1054 //p_dec->b_error = true;
1057 p_buf = p_out_buffer->p_buffer;
1059 /* Skip the ADTS/LOAS header */
1060 block_SkipBytes(&p_sys->bytestream, p_sys->i_header_size);
1062 /* Copy the whole frame into the buffer */
1063 block_GetBytes(&p_sys->bytestream, p_buf, p_sys->i_frame_size);
1064 if (p_sys->i_type != TYPE_ADTS) { /* parse/extract the whole frame */
1065 assert(p_sys->i_type == TYPE_LOAS);
1066 p_out_buffer->i_buffer = LOASParse(p_dec, p_buf, p_sys->i_frame_size);
1067 if (p_out_buffer->i_buffer <= 0) {
1068 if (!p_sys->b_latm_cfg)
1069 msg_Warn(p_dec, "waiting for header");
1071 block_Release(p_out_buffer);
1072 p_out_buffer = NULL;
1073 p_sys->i_state = STATE_NOSYNC;
1077 SetupOutput(p_dec, p_out_buffer);
1078 /* Make sure we don't reuse the same pts twice */
1079 if (p_sys->i_pts == p_sys->bytestream.p_block->i_pts)
1080 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
1082 /* So p_block doesn't get re-added several times */
1083 *pp_block = block_BytestreamPop(&p_sys->bytestream);
1085 p_sys->i_state = STATE_NOSYNC;
1087 return p_out_buffer;