?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mlp: missing initializer (fixes #20494)
[vlc.git] / modules / packetizer / mpeg4audio.c
blob3814dda0319fda8ede5c600c630bce250ebef062
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 int i_channel;
73 } extension;
74
75 /* GASpecific */
76 int i_frame_length; // 1024 or 960
77
78 } mpeg4_asc_t;
79
80 #define LATM_MAX_EXTRA_SIZE 64
81 typedef struct
82 {
83 int i_program;
84 int i_layer;
85
86 int i_frame_length_type;
87 int i_frame_length; // type 1
88 int i_frame_length_index; // type 3 4 5 6 7
89
90 mpeg4_asc_t cfg;
91
92 /* Raw configuration */
93 int i_extra;
94 uint8_t extra[LATM_MAX_EXTRA_SIZE];
95
96 } latm_stream_t;
97
98 #define LATM_MAX_LAYER (8)
99 #define LATM_MAX_PROGRAM (16)
100 typedef struct
101 {
102 int b_same_time_framing;
103 int i_sub_frames;
104 int i_programs;
105
106 int pi_layers[LATM_MAX_PROGRAM];
107
108 int pi_stream[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
109
110 int i_streams;
111 latm_stream_t stream[LATM_MAX_PROGRAM*LATM_MAX_LAYER];
112
113 uint32_t i_other_data;
114 int i_crc; /* -1 if not set */
115 } latm_mux_t;
116
117 typedef struct
118 {
119 /*
120 * Input properties
121 */
122 int i_state;
123 int i_type;
124
125 block_bytestream_t bytestream;
126
127 /*
128 * Common properties
129 */
130 date_t end_date;
131 mtime_t i_pts;
132 bool b_discontuinity;
133
134 int i_frame_size;
135 unsigned int i_channels;
136 unsigned int i_rate, i_frame_length, i_header_size;
137
138 int i_input_rate;
139
140 /* LOAS */
141 bool b_latm_cfg;
142 latm_mux_t latm;
143
144 int i_warnings;
145 } decoder_sys_t;
146
147 enum
148 {
149 WARN_CRC_UNSUPPORTED = 1
150 };
151
152 #define WARN_ONCE(warn, msg) do{\
153 decoder_sys_t *p_sys = p_dec->p_sys;\
154 if( (p_sys->i_warnings & warn) == 0 )\
155 {\
156 p_sys->i_warnings |= warn;\
157 msg_Warn( p_dec, msg );\
158 }\
159 } while(0)
160
161 enum {
162 TYPE_UNKNOWN, /* AAC samples with[out] headers */
163 TYPE_UNKNOWN_NONRAW, /* [un]packetized ADTS or LOAS */
164 TYPE_RAW, /* RAW AAC frames */
165 TYPE_ADTS,
166 TYPE_LOAS
167 };
168
169 static const int pi_sample_rates[16] =
170 {
171 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
172 16000, 12000, 11025, 8000, 7350, 0, 0, 0
173 };
174
175 #define ADTS_HEADER_SIZE 9
176 #define LOAS_HEADER_SIZE 3
177
178 /****************************************************************************
179 * Local prototypes
180 ****************************************************************************/
181 static int OpenPacketizer(vlc_object_t *);
182 static void ClosePacketizer(vlc_object_t *);
183
184 static block_t *Packetize (decoder_t *, block_t **);
185 static void Flush( decoder_t * );
186
187 static int Mpeg4ReadAudioSpecificConfig(bs_t *s, mpeg4_asc_t *p_cfg, bool);
188
189 /*****************************************************************************
190 * Module descriptor
191 *****************************************************************************/
192 vlc_module_begin ()
193 set_category(CAT_SOUT)
194 set_subcategory(SUBCAT_SOUT_PACKETIZER)
195 set_description(N_("MPEG4 audio packetizer"))
196 set_capability("packetizer", 50)
197 set_callbacks(OpenPacketizer, ClosePacketizer)
198 vlc_module_end ()
199
200 /*****************************************************************************
201 * OpenPacketizer: probe the packetizer and return score
202 *****************************************************************************/
203 static int OpenPacketizer(vlc_object_t *p_this)
204 {
205 decoder_t *p_dec = (decoder_t*)p_this;
206 decoder_sys_t *p_sys;
207
208 if (p_dec->fmt_in.i_codec != VLC_CODEC_MP4A)
209 return VLC_EGENERIC;
210
211 /* Allocate the memory needed to store the decoder's structure */
212 if ((p_dec->p_sys = p_sys = (decoder_sys_t *)malloc(sizeof(decoder_sys_t))) == NULL)
213 return VLC_ENOMEM;
214
215 /* Misc init */
216 p_sys->i_state = STATE_NOSYNC;
217 p_sys->b_discontuinity = false;
218 block_BytestreamInit(&p_sys->bytestream);
219 p_sys->b_latm_cfg = false;
220 p_sys->i_warnings = 0;
221
222 /* Set output properties */
223 p_dec->fmt_out.i_codec = VLC_CODEC_MP4A;
224
225 msg_Dbg(p_dec, "running MPEG4 audio packetizer");
226
227 /*
228 * We need to handle 3 cases.
229 * Case 1 : RAW AAC samples without sync header
230 * The demuxer shouldn't need packetizer, see next case.
231 * Case 2 : AAC samples with ADTS or LOAS/LATM header
232 * Some mux (avi) can't distinguish the both
233 * cases above, and then forwards to packetizer
234 * which should check for header and rewire to case below
235 * Case 3 : Non packetized ADTS or LOAS/LATM
236 * The demuxer needs to set original_codec for hardwiring
237 */
238
239 switch (p_dec->fmt_in.i_original_fourcc)
240 {
241 case VLC_FOURCC('L','A','T','M'):
242 p_sys->i_type = TYPE_LOAS;
243 msg_Dbg(p_dec, "LOAS/LATM Mode");
244 break;
245
246 case VLC_FOURCC('A','D','T','S'):
247 p_sys->i_type = TYPE_ADTS;
248 msg_Dbg(p_dec, "ADTS Mode");
249 break;
250
251 case VLC_FOURCC('H','E','A','D'):
252 p_sys->i_type = TYPE_UNKNOWN_NONRAW;
253 break;
254
255 default:
256 p_sys->i_type = TYPE_UNKNOWN;
257 break;
258 }
259
260 /* Some mux (avi) do send RAW AAC without extradata,
261 and LATM can be sent with out-of-band audioconfig,
262 (avformat sets m4a extradata in both cases)
263 so we can't rely on extradata to guess multiplexing */
264 p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
265
266 if(p_dec->fmt_in.i_extra)
267 {
268 mpeg4_asc_t asc;
269 bs_t s;
270 bs_init(&s, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra);
271 if(Mpeg4ReadAudioSpecificConfig(&s, &asc, true) == VLC_SUCCESS)
272 {
273 p_dec->fmt_out.audio.i_rate = asc.i_samplerate;
274 p_dec->fmt_out.audio.i_frame_length = asc.i_frame_length;
275 p_dec->fmt_out.audio.i_channels = asc.i_channel;
276
277 msg_Dbg(p_dec, "%sAAC%s %dHz %d samples/frame",
278 (asc.i_sbr) ? "HE-" : "",
279 (asc.i_ps) ? "v2" : "",
280 (asc.i_sbr) ? p_dec->fmt_out.audio.i_rate << 1
281 : p_dec->fmt_out.audio.i_rate,
282 p_dec->fmt_out.audio.i_frame_length);
283 }
284
285 p_dec->fmt_out.p_extra = malloc(p_dec->fmt_in.i_extra);
286 if (!p_dec->fmt_out.p_extra)
287 return VLC_ENOMEM;
288 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
289 memcpy(p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
290 p_dec->fmt_in.i_extra);
291 }
292 /* else() We will try to create a AAC Config from adts/loas */
293
294 date_Init(&p_sys->end_date, p_dec->fmt_out.audio.i_rate ?
295 p_dec->fmt_out.audio.i_rate : 48000, 1);
296 date_Set(&p_sys->end_date, VLC_TS_INVALID);
297
298 /* Set callbacks */
299 p_dec->pf_packetize = Packetize;
300 p_dec->pf_flush = Flush;
301
302 return VLC_SUCCESS;
303 }
304
305 /*****************************************************************************
306 * ClosePacketizer: clean up the packetizer
307 *****************************************************************************/
308 static void ClosePacketizer(vlc_object_t *p_this)
309 {
310 decoder_t *p_dec = (decoder_t *)p_this;
311 decoder_sys_t *p_sys = p_dec->p_sys;
312
313 block_BytestreamRelease(&p_sys->bytestream);
314 free(p_sys);
315 }
316
317 /****************************************************************************
318 * ForwardRawBlock:
319 ****************************************************************************
320 * This function must be fed with complete frames.
321 ****************************************************************************/
322 static block_t *ForwardRawBlock(decoder_t *p_dec, block_t **pp_block)
323 {
324 decoder_sys_t *p_sys = p_dec->p_sys;
325 block_t *p_block;
326
327 if (!pp_block || !*pp_block)
328 return NULL;
329
330 p_block = *pp_block;
331 *pp_block = NULL; /* Don't reuse this block */
332
333 if (p_block->i_pts != VLC_TS_INVALID &&
334 p_block->i_pts != date_Get(&p_sys->end_date))
335 {
336 if(date_Get(&p_sys->end_date) != VLC_TS_INVALID)
337 p_sys->b_discontuinity = true;
338 date_Set(&p_sys->end_date, p_block->i_pts);
339 }
340
341 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
342
343 /* Might not be known due to missing extradata,
344 will be set to block pts above */
345 if(p_dec->fmt_out.audio.i_frame_length)
346 p_block->i_length = date_Increment(&p_sys->end_date,
347 p_dec->fmt_out.audio.i_frame_length) - p_block->i_pts;
348
349 return p_block;
350 }
351
352 /****************************************************************************
353 * ADTS helpers
354 ****************************************************************************/
355 static int ADTSSyncInfo(decoder_t * p_dec, const uint8_t * p_buf,
356 unsigned int * pi_channels,
357 unsigned int * pi_sample_rate,
358 unsigned int * pi_frame_length,
359 unsigned int * pi_header_size)
360 {
361 int i_profile, i_sample_rate_idx, i_frame_size;
362 bool b_crc;
363
364 /* Fixed header between frames */
365 //int i_id = ((p_buf[1] >> 3) & 0x01) ? 2 : 4; /* MPEG-2 or 4 */
366 b_crc = !(p_buf[1] & 0x01);
367 i_profile = p_buf[2] >> 6;
368 i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
369 *pi_sample_rate = pi_sample_rates[i_sample_rate_idx];
370 //private_bit = (p_buf[2] >> 1) & 0x01;
371 *pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
372 if (*pi_channels == 0) /* workaround broken streams */
373 *pi_channels = 2;
374 //original_copy = (p_buf[3] >> 5) & 0x01;
375 //home = (p_buf[3] >> 4) & 0x01;
376
377 /* Variable header */
378 //copyright_id_bit = (p_buf[3] >> 3) & 0x01;
379 //copyright_id_start = (p_buf[3] >> 2) & 0x01;
380 i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
381 ((p_buf[5] >> 5) /*& 0x7*/);
382 //uint16_t buffer_fullness = ((p_buf[5] & 0x1f) << 6) | (p_buf[6] >> 2);
383 unsigned short i_raw_blocks_in_frame = p_buf[6] & 0x03;
384
385 if (!*pi_sample_rate || !i_frame_size) {
386 msg_Warn(p_dec, "Invalid ADTS header");
387 return 0;
388 }
389
390 *pi_frame_length = 1024;
391
392 if (i_raw_blocks_in_frame == 0) {
393 if (b_crc) {
394 WARN_ONCE(WARN_CRC_UNSUPPORTED, "ADTS CRC not supported");
395 //uint16_t crc = (p_buf[7] << 8) | p_buf[8];
396 }
397 } else {
398 msg_Err(p_dec, "Multiple blocks per frame in ADTS not supported");
399 return 0;
400 #if 0
401 int i;
402 const uint8_t *p_pos = p_buf + 7;
403 uint16_t crc_block;
404 uint16_t i_block_pos[3];
405 if (b_crc) {
406 for (i = 0 ; i < i_raw_blocks_in_frame ; i++) {
407 /* the 1st block's position is known ... */
408 i_block_pos[i] = (*p_pos << 8) | *(p_pos+1);
409 p_pos += 2;
410 }
411 crc_block = (*p_pos << 8) | *(p_pos+1);
412 p_pos += 2;
413 }
414 for (i = 0 ; i <= i_raw_blocks_in_frame ; i++) {
415 //read 1 block
416 if (b_crc) {
417 WARN_ONCE(WARN_CRC_UNSUPPORTED, "ADTS CRC not supported");
418 //uint16_t crc = (*p_pos << 8) | *(p_pos+1);
419 //p_pos += 2;
420 }
421 }
422 #endif
423 }
424
425
426 /* Build the decoder specific info header */
427 if (!p_dec->fmt_out.i_extra) {
428 p_dec->fmt_out.p_extra = malloc(2);
429 if (!p_dec->fmt_out.p_extra) {
430 p_dec->fmt_out.i_extra = 0;
431 return 0;
432 }
433 p_dec->fmt_out.i_extra = 2;
434 ((uint8_t *)p_dec->fmt_out.p_extra)[0] =
435 (i_profile + 1) << 3 | (i_sample_rate_idx >> 1);
436 ((uint8_t *)p_dec->fmt_out.p_extra)[1] =
437 ((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
438 }
439
440 /* ADTS header length */
441 *pi_header_size = b_crc ? 9 : 7;
442
443 return i_frame_size - *pi_header_size;
444 }
445
446 /****************************************************************************
447 * LOAS helpers
448 ****************************************************************************/
449 static int LOASSyncInfo(uint8_t p_header[LOAS_HEADER_SIZE], unsigned int *pi_header_size)
450 {
451 *pi_header_size = 3;
452 return ((p_header[1] & 0x1f) << 8) + p_header[2];
453 }
454
455 static int Mpeg4GAProgramConfigElement(bs_t *s)
456 {
457 /* TODO compute channels count ? */
458 int i_tag = bs_read(s, 4);
459 if (i_tag != 0x05)
460 return -1;
461 bs_skip(s, 2 + 4); // object type + sampling index
462 int i_num_front = bs_read(s, 4);
463 int i_num_side = bs_read(s, 4);
464 int i_num_back = bs_read(s, 4);
465 int i_num_lfe = bs_read(s, 2);
466 int i_num_assoc_data = bs_read(s, 3);
467 int i_num_valid_cc = bs_read(s, 4);
468
469 if (bs_read1(s))
470 bs_skip(s, 4); // mono downmix
471 if (bs_read1(s))
472 bs_skip(s, 4); // stereo downmix
473 if (bs_read1(s))
474 bs_skip(s, 2+1); // matrix downmix + pseudo_surround
475
476 bs_skip(s, i_num_front * (1+4));
477 bs_skip(s, i_num_side * (1+4));
478 bs_skip(s, i_num_back * (1+4));
479 bs_skip(s, i_num_lfe * (4));
480 bs_skip(s, i_num_assoc_data * (4));
481 bs_skip(s, i_num_valid_cc * (5));
482 bs_align(s);
483 int i_comment = bs_read(s, 8);
484 bs_skip(s, i_comment * 8);
485 return 0;
486 }
487
488 static int Mpeg4GASpecificConfig(mpeg4_asc_t *p_cfg, bs_t *s)
489 {
490 p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024;
491 if(p_cfg->i_object_type == 23) /* 14496-3 4.5.1.1 */
492 p_cfg->i_frame_length >>= 1;
493 else if(p_cfg->i_object_type == 3)
494 p_cfg->i_frame_length = 256;
495
496 if (bs_read1(s)) // depend on core coder
497 bs_skip(s, 14); // core coder delay
498
499 int i_extension_flag = bs_read1(s);
500 if (p_cfg->i_channel == 0)
501 Mpeg4GAProgramConfigElement(s);
502 if (p_cfg->i_object_type == 6 || p_cfg->i_object_type == 20)
503 bs_skip(s, 3); // layer
504
505 if (i_extension_flag) {
506 if (p_cfg->i_object_type == 22)
507 bs_skip(s, 5 + 11); // numOfSubFrame + layer length
508 if (p_cfg->i_object_type == 17 || p_cfg->i_object_type == 19 ||
509 p_cfg->i_object_type == 20 || p_cfg->i_object_type == 23)
510 bs_skip(s, 1+1+1); // ER data : section scale spectral */
511 if (bs_read1(s)) // extension 3
512 fprintf(stderr, "Mpeg4GASpecificConfig: error 1\n");
513 }
514 return 0;
515 }
516
517 static int Mpeg4ReadAudioObjectType(bs_t *s)
518 {
519 int i_type = bs_read(s, 5);
520 if (i_type == 31)
521 i_type = 32 + bs_read(s, 6);
522 return i_type;
523 }
524
525 static int Mpeg4ReadAudioSamplerate(bs_t *s)
526 {
527 int i_index = bs_read(s, 4);
528 if (i_index != 0x0f)
529 return pi_sample_rates[i_index];
530 return bs_read(s, 24);
531 }
532
533 static int Mpeg4ReadAudioChannelConfiguration(bs_t *s)
534 {
535 int i_channel = bs_read(s, 4);
536 if (i_channel == 7)
537 i_channel = 8; // 7.1
538 else if (i_channel >= 8)
539 i_channel = -1;
540 return i_channel;
541 }
542
543 static int Mpeg4ReadAudioSpecificConfig(bs_t *s, mpeg4_asc_t *p_cfg, bool b_withext)
544 {
545 #if 0
546 static const char *ppsz_otype[] = {
547 "NULL",
548 "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable",
549 "TwinVQ",
550 "CELP", "HVXC",
551 "Reserved", "Reserved",
552 "TTSI",
553 "Main Synthetic", "Wavetables Synthesis", "General MIDI",
554 "Algorithmic Synthesis and Audio FX",
555 "ER AAC LC",
556 "Reserved",
557 "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
558 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric",
559 "SSC",
560 "PS", "Reserved", "Escape",
561 "Layer 1", "Layer 2", "Layer 3",
562 "DST",
563 };
564 #endif
565 memset(p_cfg, 0, sizeof(*p_cfg));
566
567 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
568 p_cfg->i_samplerate = Mpeg4ReadAudioSamplerate(s);
569 p_cfg->i_channel = Mpeg4ReadAudioChannelConfiguration(s);
570
571 p_cfg->i_sbr = -1;
572 p_cfg->i_ps = -1;
573 p_cfg->extension.i_object_type = 0;
574 p_cfg->extension.i_samplerate = 0;
575 p_cfg->extension.i_channel = -1;
576 if (p_cfg->i_object_type == 5 || p_cfg->i_object_type == 29) {
577 p_cfg->i_sbr = 1;
578 if (p_cfg->i_object_type == 29)
579 p_cfg->i_ps = 1;
580 p_cfg->extension.i_object_type = 5;
581 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
582
583 p_cfg->i_object_type = Mpeg4ReadAudioObjectType(s);
584 if(p_cfg->i_object_type == 22)
585 p_cfg->extension.i_channel = Mpeg4ReadAudioChannelConfiguration(s);
586 }
587
588 switch(p_cfg->i_object_type)
589 {
590 case 1: case 2: case 3: case 4:
591 case 6: case 7:
592 case 17: case 19: case 20: case 21: case 22: case 23:
593 Mpeg4GASpecificConfig(p_cfg, s);
594 break;
595 case 8:
596 // CelpSpecificConfig();
597 case 9:
598 // HvxcSpecificConfig();
599 case 12:
600 // TTSSSpecificConfig();
601 case 13: case 14: case 15: case 16:
602 // StructuredAudioSpecificConfig();
603 case 24:
604 // ERCelpSpecificConfig();
605 case 25:
606 // ERHvxcSpecificConfig();
607 case 26: case 27:
608 // ParametricSpecificConfig();
609 case 28:
610 // SSCSpecificConfig();
611 case 32: case 33: case 34:
612 // MPEG_1_2_SpecificConfig();
613 case 35:
614 // DSTSpecificConfig();
615 case 36:
616 // ALSSpecificConfig();
617 case 37: case 38:
618 // SLSSpecificConfig();
619 case 39:
620 // ELDSpecificConfig();
621 case 40: case 41:
622 // SymbolicMusicSpecificConfig();
623 default:
624 // error
625 return VLC_EGENERIC;
626 }
627
628 switch(p_cfg->i_object_type)
629 {
630 case 17: case 19: case 20: case 21: case 22: case 23:
631 case 24: case 25: case 26: case 27: case 39:
632 {
633 int epConfig = bs_read(s, 2);
634 if (epConfig == 2 || epConfig == 3)
635 //ErrorProtectionSpecificConfig();
636 if (epConfig == 3)
637 if (bs_read1(s)) {
638 // TODO : directMapping
639 }
640 break;
641 }
642 default:
643 break;
644 }
645
646 if (b_withext && p_cfg->extension.i_object_type != 5 && bs_remain(s) >= 16 &&
647 bs_read(s, 11) == 0x2b7) {
648 p_cfg->extension.i_object_type = Mpeg4ReadAudioObjectType(s);
649 if (p_cfg->extension.i_object_type == 5)
650 {
651 p_cfg->i_sbr = bs_read1(s);
652 if (p_cfg->i_sbr == 1) {
653 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
654 if (bs_remain(s) >= 12 && bs_read(s, 11) == 0x548)
655 p_cfg->i_ps = bs_read1(s);
656 }
657 }
658 else if (p_cfg->extension.i_object_type == 22)
659 {
660 p_cfg->i_sbr = bs_read1(s);
661 if(p_cfg->i_sbr)
662 p_cfg->extension.i_samplerate = Mpeg4ReadAudioSamplerate(s);
663 p_cfg->extension.i_channel = Mpeg4ReadAudioChannelConfiguration(s);
664 }
665 }
666
667 //fprintf(stderr, "Mpeg4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n",
668 // ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr);
669
670 return VLC_SUCCESS;
671 }
672
673 static uint32_t LatmGetValue(bs_t *s)
674 {
675 uint32_t v = 0;
676 for (int i = 1 + bs_read(s, 2); i > 0; i--)
677 v = (v << 8) + bs_read(s, 8);
678 return v;
679 }
680
681 static uint32_t AudioSpecificConfigBitsToBytes(bs_t *s, uint32_t i_bits, uint8_t *p_data)
682 {
683 uint32_t i_extra = __MIN((i_bits + 7) / 8, LATM_MAX_EXTRA_SIZE);
684 for (uint32_t i = 0; i < i_extra; i++) {
685 const uint32_t i_read = __MIN(8, i_bits - 8*i);
686 p_data[i] = bs_read(s, i_read) << (8-i_read);
687 }
688 return i_extra;
689 }
690
691 static int LatmReadStreamMuxConfiguration(latm_mux_t *m, bs_t *s)
692 {
693 int i_mux_version;
694 int i_mux_versionA;
695
696 i_mux_version = bs_read(s, 1);
697 i_mux_versionA = 0;
698 if (i_mux_version)
699 i_mux_versionA = bs_read(s, 1);
700
701 if (i_mux_versionA != 0) /* support only A=0 */
702 return -1;
703
704 memset(m, 0, sizeof(*m));
705
706 if (i_mux_versionA == 0)
707 if (i_mux_version == 1)
708 LatmGetValue(s); /* taraBufferFullness */
709
710 m->b_same_time_framing = bs_read1(s);
711 m->i_sub_frames = 1 + bs_read(s, 6);
712 m->i_programs = 1 + bs_read(s, 4);
713
714 for (int i_program = 0; i_program < m->i_programs; i_program++) {
715 m->pi_layers[i_program] = 1+bs_read(s, 3);
716
717 for (int i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++) {
718 latm_stream_t *st = &m->stream[m->i_streams];
719 bool b_previous_cfg;
720
721 m->pi_stream[i_program][i_layer] = m->i_streams;
722 st->i_program = i_program;
723 st->i_layer = i_layer;
724
725 b_previous_cfg = false;
726 if (i_program != 0 || i_layer != 0)
727 b_previous_cfg = bs_read1(s);
728
729 if (b_previous_cfg) {
730 assert(m->i_streams > 0);
731 st->cfg = m->stream[m->i_streams-1].cfg;
732 } else {
733 uint32_t asc_size = 0;
734 if(i_mux_version > 0)
735 asc_size = LatmGetValue(s);
736 bs_t asc_bs = *s;
737 Mpeg4ReadAudioSpecificConfig(&asc_bs, &st->cfg, i_mux_version > 0);
738 if (i_mux_version == 0)
739 asc_size = bs_pos(&asc_bs) - bs_pos(s);
740 asc_bs = *s;
741 st->i_extra = AudioSpecificConfigBitsToBytes(&asc_bs, asc_size, st->extra);
742 bs_skip(s, asc_size);
743 }
744
745 st->i_frame_length_type = bs_read(s, 3);
746 switch(st->i_frame_length_type)
747 {
748 case 0:
749 {
750 bs_skip(s, 8); /* latmBufferFullnes */
751 if (!m->b_same_time_framing)
752 if (st->cfg.i_object_type == 6 || st->cfg.i_object_type == 20 ||
753 st->cfg.i_object_type == 8 || st->cfg.i_object_type == 24)
754 bs_skip(s, 6); /* eFrameOffset */
755 break;
756 }
757 case 1:
758 st->i_frame_length = bs_read(s, 9);
759 break;
760 case 3: case 4: case 5:
761 st->i_frame_length_index = bs_read(s, 6); // celp
762 break;
763 case 6: case 7:
764 st->i_frame_length_index = bs_read(s, 1); // hvxc
765 default:
766 break;
767 }
768 /* Next stream */
769 m->i_streams++;
770 }
771 }
772
773 /* other data */
774 if (bs_read1(s)) {
775 if (i_mux_version == 1)
776 m->i_other_data = LatmGetValue(s);
777 else {
778 int b_continue;
779 do {
780 b_continue = bs_read1(s);
781 m->i_other_data = (m->i_other_data << 8) + bs_read(s, 8);
782 } while (b_continue);
783 }
784 }
785
786 /* crc */
787 m->i_crc = -1;
788 if (bs_read1(s))
789 m->i_crc = bs_read(s, 8);
790
791 return 0;
792 }
793
794 static int LOASParse(decoder_t *p_dec, uint8_t *p_buffer, int i_buffer)
795 {
796 decoder_sys_t *p_sys = p_dec->p_sys;
797 bs_t s;
798 int i_accumulated = 0;
799
800 bs_init(&s, p_buffer, i_buffer);
801
802 /* Read the stream mux configuration if present */
803 if (!bs_read1(&s) && !LatmReadStreamMuxConfiguration(&p_sys->latm, &s) &&
804 p_sys->latm.i_streams > 0) {
805 const latm_stream_t *st = &p_sys->latm.stream[0];
806
807 if(st->cfg.i_samplerate <= 0 || st->cfg.i_channel <=0 || st->cfg.i_frame_length <= 0)
808 return 0;
809
810 p_sys->i_channels = st->cfg.i_channel;
811 p_sys->i_rate = st->cfg.i_samplerate;
812 p_sys->i_frame_length = st->cfg.i_frame_length;
813
814 if (p_sys->i_channels && p_sys->i_rate && p_sys->i_frame_length > 0)
815 {
816 if(p_dec->fmt_out.i_extra != st->i_extra ||
817 (p_dec->fmt_out.i_extra > 0 &&
818 memcmp(p_dec->fmt_out.p_extra, st->extra, st->i_extra)) )
819 {
820 if(p_dec->fmt_out.i_extra)
821 free(p_dec->fmt_out.p_extra);
822 p_dec->fmt_out.p_extra = malloc(st->i_extra);
823 if(p_dec->fmt_out.p_extra)
824 {
825 p_dec->fmt_out.i_extra = st->i_extra;
826 memcpy(p_dec->fmt_out.p_extra, st->extra, st->i_extra);
827 p_sys->b_latm_cfg = true;
828 }
829 else
830 {
831 p_dec->fmt_out.i_extra = 0;
832 p_sys->b_latm_cfg = false;
833 }
834 }
835 }
836 }
837
838 /* Wait for the configuration */
839 if (!p_sys->b_latm_cfg)
840 {
841 /* WAVE_FORMAT_MPEG_LOAS, configuration provided as AAC header :/ */
842 if( p_dec->fmt_in.i_extra > 0 &&
843 p_sys->i_channels && p_sys->i_rate && p_sys->i_frame_length )
844 {
845 p_sys->b_latm_cfg = true;
846 }
847 else return 0;
848 }
849
850 /* FIXME do we need to split the subframe into independent packet ? */
851 if (p_sys->latm.i_sub_frames > 1)
852 msg_Err(p_dec, "latm sub frames not yet supported, please send a sample");
853
854 for (int i_sub = 0; i_sub < p_sys->latm.i_sub_frames; i_sub++) {
855 int pi_payload[LATM_MAX_PROGRAM][LATM_MAX_LAYER];
856 if (p_sys->latm.b_same_time_framing) {
857 /* Payload length */
858 for (int i_program = 0; i_program < p_sys->latm.i_programs; i_program++) {
859 for (int i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++) {
860 latm_stream_t *st = &p_sys->latm.stream[p_sys->latm.pi_stream[i_program][i_layer]];
861 if (st->i_frame_length_type == 0) {
862 int i_payload = 0;
863 for (;;) {
864 int i_tmp = bs_read(&s, 8);
865 i_payload += i_tmp;
866 if (i_tmp != 255)
867 break;
868 }
869 pi_payload[i_program][i_layer] = i_payload;
870 } else if (st->i_frame_length_type == 1) {
871 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
872 } else if ((st->i_frame_length_type == 3) ||
873 (st->i_frame_length_type == 5) ||
874 (st->i_frame_length_type == 7)) {
875 bs_skip(&s, 2); // muxSlotLengthCoded
876 pi_payload[i_program][i_layer] = 0; /* TODO */
877 } else {
878 pi_payload[i_program][i_layer] = 0; /* TODO */
879 }
880 }
881 }
882
883 /* Payload Data */
884 for (int i_program = 0; i_program < p_sys->latm.i_programs; i_program++) {
885 for (int i_layer = 0; i_layer < p_sys->latm.pi_layers[i_program]; i_layer++) {
886 /* XXX we only extract 1 stream */
887 if (i_program != 0 || i_layer != 0)
888 break;
889
890 if (pi_payload[i_program][i_layer] <= 0)
891 continue;
892
893 /* FIXME that's slow (and a bit ugly to write in place) */
894 for (int i = 0; i < pi_payload[i_program][i_layer]; i++) {
895 if (i_accumulated >= i_buffer)
896 return 0;
897 p_buffer[i_accumulated++] = bs_read(&s, 8);
898 }
899 }
900 }
901 } else {
902 const int i_chunks = bs_read(&s, 4);
903 #if 0
904 int pi_program[16];
905 int pi_layer[16];
906 #endif
907
908 msg_Err(p_dec, "latm without same time frameing not yet supported, please send a sample");
909
910 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
911 const int streamIndex = bs_read(&s, 4);
912 latm_stream_t *st = &p_sys->latm.stream[streamIndex];
913 const int i_program = st->i_program;
914 const int i_layer = st->i_layer;
915
916 #if 0
917 pi_program[i_chunk] = i_program;
918 pi_layer[i_chunk] = i_layer;
919 #endif
920
921 if (st->i_frame_length_type == 0) {
922 int i_payload = 0;
923 for (;;) {
924 int i_tmp = bs_read(&s, 8);
925 i_payload += i_tmp;
926 if (i_tmp != 255)
927 break;
928 }
929 pi_payload[i_program][i_layer] = i_payload;
930 bs_skip(&s, 1); // auEndFlag
931 } else if (st->i_frame_length_type == 1) {
932 pi_payload[i_program][i_layer] = st->i_frame_length / 8; /* XXX not correct */
933 } else if ((st->i_frame_length_type == 3) ||
934 (st->i_frame_length_type == 5) ||
935 (st->i_frame_length_type == 7)) {
936 bs_read(&s, 2); // muxSlotLengthCoded
937 }
938 }
939 #if 0
940 for (int i_chunk = 0; i_chunk < i_chunks; i_chunk++) {
941 //const int i_program = pi_program[i_chunk];
942 //const int i_layer = pi_layer[i_chunk];
943
944 /* TODO ? Payload */
945 }
946 #endif
947 }
948 }
949
950 #if 0
951 if (p_sys->latm.i_other_data > 0)
952 ; // TODO
953 #endif
954 bs_align(&s);
955
956 return i_accumulated;
957 }
958
959 /*****************************************************************************
960 *
961 *****************************************************************************/
962 static void SetupOutput(decoder_t *p_dec, block_t *p_block)
963 {
964 decoder_sys_t *p_sys = p_dec->p_sys;
965
966 if (p_dec->fmt_out.audio.i_rate != p_sys->i_rate && p_sys->i_rate > 0)
967 {
968 msg_Info(p_dec, "AAC channels: %d samplerate: %d",
969 p_sys->i_channels, p_sys->i_rate);
970 date_Change(&p_sys->end_date, p_sys->i_rate, 1);
971 }
972
973 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
974 p_dec->fmt_out.audio.i_channels = p_sys->i_channels;
975 p_dec->fmt_out.audio.i_bytes_per_frame = p_sys->i_frame_size;
976 p_dec->fmt_out.audio.i_frame_length = p_sys->i_frame_length;
977
978 #if 0
979 p_dec->fmt_out.audio.i_physical_channels = p_sys->i_channels_conf;
980 #endif
981
982 p_block->i_pts = p_block->i_dts = date_Get(&p_sys->end_date);
983
984 p_block->i_length =
985 date_Increment(&p_sys->end_date, p_sys->i_frame_length) - p_block->i_pts;
986 }
987
988 /*****************************************************************************
989 * FlushStreamBlock:
990 *****************************************************************************/
991 static void Flush(decoder_t *p_dec)
992 {
993 decoder_sys_t *p_sys = p_dec->p_sys;
994
995 p_sys->i_state = STATE_NOSYNC;
996 block_BytestreamEmpty(&p_sys->bytestream);
997 date_Set(&p_sys->end_date, VLC_TS_INVALID);
998 p_sys->b_discontuinity = true;
999 }
1000
1001 static inline bool HasADTSHeader( const uint8_t *p_header )
1002 {
1003 return p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0;
1004 }
1005
1006 static inline bool HasLoasHeader( const uint8_t *p_header )
1007 {
1008 return p_header[0] == 0x56 && (p_header[1] & 0xe0) == 0xe0;
1009 }
1010
1011 /****************************************************************************
1012 * PacketizeStreamBlock: ADTS/LOAS packetizer
1013 ****************************************************************************/
1014 static block_t *PacketizeStreamBlock(decoder_t *p_dec, block_t **pp_block)
1015 {
1016 decoder_sys_t *p_sys = p_dec->p_sys;
1017 uint8_t p_header[ADTS_HEADER_SIZE + LOAS_HEADER_SIZE];
1018 block_t *p_out_buffer;
1019 uint8_t *p_buf;
1020
1021 block_t *p_block = pp_block ? *pp_block : NULL;
1022
1023 if(p_block)
1024 {
1025 block_BytestreamPush(&p_sys->bytestream, p_block);
1026 *pp_block = NULL;
1027 }
1028
1029 for (;;) switch(p_sys->i_state) {
1030 case STATE_NOSYNC:
1031 while (block_PeekBytes(&p_sys->bytestream, p_header, 2) == VLC_SUCCESS) {
1032 /* Look for sync word - should be 0xfff(adts) or 0x2b7(loas) */
1033 if ((p_sys->i_type == TYPE_ADTS || p_sys->i_type == TYPE_UNKNOWN_NONRAW) &&
1034 HasADTSHeader( p_header ) )
1035 {
1036 if (p_sys->i_type != TYPE_ADTS)
1037 msg_Dbg(p_dec, "detected ADTS format");
1038
1039 p_sys->i_state = STATE_SYNC;
1040 p_sys->i_type = TYPE_ADTS;
1041 break;
1042 }
1043 else if ((p_sys->i_type == TYPE_LOAS || p_sys->i_type == TYPE_UNKNOWN_NONRAW) &&
1044 HasLoasHeader( p_header ) )
1045 {
1046 if (p_sys->i_type != TYPE_LOAS)
1047 msg_Dbg(p_dec, "detected LOAS format");
1048
1049 p_sys->i_state = STATE_SYNC;
1050 p_sys->i_type = TYPE_LOAS;
1051 break;
1052 }
1053 block_SkipByte(&p_sys->bytestream);
1054 }
1055 if (p_sys->i_state != STATE_SYNC) {
1056 block_BytestreamFlush(&p_sys->bytestream);
1057
1058 /* Need more data */
1059 return NULL;
1060 }
1061 /* fallthrough */
1062
1063 case STATE_SYNC:
1064 /* New frame, set the Presentation Time Stamp */
1065 p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
1066 if (p_sys->i_pts != VLC_TS_INVALID &&
1067 p_sys->i_pts != date_Get(&p_sys->end_date))
1068 date_Set(&p_sys->end_date, p_sys->i_pts);
1069 p_sys->i_state = STATE_HEADER;
1070 break;
1071
1072 case STATE_HEADER:
1073 if (p_sys->i_type == TYPE_ADTS) {
1074 /* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
1075 if (block_PeekBytes(&p_sys->bytestream, p_header,
1076 ADTS_HEADER_SIZE) != VLC_SUCCESS)
1077 return NULL; /* Need more data */
1078
1079 /* Check if frame is valid and get frame info */
1080 p_sys->i_frame_size = ADTSSyncInfo(p_dec, p_header,
1081 &p_sys->i_channels,
1082 &p_sys->i_rate,
1083 &p_sys->i_frame_length,
1084 &p_sys->i_header_size);
1085 } else {
1086 assert(p_sys->i_type == TYPE_LOAS);
1087 /* Get LOAS frame header (LOAS_HEADER_SIZE bytes) */
1088 if (block_PeekBytes(&p_sys->bytestream, p_header,
1089 LOAS_HEADER_SIZE) != VLC_SUCCESS)
1090 return NULL; /* Need more data */
1091
1092 /* Check if frame is valid and get frame info */
1093 p_sys->i_frame_size = LOASSyncInfo(p_header, &p_sys->i_header_size);
1094 }
1095
1096 if (p_sys->i_frame_size <= 0) {
1097 msg_Dbg(p_dec, "emulated sync word");
1098 block_SkipByte(&p_sys->bytestream);
1099 p_sys->i_state = STATE_NOSYNC;
1100 break;
1101 }
1102
1103 p_sys->i_state = STATE_NEXT_SYNC;
1104 /* fallthrough */
1105
1106 case STATE_NEXT_SYNC:
1107 if (p_sys->bytestream.p_block == NULL) {
1108 p_sys->i_state = STATE_NOSYNC;
1109 block_BytestreamFlush(&p_sys->bytestream);
1110 return NULL;
1111 }
1112
1113 /* Check if next expected frame contains the sync word */
1114 if (block_PeekOffsetBytes(&p_sys->bytestream, p_sys->i_frame_size
1115 + p_sys->i_header_size, p_header, 2) != VLC_SUCCESS)
1116 {
1117 if(p_block == NULL) /* drain */
1118 {
1119 p_sys->i_state = STATE_SEND_DATA;
1120 break;
1121 }
1122 return NULL; /* Need more data */
1123 }
1124
1125 assert((p_sys->i_type == TYPE_ADTS) || (p_sys->i_type == TYPE_LOAS));
1126 if ( (p_sys->i_type == TYPE_ADTS && !HasADTSHeader( p_header )) ||
1127 (p_sys->i_type == TYPE_LOAS && !HasLoasHeader( p_header )) )
1128 {
1129 /* Check spacial padding case. Failing if need more bytes is ok since
1130 that should have been sent as a whole block */
1131 if( block_PeekOffsetBytes(&p_sys->bytestream,
1132 p_sys->i_frame_size + p_sys->i_header_size,
1133 p_header, 3) == VLC_SUCCESS &&
1134 p_header[0] == 0x00 &&
1135 ((p_sys->i_type == TYPE_ADTS && HasADTSHeader( &p_header[1] )) ||
1136 (p_sys->i_type == TYPE_LOAS && !HasLoasHeader( &p_header[1] ))))
1137 {
1138 p_sys->i_state = STATE_SEND_DATA;
1139 }
1140 else
1141 {
1142 msg_Dbg(p_dec, "emulated sync word (no sync on following frame)"
1143 " 0x%"PRIx8" 0x%"PRIx8, p_header[0], p_header[1] );
1144 p_sys->i_state = STATE_NOSYNC;
1145 block_SkipByte(&p_sys->bytestream);
1146 }
1147 break;
1148 }
1149
1150 p_sys->i_state = STATE_SEND_DATA;
1151 break;
1152
1153 case STATE_GET_DATA:
1154 /* Make sure we have enough data.
1155 * (Not useful if we went through NEXT_SYNC) */
1156 if (block_WaitBytes(&p_sys->bytestream, p_sys->i_frame_size +
1157 p_sys->i_header_size) != VLC_SUCCESS)
1158 return NULL; /* Need more data */
1159 p_sys->i_state = STATE_SEND_DATA;
1160 /* fallthrough */
1161
1162 case STATE_SEND_DATA:
1163 /* When we reach this point we already know we have enough
1164 * data available. */
1165
1166 p_out_buffer = block_Alloc(p_sys->i_frame_size);
1167 if (!p_out_buffer) {
1168 return NULL;
1169 }
1170 p_buf = p_out_buffer->p_buffer;
1171
1172 /* Skip the ADTS/LOAS header */
1173 block_SkipBytes(&p_sys->bytestream, p_sys->i_header_size);
1174
1175 /* Copy the whole frame into the buffer */
1176 block_GetBytes(&p_sys->bytestream, p_buf, p_sys->i_frame_size);
1177 if (p_sys->i_type != TYPE_ADTS) { /* parse/extract the whole frame */
1178 assert(p_sys->i_type == TYPE_LOAS);
1179 p_out_buffer->i_buffer = LOASParse(p_dec, p_buf, p_sys->i_frame_size);
1180 if (p_out_buffer->i_buffer <= 0)
1181 {
1182 if (!p_sys->b_latm_cfg)
1183 msg_Warn(p_dec, "waiting for header");
1184
1185 block_Release(p_out_buffer);
1186 p_out_buffer = NULL;
1187 p_sys->i_state = STATE_NOSYNC;
1188 break;
1189 }
1190 }
1191 SetupOutput(p_dec, p_out_buffer);
1192 /* Make sure we don't reuse the same pts twice */
1193 if (p_sys->i_pts == p_sys->bytestream.p_block->i_pts)
1194 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = VLC_TS_INVALID;
1195
1196 /* So p_block doesn't get re-added several times */
1197 if( pp_block )
1198 *pp_block = block_BytestreamPop(&p_sys->bytestream);
1199
1200 p_sys->i_state = STATE_NOSYNC;
1201
1202 return p_out_buffer;
1203 }
1204
1205 return NULL;
1206 }
1207
1208 /****************************************************************************
1209 * Packetize: just forwards raw blocks, or packetizes LOAS/ADTS
1210 * and strips headers
1211 ****************************************************************************/
1212 static block_t *Packetize(decoder_t *p_dec, block_t **pp_block)
1213 {
1214 decoder_sys_t *p_sys = p_dec->p_sys;
1215 block_t *p_block = pp_block ? *pp_block : NULL;
1216
1217 if(p_block)
1218 {
1219 if (p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED))
1220 {
1221 if(p_sys->i_type == TYPE_ADTS || p_sys->i_type == TYPE_LOAS)
1222 {
1223 /* First always drain complete blocks before discontinuity */
1224 block_t *p_drain = PacketizeStreamBlock(p_dec, NULL);
1225 if(p_drain)
1226 return p_drain;
1227 }
1228
1229 Flush(p_dec);
1230
1231 if (p_block->i_flags & BLOCK_FLAG_CORRUPTED)
1232 {
1233 block_Release(p_block);
1234 return NULL;
1235 }
1236 }
1237
1238 if ( p_block->i_pts == VLC_TS_INVALID &&
1239 date_Get(&p_sys->end_date) == VLC_TS_INVALID )
1240 {
1241 /* We've just started the stream, wait for the first PTS. */
1242 block_Release(p_block);
1243 return NULL;
1244 }
1245 }
1246
1247 if(p_block && p_sys->i_type == TYPE_UNKNOWN)
1248 {
1249 p_sys->i_type = TYPE_RAW;
1250 if(p_block->i_buffer > 1)
1251 {
1252 if(p_block->p_buffer[0] == 0xff && (p_block->p_buffer[1] & 0xf6) == 0xf0)
1253 {
1254 p_sys->i_type = TYPE_ADTS;
1255 }
1256 else if(p_block->p_buffer[0] == 0x56 && (p_block->p_buffer[1] & 0xe0) == 0xe0)
1257 {
1258 p_sys->i_type = TYPE_LOAS;
1259 }
1260 }
1261 }
1262
1263 if(p_sys->i_type == TYPE_RAW)
1264 p_block = ForwardRawBlock(p_dec, pp_block);
1265 else
1266 p_block = PacketizeStreamBlock(p_dec, pp_block);
1267
1268 if(p_block && p_sys->b_discontuinity)
1269 {
1270 p_block->i_flags |= BLOCK_FLAG_DISCONTINUITY;
1271 p_sys->b_discontuinity = false;
1272 }
1273
1274 return p_block;
1275 }
VLC Development tree mirror