Skip to content

V
vlc
Commit 80a06d33 authored by Gildas Bazin's avatar Gildas Bazin
Browse files
Options 

* modules/packetizer/mpeg4audio.c: ported to the new decoder api and added ADTS streams packetization.
parent f8258e32
Hide whitespace changes
Inline Side-by-side
Showing with 376 additions and 217 deletions
modules/packetizer/mpeg4audio.c
View file @ 80a06d33
/*****************************************************************************
* mpeg4audio.c
* mpeg4audio.c: parse and packetize an MPEG 4 audio stream
*****************************************************************************
* Copyright (C) 2001, 2002 VideoLAN
* $Id: mpeg4audio.c,v 1.8 2003/09/24 14:59:21 fenrir Exp $
* $Id: mpeg4audio.c,v 1.9 2003/10/05 18:09:36 gbazin Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
* Gildas Bazin <gbazin@netcourrier.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
......@@ -24,18 +25,17 @@
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <stdlib.h> /* malloc(), free() */
#include <string.h> /* strdup() */
#include <vlc/vlc.h>
#include <vlc/aout.h>
#include <vlc/decoder.h>
#include <vlc/input.h>
#include <vlc/sout.h>
#include "codecs.h"
#include <stdlib.h> /* malloc(), free() */
#include <string.h> /* strdup() */
/*****************************************************************************
* Local prototypes
*****************************************************************************/
#include "vlc_block_helper.h"
/* AAC Config in ES:
*
......@@ -50,313 +50,472 @@
* ExtensionFlag 1 bit (always 0)
*/
typedef struct packetizer_thread_s
/*****************************************************************************
* decoder_sys_t : decoder descriptor
*****************************************************************************/
struct decoder_sys_t
{
/* Input properties */
int b_adts;
decoder_fifo_t *p_fifo;
bit_stream_t bit_stream;
/* Output properties */
/*
* Input properties
*/
int i_state;
vlc_bool_t b_synchro;
block_t *p_chain;
block_bytestream_t bytestream;
/*
* Packetizer output properties
*/
sout_packetizer_input_t *p_sout_input;
sout_format_t output_format;
// mtime_t i_pts_start;
mtime_t i_last_pts;
sout_format_t sout_format;
sout_buffer_t * p_sout_buffer; /* current sout buffer */
/*
* Common properties
*/
audio_date_t end_date;
mtime_t pts;
int i_frame_size, i_raw_blocks;
unsigned int i_channels;
unsigned int i_rate, i_frame_length;
};
WAVEFORMATEX *p_wf;
enum {
/* Extracted from AAC config */
int i_sample_rate;
int i_frame_size; // 1024 or 960
STATE_NOSYNC,
STATE_SYNC,
STATE_HEADER,
STATE_NEXT_SYNC,
STATE_DATA
};
} packetizer_thread_t;
static int i_sample_rates[] =
{
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000, 7350, 0, 0, 0
};
static int Open ( vlc_object_t * );
static int Run ( decoder_fifo_t * );
#define ADTS_HEADER_SIZE 6
static int InitThread ( packetizer_thread_t * );
static void PacketizeThreadMPEG4 ( packetizer_thread_t * );
static void PacketizeThreadADTS ( packetizer_thread_t * );
static void EndThread ( packetizer_thread_t * );
/****************************************************************************
* Local prototypes
****************************************************************************/
static int OpenPacketizer( vlc_object_t * );
static int InitPacketizer( decoder_t * );
static int RunFramePacketizer ( decoder_t *, block_t * );
static int RunADTSPacketizer ( decoder_t *, block_t * );
static int EndPacketizer ( decoder_t * );
static int GetSoutBuffer( decoder_t *, sout_buffer_t ** );
static int ADTSSyncInfo( decoder_t *, const byte_t * p_buf,
unsigned int * pi_channels,
unsigned int * pi_sample_rate,
unsigned int * pi_frame_length,
unsigned int * pi_raw_blocks );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
vlc_module_begin();
set_description( _("MPEG4 Audio packetizer") );
set_capability( "packetizer", 50 );
set_callbacks( Open, NULL );
set_callbacks( OpenPacketizer, NULL );
vlc_module_end();
/*****************************************************************************
* OpenDecoder: probe the packetizer and return score
*****************************************************************************
* Tries to launch a decoder and return score so that the interface is able
* to choose.
* OpenPacketizer: probe the packetizer and return score
*****************************************************************************/
static int Open( vlc_object_t *p_this )
static int OpenPacketizer( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
if( p_dec->p_fifo->i_fourcc != VLC_FOURCC( 'm', 'p', '4', 'a') )
if( p_dec->p_fifo->i_fourcc != VLC_FOURCC( 'm', 'p', '4', 'a' ) )
{
return VLC_EGENERIC;
}
p_dec->pf_run = Run;
/* Allocate the memory needed to store the decoder's structure */
if( ( p_dec->p_sys =
(decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
{
msg_Err( p_dec, "out of memory" );
return VLC_EGENERIC;
}
p_dec->pf_init = InitPacketizer;
p_dec->pf_decode = RunFramePacketizer;
p_dec->pf_end = EndPacketizer;
return VLC_SUCCESS;
}
/*****************************************************************************
* RunDecoder: this function is called just after the thread is created
* InitPacketizer: Initalize the packetizer
*****************************************************************************/
static int Run( decoder_fifo_t *p_fifo )
static int InitPacketizer( decoder_t *p_dec )
{
packetizer_thread_t *p_pack;
int b_error;
decoder_sys_t *p_sys = p_dec->p_sys;
WAVEFORMATEX *p_wf;
msg_Info( p_fifo, "Running MPEG4 audio packetizer" );
if( !( p_pack = malloc( sizeof( packetizer_thread_t ) ) ) )
{
msg_Err( p_fifo, "out of memory" );
DecoderError( p_fifo );
return( -1 );
}
memset( p_pack, 0, sizeof( packetizer_thread_t ) );
p_sys->i_state = STATE_NOSYNC;
p_sys->b_synchro = VLC_FALSE;
p_pack->p_fifo = p_fifo;
aout_DateSet( &p_sys->end_date, 0 );
if( InitThread( p_pack ) != 0 )
{
DecoderError( p_fifo );
return( -1 );
}
p_sys->p_sout_input = NULL;
p_sys->p_sout_buffer = NULL;
p_sys->p_chain = NULL;
msg_Info( p_dec, "Running MPEG4 audio packetizer" );
while( ( !p_pack->p_fifo->b_die )&&( !p_pack->p_fifo->b_error ) )
p_wf = (WAVEFORMATEX*)p_dec->p_fifo->p_waveformatex;
if( p_wf && p_wf->cbSize > 0)
{
if( p_pack->b_adts )
uint8_t *p_config = (uint8_t*)&p_wf[1];
int i_index;
i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) ) & 0x0f;
if( i_index != 0x0f )
{
PacketizeThreadADTS( p_pack );
p_sys->i_rate = i_sample_rates[i_index];
p_sys->i_frame_length = (( p_config[1] >> 2 ) & 0x01) ? 960 : 1024;
}
else
{
PacketizeThreadMPEG4( p_pack );
p_sys->i_rate = ( ( p_config[1] & 0x7f ) << 17 ) |
( p_config[2] << 9 ) | ( p_config[3] << 1 ) |
( p_config[4] >> 7 );
p_sys->i_frame_length = (( p_config[4] >> 2 ) & 0x01) ? 960 : 1024;
}
}
msg_Dbg( p_dec, "AAC %dHz %d samples/frame",
p_sys->i_rate, p_sys->i_frame_length );
if( ( b_error = p_pack->p_fifo->b_error ) )
p_sys->i_channels = p_wf->nChannels;
p_sys->sout_format.i_extra_data = p_wf->cbSize;
p_sys->sout_format.p_extra_data = malloc( p_wf->cbSize );
memcpy( p_sys->sout_format.p_extra_data, &p_wf[1], p_wf->cbSize );
}
else
{
DecoderError( p_pack->p_fifo );
msg_Dbg( p_dec, "No decoder specific info, must be an ADTS stream" );
/* We will try to create a AAC Config from adts */
p_sys->sout_format.i_extra_data = 0;
p_sys->sout_format.p_extra_data = NULL;
p_dec->pf_decode = RunADTSPacketizer;
}
EndThread( p_pack );
if( b_error )
return VLC_SUCCESS;
}
/****************************************************************************
* RunFramePacketizer: the whole thing
****************************************************************************
* This function must be fed with complete frames.
****************************************************************************/
static int RunFramePacketizer( decoder_t *p_dec, block_t *p_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( !aout_DateGet( &p_sys->end_date ) && !p_block->i_pts )
{
return( -1 );
/* We've just started the stream, wait for the first PTS. */
block_Release( p_block );
return VLC_SUCCESS;
}
return( 0 );
}
p_sys->pts = p_block->i_pts;
p_sys->i_frame_size = p_block->i_buffer;
if( GetSoutBuffer( p_dec, &p_sys->p_sout_buffer ) != VLC_SUCCESS )
{
return VLC_EGENERIC;
}
/* Copy the whole frame into the buffer */
p_dec->p_vlc->pf_memcpy( p_sys->p_sout_buffer->p_buffer,
p_block->p_buffer, p_block->i_buffer );
#define FREE( p ) if( p ) free( p ); p = NULL
sout_InputSendBuffer( p_sys->p_sout_input, p_sys->p_sout_buffer );
p_sys->p_sout_buffer = NULL;
/*****************************************************************************
* InitThread: initialize data before entering main loop
*****************************************************************************/
static int i_sample_rates[] =
{
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000, 7350, 0, 0, 0
};
block_Release( p_block );
return VLC_SUCCESS;
}
static int InitThread( packetizer_thread_t *p_pack )
/****************************************************************************
* RunADTSPacketizer: the whole thing
****************************************************************************/
static int RunADTSPacketizer( decoder_t *p_dec, block_t *p_block )
{
WAVEFORMATEX *p_wf;
p_wf = (WAVEFORMATEX*)p_pack->p_fifo->p_waveformatex;
decoder_sys_t *p_sys = p_dec->p_sys;
uint8_t p_header[ADTS_HEADER_SIZE];
if( p_wf && p_wf->cbSize > 0)
if( (!aout_DateGet( &p_sys->end_date ) && !p_block->i_pts)
|| p_block->b_discontinuity )
{
uint8_t *p_config = (uint8_t*)&p_wf[1];
int i_index;
p_pack->b_adts = 0;
/* We've just started the stream, wait for the first PTS. */
block_Release( p_block );
p_sys->b_synchro = VLC_FALSE;
return VLC_SUCCESS;
}
i_index = ( ( p_config[0] << 1 ) | ( p_config[1] >> 7 ) )&0x0f;
if( i_index != 0x0f )
{
p_pack->i_sample_rate = i_sample_rates[i_index];
p_pack->i_frame_size = ( ( p_config[1] >> 2 )&0x01 ) ? 960 : 1024;
}
else
{
p_pack->i_sample_rate = ( ( p_config[1]&0x7f ) << 17 ) | ( p_config[2] << 9 )|
( p_config[3] << 1 ) | ( p_config[4] >> 7 );
p_pack->i_frame_size = ( ( p_config[4] >> 2 )&0x01 ) ? 960 : 1024;
}
msg_Dbg( p_pack->p_fifo,
"aac %dHz %d samples/frame",
p_pack->i_sample_rate,
p_pack->i_frame_size );
p_pack->output_format.i_cat = AUDIO_ES;
p_pack->output_format.i_fourcc = VLC_FOURCC( 'm', 'p', '4', 'a' );
p_pack->output_format.i_sample_rate = p_pack->i_sample_rate;
p_pack->output_format.i_channels = p_wf->nChannels;
p_pack->output_format.i_block_align = 0;
p_pack->output_format.i_bitrate = 0;
p_pack->output_format.i_extra_data = p_wf->cbSize;
p_pack->output_format.p_extra_data = malloc( p_wf->cbSize );
memcpy( p_pack->output_format.p_extra_data,
&p_wf[1],
p_wf->cbSize );
if( p_sys->p_chain )
{
block_ChainAppend( &p_sys->p_chain, p_block );
}
else
{
/* we will try to create a AAC Config from adts */
p_pack->output_format.i_cat = UNKNOWN_ES;
p_pack->output_format.i_fourcc = VLC_FOURCC( 'n', 'u', 'l', 'l' );
p_pack->b_adts = 1;
block_ChainAppend( &p_sys->p_chain, p_block );
p_sys->bytestream = block_BytestreamInit( p_dec, p_sys->p_chain, 0 );
}
if( InitBitstream( &p_pack->bit_stream, p_pack->p_fifo,
NULL, NULL ) != VLC_SUCCESS )
while( 1 )
{
switch( p_sys->i_state )
{
msg_Err( p_pack->p_fifo, "cannot initialize bitstream" );
return -1;
}
}
case STATE_NOSYNC:
while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
== VLC_SUCCESS )
{
/* Look for sync word - should be 0xfff + 2 layer bits */
if( p_header[0] == 0xff && (p_header[1] & 0xf6) == 0xf0 )
{
p_sys->i_state = STATE_SYNC;
break;
}
block_SkipByte( &p_sys->bytestream );
p_sys->b_synchro = VLC_FALSE;
}
if( p_sys->i_state != STATE_SYNC )
{
block_ChainRelease( p_sys->p_chain );
p_sys->p_chain = NULL;
p_pack->p_sout_input =
sout_InputNew( p_pack->p_fifo,
&p_pack->output_format );
/* Need more data */
return VLC_SUCCESS;
}
if( !p_pack->p_sout_input )
{
msg_Err( p_pack->p_fifo,
"cannot add a new stream" );
return( -1 );
case STATE_SYNC:
/* New frame, set the Presentation Time Stamp */
p_sys->pts = p_sys->bytestream.p_block->i_pts;
if( p_sys->pts != 0 &&
p_sys->pts != aout_DateGet( &p_sys->end_date ) )
{
aout_DateSet( &p_sys->end_date, p_sys->pts );
}
p_sys->i_state = STATE_HEADER;
break;
case STATE_HEADER:
/* Get ADTS frame header (ADTS_HEADER_SIZE bytes) */
if( block_PeekBytes( &p_sys->bytestream, p_header,
ADTS_HEADER_SIZE ) != VLC_SUCCESS )
{
/* Need more data */
return VLC_SUCCESS;
}
/* Check if frame is valid and get frame info */
p_sys->i_frame_size = ADTSSyncInfo( p_dec, p_header,
&p_sys->i_channels,
&p_sys->i_rate,
&p_sys->i_frame_length,
&p_sys->i_raw_blocks );
if( !p_sys->i_frame_size )
{
msg_Dbg( p_dec, "emulated sync word" );
block_SkipByte( &p_sys->bytestream );
p_sys->i_state = STATE_NOSYNC;
p_sys->b_synchro = VLC_FALSE;
break;
}
p_sys->i_state = STATE_DATA;
case STATE_DATA:
/* TODO: If p_block == NULL, flush the buffer without checking the
* next sync word */
if( !p_sys->b_synchro )
{
/* Check if next expected frame contains the sync word */
if( block_PeekOffsetBytes( &p_sys->bytestream,
p_sys->i_frame_size, p_header, 2 )
!= VLC_SUCCESS )
{
/* Need more data */
return VLC_SUCCESS;
}
if( p_header[0] != 0xff || (p_header[1] & 0xf6) != 0xf0 )
{
msg_Dbg( p_dec, "emulated sync word "
"(no sync on following frame)" );
p_sys->i_state = STATE_NOSYNC;
block_SkipByte( &p_sys->bytestream );
p_sys->b_synchro = VLC_FALSE;
break;
}
}
if( !p_sys->p_sout_buffer )
if( GetSoutBuffer( p_dec, &p_sys->p_sout_buffer ) != VLC_SUCCESS )
{
return VLC_EGENERIC;
}
/* Copy the whole frame into the buffer */
if( block_GetBytes( &p_sys->bytestream,
p_sys->p_sout_buffer->p_buffer,
p_sys->i_frame_size ) != VLC_SUCCESS )
{
/* Need more data */
return VLC_SUCCESS;
}
p_sys->p_chain = block_BytestreamFlush( &p_sys->bytestream );
sout_InputSendBuffer( p_sys->p_sout_input, p_sys->p_sout_buffer );
p_sys->i_state = STATE_NOSYNC;
p_sys->p_sout_buffer = NULL;
p_sys->b_synchro = VLC_TRUE;
/* Make sure we don't reuse the same pts twice */
if( p_sys->pts == p_sys->bytestream.p_block->i_pts )
p_sys->pts = p_sys->bytestream.p_block->i_pts = 0;
}
}
p_pack->i_last_pts = 0;
return( 0 );
return VLC_SUCCESS;
}
/*****************************************************************************
* PacketizeThread: packetize an unit (here copy a complete pes)
* GetSoutBuffer:
*****************************************************************************/
static void PacketizeThreadMPEG4( packetizer_thread_t *p_pack )
static int GetSoutBuffer( decoder_t *p_dec, sout_buffer_t **pp_buffer )
{
sout_buffer_t *p_sout_buffer;
pes_packet_t *p_pes;
ssize_t i_size;
mtime_t i_pts;
/* **** get samples count **** */
input_ExtractPES( p_pack->p_fifo, &p_pes );
if( !p_pes )
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_sys->p_sout_input != NULL &&
( p_sys->sout_format.i_sample_rate != (int)p_sys->i_rate
|| p_sys->sout_format.i_channels != (int)p_sys->i_channels ) )
{
p_pack->p_fifo->b_error = 1;
return;
/* Parameters changed - this should not happen. */
}
#if 0
if( p_pack->i_pts_start < 0 && p_pes->i_pts > 0 )
/* Creating the sout input if not created yet. */
if( p_sys->p_sout_input == NULL )
{
p_pack->i_pts_start = p_pes->i_pts;
p_sys->sout_format.i_cat = AUDIO_ES;
p_sys->sout_format.i_fourcc = VLC_FOURCC( 'm', 'p', '4', 'a' );
p_sys->sout_format.i_sample_rate = p_sys->i_rate;
p_sys->sout_format.i_channels = p_sys->i_channels;
p_sys->sout_format.i_block_align = 0;
p_sys->sout_format.i_bitrate = 0;
aout_DateInit( &p_sys->end_date, p_sys->i_rate );
aout_DateSet( &p_sys->end_date, p_sys->pts );
p_sys->p_sout_input = sout_InputNew( p_dec, &p_sys->sout_format );
if( p_sys->p_sout_input == NULL )
{
msg_Err( p_dec, "cannot add a new stream" );
*pp_buffer = NULL;
return VLC_EGENERIC;
}
msg_Info( p_dec, "AAC channels: %d samplerate: %d",
p_sys->i_channels, p_sys->i_rate );
}
p_pack->i_pts = p_pes->i_pts - p_pack->i_pts_start;
#endif
i_pts = p_pes->i_pts;
if( i_pts <= 0 && p_pack->i_last_pts <= 0 )
*pp_buffer = sout_BufferNew( p_sys->p_sout_input->p_sout,
p_sys->i_frame_size );
if( *pp_buffer == NULL )
{
msg_Dbg( p_pack->p_fifo, "need a starting pts" );
input_DeletePES( p_pack->p_fifo->p_packets_mgt, p_pes );
return;
return VLC_EGENERIC;
}
i_size = p_pes->i_pes_size;
if( i_size > 0 )
{
data_packet_t *p_data;
ssize_t i_buffer;
(*pp_buffer)->i_pts =
(*pp_buffer)->i_dts = aout_DateGet( &p_sys->end_date );
p_sout_buffer =
sout_BufferNew( p_pack->p_sout_input->p_sout, i_size );
if( !p_sout_buffer )
{
p_pack->p_fifo->b_error = 1;
input_DeletePES( p_pack->p_fifo->p_packets_mgt, p_pes );
return;
}
/* TODO: memcpy of the pes packet */
for( i_buffer = 0, p_data = p_pes->p_first;
p_data != NULL && i_buffer < i_size;
p_data = p_data->p_next)
{
size_t i_copy;
(*pp_buffer)->i_length =
aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length )
- (*pp_buffer)->i_pts;
i_copy = __MIN( p_data->p_payload_end - p_data->p_payload_start,
i_size - i_buffer );
if( i_copy > 0 )
{
p_pack->p_fifo->p_vlc->pf_memcpy( p_sout_buffer->p_buffer + i_buffer,
p_data->p_payload_start,
i_copy );
}
i_buffer += i_copy;
}
return VLC_SUCCESS;
}
if( i_pts <= 0 )
/*****************************************************************************
* EndPacketizer: clean up the packetizer
*****************************************************************************/
static int EndPacketizer( decoder_t *p_dec )
{
if( p_dec->p_sys->p_sout_input != NULL )
{
if( p_dec->p_sys->p_sout_buffer )
{
i_pts = p_pack->i_last_pts +
(mtime_t)1000000 *
(mtime_t)p_pack->i_frame_size /
(mtime_t)p_pack->i_sample_rate;
sout_BufferDelete( p_dec->p_sys->p_sout_input->p_sout,
p_dec->p_sys->p_sout_buffer );
}
p_pack->i_last_pts = i_pts;
p_sout_buffer->i_length = (mtime_t)1000000 *
(mtime_t)p_pack->i_frame_size /
(mtime_t)p_pack->i_sample_rate;
p_sout_buffer->i_bitrate = 0;
p_sout_buffer->i_dts = i_pts;
p_sout_buffer->i_pts = i_pts;
sout_InputSendBuffer( p_pack->p_sout_input,
p_sout_buffer );
sout_InputDelete( p_dec->p_sys->p_sout_input );
}
input_DeletePES( p_pack->p_fifo->p_packets_mgt, p_pes );
}
if( p_dec->p_sys->p_chain ) block_ChainRelease( p_dec->p_sys->p_chain );
free( p_dec->p_sys );
static void PacketizeThreadADTS( packetizer_thread_t *p_pack )
{
msg_Err( p_pack->p_fifo, "adts stream unsupported" );
p_pack->p_fifo->b_error = 1;
return VLC_SUCCESS;
}
/*****************************************************************************
* EndThread : packetizer thread destruction
* ADTSSyncInfo: parse MPEG 4 audio ADTS sync info
*****************************************************************************/
static void EndThread ( packetizer_thread_t *p_pack)
static int ADTSSyncInfo( decoder_t * p_dec, const byte_t * p_buf,
unsigned int * pi_channels,
unsigned int * pi_sample_rate,
unsigned int * pi_frame_length,
unsigned int * pi_raw_blocks_in_frame )
{
if( p_pack->p_sout_input )
decoder_sys_t *p_sys = p_dec->p_sys;
int i_id, i_profile, i_sample_rate_idx, i_frame_size;
/* Fixed header between frames */
i_id = ( (p_buf[1] >> 3) & 0x01 ) ? 2 : 4;
i_profile = p_buf[2] >> 6;
i_sample_rate_idx = (p_buf[2] >> 2) & 0x0f;
*pi_sample_rate = i_sample_rates[i_sample_rate_idx];
*pi_channels = ((p_buf[2] & 0x01) << 2) | ((p_buf[3] >> 6) & 0x03);
/* Variable header */
i_frame_size = ((p_buf[3] & 0x03) << 11) | (p_buf[4] << 3) |
((p_buf[5] >> 5) & 0x7);
*pi_raw_blocks_in_frame = (p_buf[6] & 0x02) + 1;
if( !*pi_sample_rate || !*pi_channels || !i_frame_size )
{
sout_InputDelete( p_pack->p_sout_input );
return 0;
}
if( p_pack->p_wf )
/* Fixme */
*pi_frame_length = 1024;
/* Build the decoder specific info header */
if( !p_dec->p_sys->sout_format.i_extra_data )
{
free( p_pack->p_wf );
p_sys->sout_format.i_extra_data = 2;
p_sys->sout_format.p_extra_data = malloc( 2 );
p_sys->sout_format.p_extra_data[0] =
(i_profile + 1) << 3 | (i_sample_rate_idx > 1);
p_sys->sout_format.p_extra_data[1] =
((i_sample_rate_idx & 0x01) << 7) | (*pi_channels <<3);
}
free( p_pack );
return i_frame_size;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment