/****************************************************************************
* DecodeBlock: the whole thing
****************************************************************************
* This function must be fed with whole samples (see nBlockAlign).
****************************************************************************/
static int DecodeBlock( decoder_t *p_dec, block_t *p_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( p_block == NULL ) /* No Drain */
return VLCDEC_SUCCESS;
if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED|BLOCK_FLAG_DISCONTINUITY) )
{
Flush( p_dec );
if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
goto skip;
}
if( p_block->i_pts > VLC_TS_INVALID &&
p_block->i_pts != date_Get( &p_sys->end_date ) )
{
date_Set( &p_sys->end_date, p_block->i_pts );
}
else if( !date_Get( &p_sys->end_date ) )
/* We've just started the stream, wait for the first PTS. */
goto skip;
unsigned samples = (8 * p_block->i_buffer) / p_sys->framebits;
if( samples == 0 )
goto skip;
if( p_sys->decode != NULL )
{
if( decoder_UpdateAudioFormat( p_dec ) )
goto skip;
block_t *p_out = decoder_NewAudioBuffer( p_dec, samples );
if( p_out == NULL )
goto skip;
p_sys->decode( p_out->p_buffer, p_block->p_buffer,
samples * p_dec->fmt_in.audio.i_channels );
block_Release( p_block );
p_block = p_out;
}
else
{
decoder_UpdateAudioFormat( p_dec );
p_block->i_nb_samples = samples;
p_block->i_buffer = samples * (p_sys->framebits / 8);
}
p_block->i_pts = date_Get( &p_sys->end_date );
p_block->i_length = date_Increment( &p_sys->end_date, samples )
- p_block->i_pts;
decoder_QueueAudio( p_dec, p_block );
return VLCDEC_SUCCESS;
skip:
block_Release( p_block );
return VLCDEC_SUCCESS;
}
/****************************************************************************
* DecodeBlock: the whole thing
****************************************************************************
* This function must be fed with whole samples (see nBlockAlign).
****************************************************************************/
static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( pp_block == NULL )
return NULL;
block_t *p_block = *pp_block;
if( p_block == NULL )
return NULL;
*pp_block = NULL;
if( p_block->i_pts > VLC_TS_INVALID &&
p_block->i_pts != date_Get( &p_sys->end_date ) )
{
date_Set( &p_sys->end_date, p_block->i_pts );
}
else if( !date_Get( &p_sys->end_date ) )
/* We've just started the stream, wait for the first PTS. */
goto skip;
unsigned samples = (8 * p_block->i_buffer) / p_sys->framebits;
if( samples == 0 )
goto skip;
if( p_sys->decode != NULL )
{
block_t *p_out = decoder_NewAudioBuffer( p_dec, samples );
if( p_out == NULL )
goto skip;
p_sys->decode( p_out->p_buffer, p_block->p_buffer,
samples * p_dec->fmt_in.audio.i_channels );
block_Release( p_block );
p_block = p_out;
}
else
{
decoder_UpdateAudioFormat( p_dec );
p_block->i_nb_samples = samples;
p_block->i_buffer = samples * (p_sys->framebits / 8);
}
p_block->i_pts = date_Get( &p_sys->end_date );
p_block->i_length = date_Increment( &p_sys->end_date, samples )
- p_block->i_pts;
return p_block;
skip:
block_Release( p_block );
return NULL;
}
/*****************************************************************************
* DecodePacket: decodes a Vorbis packet.
*****************************************************************************/
static block_t *DecodePacket( decoder_t *p_dec, ogg_packet *p_oggpacket )
{
decoder_sys_t *p_sys = p_dec->p_sys;
int i_samples;
INTERLEAVE_TYPE **pp_pcm;
if( p_oggpacket->bytes &&
vorbis_synthesis( &p_sys->vb, p_oggpacket ) == 0 )
vorbis_synthesis_blockin( &p_sys->vd, &p_sys->vb );
/* **pp_pcm is a multichannel float vector. In stereo, for
* example, pp_pcm[0] is left, and pp_pcm[1] is right. i_samples is
* the size of each channel. Convert the float values
* (-1.<=range<=1.) to whatever PCM format and write it out */
if( ( i_samples = vorbis_synthesis_pcmout( &p_sys->vd, &pp_pcm ) ) > 0 )
{
block_t *p_aout_buffer;
if( decoder_UpdateAudioFormat( p_dec ) ) return NULL;
p_aout_buffer =
decoder_NewAudioBuffer( p_dec, i_samples );
if( p_aout_buffer == NULL ) return NULL;
/* Interleave the samples */
Interleave( (INTERLEAVE_TYPE*)p_aout_buffer->p_buffer,
(const INTERLEAVE_TYPE**)pp_pcm, p_sys->vi.channels, i_samples,
p_sys->pi_chan_table);
/* Tell libvorbis how many samples we actually consumed */
vorbis_synthesis_read( &p_sys->vd, i_samples );
/* Date management */
p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
p_aout_buffer->i_length = date_Increment( &p_sys->end_date,
i_samples ) - p_aout_buffer->i_pts;
return p_aout_buffer;
}
else
{
return NULL;
}
}
static int UpdateAudioFormat( decoder_t *p_dec )
{
int i_err;
decoder_sys_t *p_sys = p_dec->p_sys;
struct mpg123_frameinfo frame_info;
/* Get details about the stream */
i_err = mpg123_info( p_sys->p_handle, &frame_info );
if( i_err != MPG123_OK )
{
msg_Err( p_dec, "mpg123_info failed: %s",
mpg123_plain_strerror( i_err ) );
return VLC_EGENERIC;
}
p_dec->fmt_out.i_bitrate = frame_info.bitrate * 1000;
switch( frame_info.mode )
{
case MPG123_M_DUAL:
p_dec->fmt_out.audio.i_chan_mode = AOUT_CHANMODE_DUALMONO;
/* fall through */
case MPG123_M_STEREO:
case MPG123_M_JOINT:
p_dec->fmt_out.audio.i_physical_channels =
AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
break;
case MPG123_M_MONO:
p_dec->fmt_out.audio.i_physical_channels = AOUT_CHAN_CENTER;
break;
default:
return VLC_EGENERIC;
}
aout_FormatPrepare( &p_dec->fmt_out.audio );
/* Date management */
if( p_dec->fmt_out.audio.i_rate != frame_info.rate )
{
p_dec->fmt_out.audio.i_rate = frame_info.rate;
date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
date_Set( &p_sys->end_date, 0 );
}
return decoder_UpdateAudioFormat( p_dec );
}
static int ProcessOutputStream(decoder_t *p_dec, DWORD stream_id)
{
decoder_sys_t *p_sys = p_dec->p_sys;
HRESULT hr;
picture_t *picture = NULL;
block_t *aout_buffer = NULL;
DWORD output_status = 0;
MFT_OUTPUT_DATA_BUFFER output_buffer = { stream_id, p_sys->output_sample, 0, NULL };
hr = IMFTransform_ProcessOutput(p_sys->mft, 0, 1, &output_buffer, &output_status);
if (output_buffer.pEvents)
IMFCollection_Release(output_buffer.pEvents);
/* Use the returned sample since it can be provided by the MFT. */
IMFSample *output_sample = output_buffer.pSample;
if (hr == S_OK)
{
if (!output_sample)
return VLC_SUCCESS;
LONGLONG sample_time;
hr = IMFSample_GetSampleTime(output_sample, &sample_time);
if (FAILED(hr))
goto error;
/* Convert from 100 nanoseconds unit to microseconds. */
sample_time /= 10;
DWORD total_length = 0;
hr = IMFSample_GetTotalLength(output_sample, &total_length);
if (FAILED(hr))
goto error;
if (p_dec->fmt_in.i_cat == VIDEO_ES)
{
if (decoder_UpdateVideoFormat(p_dec))
return VLC_SUCCESS;
picture = decoder_NewPicture(p_dec);
if (!picture)
return VLC_SUCCESS;
UINT32 interlaced = false;
hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_Interlaced, &interlaced);
picture->b_progressive = !interlaced;
picture->date = sample_time;
}
else
{
if (decoder_UpdateAudioFormat(p_dec))
goto error;
if (p_dec->fmt_out.audio.i_bitspersample == 0 || p_dec->fmt_out.audio.i_channels == 0)
goto error;
int samples = total_length / (p_dec->fmt_out.audio.i_bitspersample * p_dec->fmt_out.audio.i_channels / 8);
aout_buffer = decoder_NewAudioBuffer(p_dec, samples);
if (!aout_buffer)
return VLC_SUCCESS;
if (aout_buffer->i_buffer < total_length)
goto error;
aout_buffer->i_pts = sample_time;
}
IMFMediaBuffer *output_media_buffer = NULL;
hr = IMFSample_GetBufferByIndex(output_sample, 0, &output_media_buffer);
BYTE *buffer_start;
hr = IMFMediaBuffer_Lock(output_media_buffer, &buffer_start, NULL, NULL);
if (FAILED(hr))
goto error;
if (p_dec->fmt_in.i_cat == VIDEO_ES)
CopyPackedBufferToPicture(picture, buffer_start);
else
memcpy(aout_buffer->p_buffer, buffer_start, total_length);
hr = IMFMediaBuffer_Unlock(output_media_buffer);
IMFSample_Release(output_media_buffer);
if (FAILED(hr))
goto error;
if (p_sys->output_sample)
{
/* Sample is not provided by the MFT: clear its content. */
hr = IMFMediaBuffer_SetCurrentLength(output_media_buffer, 0);
if (FAILED(hr))
goto error;
}
else
{
/* Sample is provided by the MFT: decrease refcount. */
IMFSample_Release(output_sample);
}
}
else if (hr == MF_E_TRANSFORM_STREAM_CHANGE || hr == MF_E_TRANSFORM_TYPE_NOT_SET)
{
if (p_sys->output_type)
IMFMediaType_Release(p_sys->output_type);
if (SetOutputType(p_dec, p_sys->output_stream_id, &p_sys->output_type))
goto error;
/* Reallocate output sample. */
if (p_sys->output_sample)
IMFSample_Release(p_sys->output_sample);
p_sys->output_sample = NULL;
if (AllocateOutputSample(p_dec, 0, &p_sys->output_sample))
goto error;
return VLC_SUCCESS;
}
else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
{
return VLC_SUCCESS;
}
else /* An error not listed above occurred */
{
msg_Err(p_dec, "Unexpected error in IMFTransform::ProcessOutput: %#lx",
hr);
goto error;
}
if (p_dec->fmt_in.i_cat == VIDEO_ES)
decoder_QueueVideo(p_dec, picture);
else
decoder_QueueAudio(p_dec, aout_buffer);
return VLC_SUCCESS;
error:
msg_Err(p_dec, "Error in ProcessOutputStream()");
if (picture)
picture_Release(picture);
if (aout_buffer)
block_Release(aout_buffer);
return VLC_EGENERIC;
}
/*****************************************************************************
* DecodeBlock:
*****************************************************************************/
static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_block;
if( !pp_block || !*pp_block ) return NULL;
p_block = *pp_block;
*pp_block = NULL;
if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED) )
{
Flush( p_dec );
if( p_block->i_flags & (BLOCK_FLAG_CORRUPTED) )
{
block_Release( p_block );
return NULL;
}
}
/* Remove ADTS header if we have decoder specific config */
if( p_dec->fmt_in.i_extra && p_block->i_buffer > 7 )
{
if( p_block->p_buffer[0] == 0xff &&
( p_block->p_buffer[1] & 0xf0 ) == 0xf0 ) /* syncword */
{ /* ADTS header present */
size_t i_header_size; /* 7 bytes (+ 2 bytes for crc) */
i_header_size = 7 + ( ( p_block->p_buffer[1] & 0x01 ) ? 0 : 2 );
/* FIXME: multiple blocks per frame */
if( p_block->i_buffer > i_header_size )
{
p_block->p_buffer += i_header_size;
p_block->i_buffer -= i_header_size;
}
}
}
/* Append the block to the temporary buffer */
if( p_sys->i_buffer_size < p_sys->i_buffer + p_block->i_buffer )
{
size_t i_buffer_size = p_sys->i_buffer + p_block->i_buffer;
uint8_t *p_buffer = realloc( p_sys->p_buffer, i_buffer_size );
if( p_buffer )
{
p_sys->i_buffer_size = i_buffer_size;
p_sys->p_buffer = p_buffer;
}
else
{
p_block->i_buffer = 0;
}
}
if( p_block->i_buffer > 0 )
{
memcpy( &p_sys->p_buffer[p_sys->i_buffer],
p_block->p_buffer, p_block->i_buffer );
p_sys->i_buffer += p_block->i_buffer;
p_block->i_buffer = 0;
}
if( p_dec->fmt_out.audio.i_rate == 0 && p_dec->fmt_in.i_extra > 0 )
{
/* We have a decoder config so init the handle */
unsigned long i_rate;
unsigned char i_channels;
if( NeAACDecInit2( p_sys->hfaad, p_dec->fmt_in.p_extra,
p_dec->fmt_in.i_extra,
&i_rate, &i_channels ) >= 0 )
{
p_dec->fmt_out.audio.i_rate = i_rate;
p_dec->fmt_out.audio.i_channels = i_channels;
p_dec->fmt_out.audio.i_physical_channels
= p_dec->fmt_out.audio.i_original_channels
= pi_channels_guessed[i_channels];
date_Init( &p_sys->date, i_rate, 1 );
}
}
if( p_dec->fmt_out.audio.i_rate == 0 && p_sys->i_buffer )
{
unsigned long i_rate;
unsigned char i_channels;
/* Init faad with the first frame */
if( NeAACDecInit( p_sys->hfaad,
p_sys->p_buffer, p_sys->i_buffer,
&i_rate, &i_channels ) < 0 )
{
block_Release( p_block );
return NULL;
}
p_dec->fmt_out.audio.i_rate = i_rate;
p_dec->fmt_out.audio.i_channels = i_channels;
p_dec->fmt_out.audio.i_physical_channels
= p_dec->fmt_out.audio.i_original_channels
= pi_channels_guessed[i_channels];
date_Init( &p_sys->date, i_rate, 1 );
}
if( p_block->i_pts > VLC_TS_INVALID && p_block->i_pts != date_Get( &p_sys->date ) )
{
date_Set( &p_sys->date, p_block->i_pts );
}
else if( !date_Get( &p_sys->date ) )
{
/* We've just started the stream, wait for the first PTS. */
block_Release( p_block );
p_sys->i_buffer = 0;
return NULL;
}
/* Decode all data */
if( p_sys->i_buffer > 1)
{
void *samples;
NeAACDecFrameInfo frame;
block_t *p_out;
samples = NeAACDecDecode( p_sys->hfaad, &frame,
p_sys->p_buffer, p_sys->i_buffer );
if( frame.error > 0 )
{
msg_Warn( p_dec, "%s", NeAACDecGetErrorMessage( frame.error ) );
if( frame.error == 21 || frame.error == 12 )
{
/*
* Once an "Unexpected channel configuration change"
* or a "Invalid number of channels" error
* occurs, it will occurs afterwards, and we got no sound.
* Reinitialization of the decoder is required.
*/
unsigned long i_rate;
unsigned char i_channels;
NeAACDecHandle *hfaad;
NeAACDecConfiguration *cfg,*oldcfg;
oldcfg = NeAACDecGetCurrentConfiguration( p_sys->hfaad );
hfaad = NeAACDecOpen();
cfg = NeAACDecGetCurrentConfiguration( hfaad );
if( oldcfg->defSampleRate )
cfg->defSampleRate = oldcfg->defSampleRate;
cfg->defObjectType = oldcfg->defObjectType;
cfg->outputFormat = oldcfg->outputFormat;
NeAACDecSetConfiguration( hfaad, cfg );
if( NeAACDecInit( hfaad, p_sys->p_buffer, p_sys->i_buffer,
&i_rate,&i_channels ) < 0 )
{
/* reinitialization failed */
NeAACDecClose( hfaad );
NeAACDecSetConfiguration( p_sys->hfaad, oldcfg );
}
else
{
NeAACDecClose( p_sys->hfaad );
p_sys->hfaad = hfaad;
p_dec->fmt_out.audio.i_rate = i_rate;
p_dec->fmt_out.audio.i_channels = i_channels;
p_dec->fmt_out.audio.i_physical_channels
= p_dec->fmt_out.audio.i_original_channels
= pi_channels_guessed[i_channels];
date_Init( &p_sys->date, i_rate, 1 );
}
}
/* Flush the buffer */
p_sys->i_buffer = 0;
block_Release( p_block );
return NULL;
}
if( frame.channels <= 0 || frame.channels > 8 || frame.channels == 7 )
{
msg_Warn( p_dec, "invalid channels count: %i", frame.channels );
/* Flush the buffer */
p_sys->i_buffer -= frame.bytesconsumed;
if( p_sys->i_buffer > 0 )
{
memmove( p_sys->p_buffer,&p_sys->p_buffer[frame.bytesconsumed],
p_sys->i_buffer );
}
block_Release( p_block );
return NULL;
}
if( frame.samples <= 0 )
{
msg_Warn( p_dec, "decoded zero sample" );
/* Flush the buffer */
p_sys->i_buffer -= frame.bytesconsumed;
if( p_sys->i_buffer > 1 )
{
memmove( p_sys->p_buffer,&p_sys->p_buffer[frame.bytesconsumed],
p_sys->i_buffer );
}
else
{
/* Drop byte of padding */
p_sys->i_buffer = 0;
}
block_Release( p_block );
return NULL;
}
/* We decoded a valid frame */
if( p_dec->fmt_out.audio.i_rate != frame.samplerate )
{
date_Init( &p_sys->date, frame.samplerate, 1 );
date_Set( &p_sys->date, p_block->i_pts );
}
p_block->i_pts = VLC_TS_INVALID; /* PTS is valid only once */
p_dec->fmt_out.audio.i_rate = frame.samplerate;
p_dec->fmt_out.audio.i_channels = frame.channels;
/* Adjust stream info when dealing with SBR/PS */
bool b_sbr = (frame.sbr == 1) || (frame.sbr == 2);
if( p_sys->b_sbr != b_sbr || p_sys->b_ps != frame.ps )
{
const char *psz_ext = (b_sbr && frame.ps) ? "SBR+PS" :
b_sbr ? "SBR" : "PS";
msg_Dbg( p_dec, "AAC %s (channels: %u, samplerate: %lu)",
psz_ext, frame.channels, frame.samplerate );
if( !p_dec->p_description )
p_dec->p_description = vlc_meta_New();
if( p_dec->p_description )
vlc_meta_AddExtra( p_dec->p_description, _("AAC extension"), psz_ext );
p_sys->b_sbr = b_sbr;
p_sys->b_ps = frame.ps;
}
/* Convert frame.channel_position to our own channel values */
p_dec->fmt_out.audio.i_physical_channels = 0;
const uint32_t nbChannels = frame.channels;
unsigned j;
for( unsigned i = 0; i < nbChannels; i++ )
{
/* Find the channel code */
for( j = 0; j < MAX_CHANNEL_POSITIONS; j++ )
{
if( frame.channel_position[i] == pi_channels_in[j] )
break;
}
if( j >= MAX_CHANNEL_POSITIONS )
{
msg_Warn( p_dec, "unknown channel ordering" );
/* Invent something */
j = i;
}
/* */
p_sys->pi_channel_positions[i] = pi_channels_out[j];
if( p_dec->fmt_out.audio.i_physical_channels & pi_channels_out[j] )
frame.channels--; /* We loose a duplicated channel */
else
p_dec->fmt_out.audio.i_physical_channels |= pi_channels_out[j];
}
if ( nbChannels != frame.channels )
{
p_dec->fmt_out.audio.i_physical_channels
= p_dec->fmt_out.audio.i_original_channels
= pi_channels_guessed[nbChannels];
}
else
{
p_dec->fmt_out.audio.i_original_channels =
p_dec->fmt_out.audio.i_physical_channels;
}
p_dec->fmt_out.audio.i_channels = nbChannels;
if( decoder_UpdateAudioFormat( p_dec ) )
p_out = NULL;
else
p_out = decoder_NewAudioBuffer( p_dec, frame.samples / nbChannels );
if( p_out == NULL )
{
p_sys->i_buffer = 0;
block_Release( p_block );
return NULL;
}
p_out->i_pts = date_Get( &p_sys->date );
p_out->i_length = date_Increment( &p_sys->date,
frame.samples / nbChannels )
- p_out->i_pts;
DoReordering( (uint32_t *)p_out->p_buffer, samples,
frame.samples / nbChannels, nbChannels,
p_sys->pi_channel_positions );
p_sys->i_buffer -= frame.bytesconsumed;
if( p_sys->i_buffer > 0 )
{
memmove( p_sys->p_buffer, &p_sys->p_buffer[frame.bytesconsumed],
p_sys->i_buffer );
}
block_Release( p_block );
return p_out;
}
else
{
/* Drop byte of padding */
p_sys->i_buffer = 0;
}
block_Release( p_block );
return NULL;
}
static int Open( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t *)p_this;
decoder_sys_t *p_sys;
if( p_dec->fmt_in.i_codec != VLC_CODEC_DTS
|| p_dec->fmt_in.audio.i_rate == 0
|| p_dec->fmt_in.audio.i_physical_channels == 0
|| p_dec->fmt_in.audio.i_original_channels == 0
|| p_dec->fmt_in.audio.i_bytes_per_frame == 0
|| p_dec->fmt_in.audio.i_frame_length == 0 )
return VLC_EGENERIC;
/* Allocate the memory needed to store the module's structure */
p_sys = p_dec->p_sys = malloc( sizeof(decoder_sys_t) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_sys->b_dynrng = var_InheritBool( p_this, "dts-dynrng" );
p_sys->b_dontwarn = 0;
/* We'll do our own downmixing, thanks. */
p_sys->i_nb_channels = aout_FormatNbChannels( &p_dec->fmt_in.audio );
if( channels_vlc2dca( &p_dec->fmt_in.audio, &p_sys->i_flags )
!= VLC_SUCCESS )
{
msg_Warn( p_this, "unknown sample format!" );
free( p_sys );
return VLC_EGENERIC;
}
//p_sys->i_flags |= DCA_ADJUST_LEVEL;
/* Initialize libdca */
p_sys->p_libdca = dca_init( 0 );
if( p_sys->p_libdca == NULL )
{
msg_Err( p_this, "unable to initialize libdca" );
free( p_sys );
return VLC_EGENERIC;
}
/* libdca channel order
* libdca currently only decodes 5.1, even if you have a DTS-ES source. */
static const uint32_t pi_channels_in[] = {
AOUT_CHAN_CENTER, AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT,
AOUT_CHAN_REARCENTER, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT,
AOUT_CHAN_LFE, 0
};
aout_CheckChannelReorder( pi_channels_in, NULL,
p_dec->fmt_in.audio.i_physical_channels,
p_sys->pi_chan_table );
p_dec->fmt_out.i_cat = AUDIO_ES;
p_dec->fmt_out.audio = p_dec->fmt_in.audio;
p_dec->fmt_out.audio.i_format = VLC_CODEC_FL32;
p_dec->fmt_out.i_codec = p_dec->fmt_out.audio.i_format;
aout_FormatPrepare( &p_dec->fmt_out.audio );
if( decoder_UpdateAudioFormat( p_dec ) )
{
es_format_Init( &p_dec->fmt_out, UNKNOWN_ES, 0 );
Close( p_this );
return VLC_EGENERIC;
}
p_dec->pf_decode = Decode;
p_dec->pf_flush = NULL;
return VLC_SUCCESS;
}
/*****************************************************************************
* DecodeAudio: Called to decode one frame
*****************************************************************************/
static block_t *DecodeAudio( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
AVCodecContext *ctx = p_sys->p_context;
AVFrame *frame = NULL;
block_t *p_block = NULL;
if( !ctx->extradata_size && p_dec->fmt_in.i_extra && p_sys->b_delayed_open)
{
InitDecoderConfig( p_dec, ctx );
OpenAudioCodec( p_dec );
}
if( p_sys->b_delayed_open )
{
if( pp_block )
p_block = *pp_block;
goto drop;
}
/* Flushing or decoding, we return any block ready from multiple frames output */
if( p_sys->p_decoded )
return DequeueOneDecodedFrame( p_sys );
if( pp_block == NULL ) /* Drain request */
{
/* we don't need to care about return val */
(void) avcodec_send_packet( ctx, NULL );
}
else
{
p_block = *pp_block;
}
if( p_block )
{
if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
{
Flush( p_dec );
goto drop;
}
if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
{
date_Set( &p_sys->end_date, VLC_TS_INVALID );
}
/* We've just started the stream, wait for the first PTS. */
if( !date_Get( &p_sys->end_date ) && p_block->i_pts <= VLC_TS_INVALID )
goto drop;
if( p_block->i_buffer <= 0 )
goto drop;
if( (p_block->i_flags & BLOCK_FLAG_PRIVATE_REALLOCATED) == 0 )
{
p_block = block_Realloc( p_block, 0, p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
if( !p_block )
return NULL;
*pp_block = p_block;
p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
memset( &p_block->p_buffer[p_block->i_buffer], 0, FF_INPUT_BUFFER_PADDING_SIZE );
p_block->i_flags |= BLOCK_FLAG_PRIVATE_REALLOCATED;
}
}
frame = av_frame_alloc();
if (unlikely(frame == NULL))
goto end;
for( int ret = 0; ret == 0; )
{
/* Feed in the loop as buffer could have been full on first iterations */
if( p_block )
{
AVPacket pkt;
av_init_packet( &pkt );
pkt.data = p_block->p_buffer;
pkt.size = p_block->i_buffer;
ret = avcodec_send_packet( ctx, &pkt );
if( ret == 0 ) /* Block has been consumed */
{
/* Only set new pts from input block if it has been used,
* otherwise let it be through interpolation */
if( p_block->i_pts > date_Get( &p_sys->end_date ) )
{
date_Set( &p_sys->end_date, p_block->i_pts );
}
block_Release( p_block );
*pp_block = p_block = NULL;
}
else if ( ret != AVERROR(EAGAIN) ) /* Errors other than buffer full */
{
if( ret == AVERROR(ENOMEM) || ret == AVERROR(EINVAL) )
goto end;
else
goto drop;
}
}
/* Try to read one or multiple frames */
ret = avcodec_receive_frame( ctx, frame );
if( ret == 0 )
{
/* checks and init from first decoded frame */
if( ctx->channels <= 0 || ctx->channels > 8 || ctx->sample_rate <= 0 )
{
msg_Warn( p_dec, "invalid audio properties channels count %d, sample rate %d",
ctx->channels, ctx->sample_rate );
goto drop;
}
else if( p_dec->fmt_out.audio.i_rate != (unsigned int)ctx->sample_rate )
{
date_Init( &p_sys->end_date, ctx->sample_rate, 1 );
}
SetupOutputFormat( p_dec, true );
if( decoder_UpdateAudioFormat( p_dec ) )
goto drop;
block_t *p_converted = ConvertAVFrame( p_dec, frame ); /* Consumes frame */
if( p_converted )
{
/* Silent unwanted samples */
if( p_sys->i_reject_count > 0 )
{
memset( p_converted->p_buffer, 0, p_converted->i_buffer );
p_sys->i_reject_count--;
}
p_converted->i_buffer = p_converted->i_nb_samples
* p_dec->fmt_out.audio.i_bytes_per_frame;
p_converted->i_pts = date_Get( &p_sys->end_date );
p_converted->i_length = date_Increment( &p_sys->end_date,
p_converted->i_nb_samples ) - p_converted->i_pts;
block_ChainLastAppend( &p_sys->pp_decoded_last, p_converted );
}
/* Prepare new frame */
frame = av_frame_alloc();
if (unlikely(frame == NULL))
break;
}
else av_frame_free( &frame );
};
return ( p_sys->p_decoded ) ? DequeueOneDecodedFrame( p_sys ) : NULL;
end:
p_dec->b_error = true;
if( pp_block )
{
assert( *pp_block == p_block );
*pp_block = NULL;
}
drop:
if( p_block != NULL )
block_Release(p_block);
if( frame != NULL )
av_frame_free( &frame );
return NULL;
}
static int Audio_GetOutput(decoder_t *p_dec, picture_t **pp_out_pic,
block_t **pp_out_block, bool *p_abort,
mtime_t i_timeout)
{
decoder_sys_t *p_sys = p_dec->p_sys;
mc_api_out out;
int i_ret;
(void) p_abort;
assert(!pp_out_pic && pp_out_block);
i_ret = p_sys->api->get_out(p_sys->api, &out, i_timeout);
if (i_ret != 1)
return i_ret;
if (out.type == MC_OUT_TYPE_BUF)
{
block_t *p_block = NULL;
if (!p_sys->b_has_format) {
msg_Warn(p_dec, "Buffers returned before output format is set, dropping frame");
return p_sys->api->release_out(p_sys->api, out.u.buf.i_index, false);
}
p_block = block_Alloc(out.u.buf.i_size);
if (!p_block)
return -1;
p_block->i_nb_samples = out.u.buf.i_size
/ p_dec->fmt_out.audio.i_bytes_per_frame;
if (p_sys->u.audio.b_extract)
{
aout_ChannelExtract(p_block->p_buffer,
p_dec->fmt_out.audio.i_channels,
out.u.buf.p_ptr, p_sys->u.audio.i_channels,
p_block->i_nb_samples, p_sys->u.audio.pi_extraction,
p_dec->fmt_out.audio.i_bitspersample);
}
else
memcpy(p_block->p_buffer, out.u.buf.p_ptr, out.u.buf.i_size);
if (out.u.buf.i_ts != 0 && out.u.buf.i_ts != date_Get(&p_sys->u.audio.i_end_date))
date_Set(&p_sys->u.audio.i_end_date, out.u.buf.i_ts);
p_block->i_pts = date_Get(&p_sys->u.audio.i_end_date);
p_block->i_length = date_Increment(&p_sys->u.audio.i_end_date,
p_block->i_nb_samples)
- p_block->i_pts;
if (p_sys->api->release_out(p_sys->api, out.u.buf.i_index, false))
{
block_Release(p_block);
return -1;
}
*pp_out_block = p_block;
return 1;
} else {
uint32_t i_layout_dst;
int i_channels_dst;
assert(out.type == MC_OUT_TYPE_CONF);
if (out.u.conf.audio.channel_count <= 0
|| out.u.conf.audio.channel_count > 8
|| out.u.conf.audio.sample_rate <= 0)
{
msg_Warn( p_dec, "invalid audio properties channels count %d, sample rate %d",
out.u.conf.audio.channel_count,
out.u.conf.audio.sample_rate);
return -1;
}
msg_Err(p_dec, "output: channel_count: %d, channel_mask: 0x%X, rate: %d",
out.u.conf.audio.channel_count, out.u.conf.audio.channel_mask,
out.u.conf.audio.sample_rate);
p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
p_dec->fmt_out.audio.i_format = p_dec->fmt_out.i_codec;
p_dec->fmt_out.audio.i_rate = out.u.conf.audio.sample_rate;
date_Init(&p_sys->u.audio.i_end_date, out.u.conf.audio.sample_rate, 1 );
p_sys->u.audio.i_channels = out.u.conf.audio.channel_count;
p_sys->u.audio.b_extract =
aout_CheckChannelExtraction(p_sys->u.audio.pi_extraction,
&i_layout_dst, &i_channels_dst,
NULL, pi_audio_order_src,
p_sys->u.audio.i_channels);
if (p_sys->u.audio.b_extract)
msg_Warn(p_dec, "need channel extraction: %d -> %d",
p_sys->u.audio.i_channels, i_channels_dst);
p_dec->fmt_out.audio.i_original_channels =
p_dec->fmt_out.audio.i_physical_channels = i_layout_dst;
aout_FormatPrepare(&p_dec->fmt_out.audio);
if (decoder_UpdateAudioFormat(p_dec))
return -1;
p_sys->b_has_format = true;
return 0;
}
}
/*****************************************************************************
* DecodeBlock:
*****************************************************************************/
static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_block;
if( !*pp_block ) return NULL;
p_block = *pp_block;
if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
{
Flush( p_dec );
if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
goto drop;
}
if( p_block->i_pts > VLC_TS_INVALID &&
p_block->i_pts != date_Get( &p_sys->end_date ) )
{
date_Set( &p_sys->end_date, p_block->i_pts );
}
else if( !date_Get( &p_sys->end_date ) )
/* We've just started the stream, wait for the first PTS. */
goto drop;
/* Don't re-use the same pts twice */
p_block->i_pts = VLC_TS_INVALID;
if( p_block->i_buffer >= p_sys->i_block )
{
block_t *p_out;
if( decoder_UpdateAudioFormat( p_dec ) )
goto drop;
p_out = decoder_NewAudioBuffer( p_dec, p_sys->i_samplesperblock );
if( p_out == NULL )
goto drop;
p_out->i_pts = date_Get( &p_sys->end_date );
p_out->i_length = date_Increment( &p_sys->end_date,
p_sys->i_samplesperblock ) - p_out->i_pts;
switch( p_sys->codec )
{
case ADPCM_IMA_QT:
DecodeAdpcmImaQT( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
break;
case ADPCM_IMA_WAV:
DecodeAdpcmImaWav( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
break;
case ADPCM_MS:
DecodeAdpcmMs( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
break;
case ADPCM_DK4:
DecodeAdpcmDk4( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
break;
case ADPCM_DK3:
DecodeAdpcmDk3( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
break;
case ADPCM_EA:
DecodeAdpcmEA( p_dec, (int16_t*)p_out->p_buffer,
p_block->p_buffer );
default:
break;
}
p_block->p_buffer += p_sys->i_block;
p_block->i_buffer -= p_sys->i_block;
return p_out;
}
drop:
block_Release( p_block );
*pp_block = NULL;
return NULL;
}
/*****************************************************************************
* DecodeAudio: Called to decode one frame
*****************************************************************************/
static block_t *DecodeAudio( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
AVCodecContext *ctx = p_sys->p_context;
AVFrame *frame = NULL;
if( !pp_block || !*pp_block )
return NULL;
block_t *p_block = *pp_block;
if( !ctx->extradata_size && p_dec->fmt_in.i_extra && p_sys->b_delayed_open)
{
InitDecoderConfig( p_dec, ctx );
OpenAudioCodec( p_dec );
}
if( p_sys->b_delayed_open )
goto end;
if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
{
Flush( p_dec );
goto end;
}
if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
{
date_Set( &p_sys->end_date, VLC_TS_INVALID );
}
/* We've just started the stream, wait for the first PTS. */
if( !date_Get( &p_sys->end_date ) && p_block->i_pts <= VLC_TS_INVALID )
goto end;
if( p_block->i_buffer <= 0 )
goto end;
if( (p_block->i_flags & BLOCK_FLAG_PRIVATE_REALLOCATED) == 0 )
{
p_block = block_Realloc( p_block, 0, p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE );
if( !p_block )
return NULL;
*pp_block = p_block;
p_block->i_buffer -= FF_INPUT_BUFFER_PADDING_SIZE;
memset( &p_block->p_buffer[p_block->i_buffer], 0, FF_INPUT_BUFFER_PADDING_SIZE );
p_block->i_flags |= BLOCK_FLAG_PRIVATE_REALLOCATED;
}
frame = av_frame_alloc();
if (unlikely(frame == NULL))
goto end;
for( int got_frame = 0; !got_frame; )
{
if( p_block->i_buffer == 0 )
goto end;
AVPacket pkt;
av_init_packet( &pkt );
pkt.data = p_block->p_buffer;
pkt.size = p_block->i_buffer;
int ret = avcodec_send_packet( ctx, &pkt );
if( ret != 0 && ret != AVERROR(EAGAIN) )
{
msg_Warn( p_dec, "cannot decode one frame (%zu bytes)",
p_block->i_buffer );
goto end;
}
int used = ret != AVERROR(EAGAIN) ? pkt.size : 0;
ret = avcodec_receive_frame( ctx, frame );
if( ret != 0 && ret != AVERROR(EAGAIN) )
{
msg_Warn( p_dec, "cannot decode one frame (%zu bytes)",
p_block->i_buffer );
goto end;
}
got_frame = ret == 0;
p_block->p_buffer += used;
p_block->i_buffer -= used;
}
if( ctx->channels <= 0 || ctx->channels > 8 || ctx->sample_rate <= 0 )
{
msg_Warn( p_dec, "invalid audio properties channels count %d, sample rate %d",
ctx->channels, ctx->sample_rate );
goto end;
}
if( p_dec->fmt_out.audio.i_rate != (unsigned int)ctx->sample_rate )
date_Init( &p_sys->end_date, ctx->sample_rate, 1 );
if( p_block->i_pts > date_Get( &p_sys->end_date ) )
{
date_Set( &p_sys->end_date, p_block->i_pts );
}
if( p_block->i_buffer == 0 )
{ /* Done with this buffer */
block_Release( p_block );
p_block = NULL;
*pp_block = NULL;
}
/* NOTE WELL: Beyond this point, p_block refers to the DECODED block! */
SetupOutputFormat( p_dec, true );
if( decoder_UpdateAudioFormat( p_dec ) )
goto drop;
/* Interleave audio if required */
if( av_sample_fmt_is_planar( ctx->sample_fmt ) )
{
p_block = block_Alloc(frame->linesize[0] * ctx->channels);
if (unlikely(p_block == NULL))
goto drop;
const void *planes[ctx->channels];
for (int i = 0; i < ctx->channels; i++)
planes[i] = frame->extended_data[i];
aout_Interleave(p_block->p_buffer, planes, frame->nb_samples,
ctx->channels, p_dec->fmt_out.audio.i_format);
p_block->i_nb_samples = frame->nb_samples;
av_frame_free(&frame);
}
else
{
p_block = vlc_av_frame_Wrap(frame);
if (unlikely(p_block == NULL))
goto drop;
frame = NULL;
}
if (p_sys->b_extract)
{ /* TODO: do not drop channels... at least not here */
block_t *p_buffer = block_Alloc( p_dec->fmt_out.audio.i_bytes_per_frame
* p_block->i_nb_samples );
if( unlikely(p_buffer == NULL) )
goto drop;
aout_ChannelExtract( p_buffer->p_buffer,
p_dec->fmt_out.audio.i_channels,
p_block->p_buffer, ctx->channels,
p_block->i_nb_samples, p_sys->pi_extraction,
p_dec->fmt_out.audio.i_bitspersample );
p_buffer->i_nb_samples = p_block->i_nb_samples;
block_Release( p_block );
p_block = p_buffer;
}
/* Silent unwanted samples */
if( p_sys->i_reject_count > 0 )
{
memset( p_block->p_buffer, 0, p_block->i_buffer );
p_sys->i_reject_count--;
}
p_block->i_buffer = p_block->i_nb_samples
* p_dec->fmt_out.audio.i_bytes_per_frame;
p_block->i_pts = date_Get( &p_sys->end_date );
p_block->i_length = date_Increment( &p_sys->end_date,
p_block->i_nb_samples ) - p_block->i_pts;
return p_block;
end:
*pp_block = NULL;
drop:
av_frame_free(&frame);
if( p_block != NULL )
block_Release(p_block);
return NULL;
}
