static void codecs_init(void *base, u32 codec_mask)
{
int i;
for (i = 2; i >= 0; i--) {
if (codec_mask & (1 << i))
codec_init(base, i);
}
}
/* PT=32
* MPV: MPEG Video (RFC2250, §3.5)
*/
static void *mpv_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, VIDEO_ES, VLC_CODEC_MPGV);
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
static void codecs_init(struct device *dev, u8 *base, u32 codec_mask)
{
int i;
for (i = 2; i >= 0; i--) {
if (codec_mask & (1 << i))
codec_init(dev, base, i);
}
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
size_t n;
unsigned char *filebuf;
int sample_loc;
intptr_t param;
if (codec_init())
return CODEC_ERROR;
ci->configure(DSP_SET_FREQUENCY, ci->id3->frequency);
codec_set_replaygain(ci->id3);
/* Intialise the A52 decoder and check for success */
state = a52_init(0);
samplesdone = 0;
/* The main decoding loop */
if (ci->id3->offset) {
if (ci->seek_buffer(ci->id3->offset)) {
samplesdone = (ci->id3->offset / ci->id3->bytesperframe) *
A52_SAMPLESPERFRAME;
ci->set_elapsed(samplesdone/(ci->id3->frequency / 1000));
}
}
else {
ci->seek_buffer(ci->id3->first_frame_offset);
ci->set_elapsed(0);
}
while (1) {
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
if (action == CODEC_ACTION_SEEK_TIME) {
sample_loc = param/1000 * ci->id3->frequency;
if (ci->seek_buffer((sample_loc/A52_SAMPLESPERFRAME)*ci->id3->bytesperframe)) {
samplesdone = sample_loc;
ci->set_elapsed(samplesdone/(ci->id3->frequency/1000));
}
ci->seek_complete();
}
filebuf = ci->request_buffer(&n, BUFFER_SIZE);
if (n == 0) /* End of Stream */
break;
a52_decode_data(filebuf, filebuf + n);
ci->advance_buffer(n);
}
return CODEC_OK;
}
/* PT=14
* MPA: MPEG Audio (RFC2250, §3.4)
*/
static void *mpa_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_MPGA);
fmt.audio.i_channels = 2;
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
/* PT=12
* QCELP
*/
static void *qcelp_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_QCELP);
fmt.audio.i_rate = 8000;
fmt.audio.i_channels = 1;
return codec_init (demux, &fmt);
}
static void *l16m_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_S16B);
fmt.audio.i_rate = 44100;
fmt.audio.i_channels = 1;
return codec_init (demux, &fmt);
}
/* PT=10,11
* L16: 16-bits (network byte order) PCM
*/
static void *l16s_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_S16B);
fmt.audio.i_rate = 44100;
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHANS_STEREO;
return codec_init (demux, &fmt);
}
/* PT=12
* QCELP
*/
static void *qcelp_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_QCELP);
fmt.audio.i_rate = 8000;
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHAN_CENTER;
return codec_init (demux, &fmt);
}
/* PT=14
* MPA: MPEG Audio (RFC2250, §3.4)
*/
static void *mpa_init (demux_t *demux)
{
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_MPGA);
fmt.audio.i_original_channels =
fmt.audio.i_physical_channels = AOUT_CHANS_STEREO;
fmt.b_packetized = false;
return codec_init (demux, &fmt);
}
/* this is the codec entry point */
enum codec_status codec_main(enum codec_entry_call_reason reason)
{
if (reason == CODEC_LOAD) {
if (codec_init())
return CODEC_ERROR;
ci->configure(DSP_SET_SAMPLE_DEPTH, 24);
}
return CODEC_OK;
}
void init_all(void)
{
GPIO_init();
DAC_DMA_init();
P24_init();
vdisplay_init();
codec_init();
codec_ctrl_init();
TIM6_init(); /* Initialize timer */
TIM3_init(); /* interrupts last... */
TIM4_init();
}
/*
* Initialize the driver.
*/
static int
tosh_init( struct wm_drive *d )
{
extern int min_volume;
/* Sun use Toshiba drives as well */
#if defined(SYSV) && defined(CODEC)
codec_init();
#endif
min_volume = 0;
return ( 0 );
}
void S_Init( void )
{
cvar_t *cv;
qboolean started = qfalse;
Com_Printf("%s", _( "------ Initializing Sound -----\n" ));
cv = Cvar_Get( "s_initsound", "1", 0 );
if ( !cv->integer )
{
Com_Printf( "Sound Disabled\n" );
return;
}
else
{
codec_init();
s_volume = Cvar_Get( "s_volume", "0.8", CVAR_ARCHIVE );
s_musicVolume = Cvar_Get( "s_musicvolume", "0.25", CVAR_ARCHIVE );
s_separation = Cvar_Get( "s_separation", "0.5", CVAR_ARCHIVE );
s_doppler = Cvar_Get( "s_doppler", "1", CVAR_ARCHIVE );
s_khz = Cvar_Get( "s_khz", "22", CVAR_ARCHIVE );
s_mixahead = Cvar_Get( "s_mixahead", "0.2", CVAR_ARCHIVE );
s_mixPreStep = Cvar_Get( "s_mixPreStep", "0.05", CVAR_ARCHIVE );
s_show = Cvar_Get( "s_show", "0", CVAR_CHEAT );
s_testsound = Cvar_Get( "s_testsound", "0", CVAR_CHEAT );
cv = Cvar_Get( "s_usemodule", "1", CVAR_ARCHIVE );
if( cv->integer )
{
started = S_AL_Init( &si );
}
if( !started )
{
Com_Printf( "Using builtin sound backend\n" );
S_Base_Init( &si );
}
else
{
Com_Printf( "Using OpenAL sound backend\n" );
}
Cmd_AddCommand( "play", S_Play_f );
Cmd_AddCommand( "music", S_Music_f );
Cmd_AddCommand( "s_list", S_SoundList_f );
Cmd_AddCommand( "s_info", S_SoundInfo_f );
Cmd_AddCommand( "s_stop", S_StopAllSounds );
}
Com_Printf( "------------------------------------\n" );
}
int aml_setup(int videoFormat, int width, int height, int redrawRate, void* context, int drFlags) {
codecParam.stream_type = STREAM_TYPE_ES_VIDEO;
codecParam.has_video = 1;
codecParam.noblock = 0;
codecParam.am_sysinfo.param = 0;
switch (videoFormat) {
case VIDEO_FORMAT_H264:
if (width > 1920 || height > 1080) {
codecParam.video_type = VFORMAT_H264_4K2K;
codecParam.am_sysinfo.format = VIDEO_DEC_FORMAT_H264_4K2K;
} else {
codecParam.video_type = VFORMAT_H264;
codecParam.am_sysinfo.format = VIDEO_DEC_FORMAT_H264;
// Workaround for decoding special case of C1, 1080p, H264
int major, minor;
struct utsname name;
uname(&name);
int ret = sscanf(name.release, "%d.%d", &major, &minor);
if (!(major > 3 || (major == 3 && minor >= 14)) && width == 1920 && height == 1080)
codecParam.am_sysinfo.param = (void*) UCODE_IP_ONLY_PARAM;
}
break;
case VIDEO_FORMAT_H265:
codecParam.video_type = VFORMAT_HEVC;
codecParam.am_sysinfo.format = VIDEO_DEC_FORMAT_HEVC;
break;
default:
printf("Video format not supported\n");
return -1;
}
codecParam.am_sysinfo.width = width;
codecParam.am_sysinfo.height = height;
codecParam.am_sysinfo.rate = 96000 / redrawRate;
codecParam.am_sysinfo.param = (void*) ((size_t) codecParam.am_sysinfo.param | SYNC_OUTSIDE);
int ret;
if ((ret = codec_init(&codecParam)) != 0) {
fprintf(stderr, "codec_init error: %x\n", ret);
return -2;
}
if ((ret = codec_set_freerun_mode(&codecParam, 1)) != 0) {
fprintf(stderr, "Can't set Freerun mode: %x\n", ret);
return -2;
}
return 0;
}
static void codecs_init(struct device *dev, u32 base, u32 codec_mask)
{
int i;
for (i = 3; i >= 0; i--) {
if (codec_mask & (1 << i))
codec_init(dev, base, i);
}
for (i = 0; i < pc_beep_verbs_size; i++) {
if (wait_for_ready(base) == -1)
return;
write32(base + 0x60, pc_beep_verbs[i]);
if (wait_for_valid(base) == -1)
return;
}
}
static gboolean
gst_set_vstream_info(GstAmlVdec *amlvdec, GstCaps * caps)
{
GstStructure *structure;
const char *name;
gint32 ret = CODEC_ERROR_NONE;
AmlStreamInfo *videoinfo = NULL;
int coordinate[4] = {0, 0, 0, 0};
structure = gst_caps_get_structure(caps, 0);
name = gst_structure_get_name(structure);
videoinfo = amlVstreamInfoInterface(name);
if (NULL == name) {
return FALSE;
}
amlvdec->info = videoinfo;
videoinfo->init(videoinfo, amlvdec->pcodec, structure);
if (amlvdec->pcodec && amlvdec->pcodec->stream_type == STREAM_TYPE_ES_VIDEO) {
if (!amlvdec->codec_init_ok) {
ret = codec_init(amlvdec->pcodec);
if (ret != CODEC_ERROR_NONE) {
GST_ERROR("codec init failed, ret=-0x%x", -ret);
return FALSE;
}
set_fb0_blank(1);
set_fb1_blank(1);
set_tsync_enable(1);
set_display_axis(coordinate);
//set_video_axis(coordinate);
amlvdec->codec_init_ok = 1;
if (amlvdec->trickRate > 0) {
if (amlvdec->pcodec && amlvdec->pcodec->cntl_handle) {
//T codec_set_video_playrate(amlvdec->pcodec, (int) (amlvdec->trickRate * (1 << 16)));
}
}
GST_DEBUG_OBJECT(amlvdec, "video codec_init ok");
}
}
return TRUE;
}
bool CTsPlayer::StartPlay()
{
int ret;
memset(pcodec,0,sizeof(*pcodec));
pcodec->stream_type=STREAM_TYPE_TS;
pcodec->video_type = vPara.vFmt;
pcodec->has_video=1;
pcodec->audio_type= aPara.aFmt;
pcodec->has_audio=1;
pcodec->video_pid=(int)vPara.pid;
pcodec->audio_pid=(int)aPara.pid;
//pcodec->audio_channels = 1;
//pcodec->audio_samplerate = 48000;
// 解决AC3无声的问题
if(IS_AUIDO_NEED_EXT_INFO(pcodec->audio_type)){
pcodec->audio_info.valid = 1;
LOGI("set audio_info.valid to 1");
}
if (pcodec->video_type == VFORMAT_H264) {
pcodec->am_sysinfo.format = VIDEO_DEC_FORMAT_H264;
pcodec->am_sysinfo.param = (void *)(0);
}
else if(pcodec->video_type ==VFORMAT_MPEG12){
pcodec->am_sysinfo.param = (void *)(0);
}
printf("set %d,%d,%d,%d\n",vPara.vFmt,aPara.aFmt,vPara.pid,aPara.pid);
pcodec->noblock = 0;
/*other setting*/
ret=codec_init(pcodec);
#if DUMP_TSPACKET1
m_fStream = fopen("/data/data/novel.supertv.dvb/new_1.ts","wb");
#endif
return !ret;
}
void xiph_decode (demux_t *demux, void *data, block_t *block)
{
rtp_xiph_t *self = (rtp_xiph_t *)data; // sunqueen modify
if (!data || block->i_buffer < 4)
goto drop;
/* 32-bits RTP header (§2.2) */
uint32_t ident = GetDWBE (block->p_buffer);
block->i_buffer -= 4;
block->p_buffer += 4;
unsigned fragtype = (ident >> 6) & 3;
unsigned datatype = (ident >> 4) & 3;
unsigned pkts = (ident) & 15;
ident >>= 8;
/* RTP defragmentation */
if (self->block && (block->i_flags & BLOCK_FLAG_DISCONTINUITY))
{ /* Screwed! discontinuity within a fragmented packet */
msg_Warn (demux, self->vorbis ?
"discontinuity in fragmented Vorbis packet" :
"discontinuity in fragmented Theora packet");
block_Release (self->block);
self->block = NULL;
}
if (fragtype <= 1)
{
if (self->block) /* Invalid first fragment */
{
block_Release (self->block);
self->block = NULL;
}
}
else
{
if (!self->block)
goto drop; /* Invalid non-first fragment */
}
if (fragtype > 0)
{ /* Fragment */
if (pkts > 0 || block->i_buffer < 2)
goto drop;
size_t fraglen = GetWBE (block->p_buffer);
if (block->i_buffer < (fraglen + 2))
goto drop; /* Invalid payload length */
block->i_buffer = fraglen;
if (fragtype == 1)/* Keep first fragment */
{
block->i_buffer += 2;
self->block = block;
}
else
{ /* Append non-first fragment */
size_t len = self->block->i_buffer;
self->block = block_Realloc (self->block, 0, len + fraglen);
if (!self->block)
{
block_Release (block);
return;
}
memcpy (self->block->p_buffer + len, block->p_buffer + 2,
fraglen);
block_Release (block);
}
if (fragtype < 3)
return; /* Non-last fragment */
/* Last fragment reached, process it */
block = self->block;
self->block = NULL;
SetWBE (block->p_buffer, block->i_buffer - 2);
pkts = 1;
}
/* RTP payload packets processing */
while (pkts > 0)
{
if (block->i_buffer < 2)
goto drop;
size_t len = GetWBE (block->p_buffer);
block->i_buffer -= 2;
block->p_buffer += 2;
if (block->i_buffer < len)
goto drop;
switch (datatype)
{
case 0: /* Raw payload */
{
if (self->ident != ident)
{
msg_Warn (demux, self->vorbis ?
"ignoring raw Vorbis payload without configuration" :
"ignoring raw Theora payload without configuration");
break;
}
block_t *raw = block_Alloc (len);
memcpy (raw->p_buffer, block->p_buffer, len);
raw->i_pts = block->i_pts; /* FIXME: what about pkts > 1 */
codec_decode (demux, self->id, raw);
break;
}
case 1: /* Packed configuration frame (§3.1.1) */
{
if (self->ident == ident)
break; /* Ignore config retransmission */
void *extv;
ssize_t extc = xiph_header (&extv, block->p_buffer, len);
if (extc < 0)
break;
es_format_t fmt;
es_format_Init (&fmt, self->vorbis ? AUDIO_ES : VIDEO_ES,
self->vorbis ? VLC_CODEC_VORBIS
: VLC_CODEC_THEORA);
fmt.p_extra = extv;
fmt.i_extra = extc;
codec_destroy (demux, self->id);
msg_Dbg (demux, self->vorbis ?
"Vorbis packed configuration received (%06"PRIx32")" :
"Theora packed configuration received (%06"PRIx32")",
ident);
self->ident = ident;
self->id = (es_out_id_t *)codec_init (demux, &fmt); // sunqueen modify
break;
}
}
block->i_buffer -= len;
block->p_buffer += len;
pkts--;
}
drop:
block_Release (block);
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
size_t n;
unsigned char *filebuf;
int sample_loc;
int retval;
/* Generic codec initialisation */
ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
ci->configure(DSP_SET_SAMPLE_DEPTH, 28);
next_track:
retval = CODEC_OK;
if (codec_init()) {
retval = CODEC_ERROR;
goto exit;
}
if (codec_wait_taginfo() != 0)
goto request_next_track;
ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
codec_set_replaygain(ci->id3);
/* Intialise the A52 decoder and check for success */
state = a52_init(0);
/* The main decoding loop */
if (ci->id3->offset) {
if (ci->seek_buffer(ci->id3->offset)) {
samplesdone = (ci->id3->offset / ci->id3->bytesperframe) *
A52_SAMPLESPERFRAME;
ci->set_elapsed(samplesdone/(ci->id3->frequency / 1000));
}
}
else {
samplesdone = 0;
}
while (1) {
if (ci->stop_codec || ci->new_track)
break;
if (ci->seek_time) {
sample_loc = (ci->seek_time - 1)/1000 * ci->id3->frequency;
if (ci->seek_buffer((sample_loc/A52_SAMPLESPERFRAME)*ci->id3->bytesperframe)) {
samplesdone = sample_loc;
ci->set_elapsed(samplesdone/(ci->id3->frequency/1000));
}
ci->seek_complete();
}
filebuf = ci->request_buffer(&n, BUFFER_SIZE);
if (n == 0) /* End of Stream */
break;
a52_decode_data(filebuf, filebuf + n);
ci->advance_buffer(n);
}
request_next_track:
if (ci->request_next_track())
goto next_track;
exit:
a52_free(state);
return retval;
}
void CS43L22_Config() {
// configure STM32F4Discovery I2S pins
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Pin = STM32F4D_I2S_WS_PIN;
GPIO_Init(STM32F4D_I2S_WS_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(STM32F4D_I2S_WS_PORT, STM32F4D_I2S_WS_PINSRC, GPIO_AF_SPI3);
GPIO_InitStructure.GPIO_Pin = STM32F4D_I2S_CK_PIN;
GPIO_Init(STM32F4D_I2S_CK_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(STM32F4D_I2S_CK_PORT, STM32F4D_I2S_CK_PINSRC, GPIO_AF_SPI3);
GPIO_InitStructure.GPIO_Pin = STM32F4D_I2S_SD_PIN;
GPIO_Init(STM32F4D_I2S_SD_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(STM32F4D_I2S_SD_PORT, STM32F4D_I2S_SD_PINSRC, GPIO_AF_SPI3);
GPIO_InitStructure.GPIO_Pin = STM32F4D_I2S_MCLK_PIN;
GPIO_Init(STM32F4D_I2S_MCLK_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(STM32F4D_I2S_MCLK_PORT, STM32F4D_I2S_MCLK_PINSRC, GPIO_AF_SPI3);
// configure I2C pins to access the CS43L22 configuration registers
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = CODEC_I2C_SCL_PIN;
GPIO_Init(CODEC_I2C_SCL_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(CODEC_I2C_SCL_PORT, GPIO_PinSource6, GPIO_AF_I2C1);
GPIO_InitStructure.GPIO_Pin = CODEC_I2C_SDA_PIN;
GPIO_Init(CODEC_I2C_SDA_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(CODEC_I2C_SDA_PORT, GPIO_PinSource9, GPIO_AF_I2C1);
// CS43L22 reset pin
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Pin = CODEC_RESET_PIN;
GPIO_Init(CODEC_RESET_PORT, &GPIO_InitStructure);
GPIO_ResetBits(CODEC_RESET_PORT, CODEC_RESET_PIN); // activate reset
// I2S initialisation
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
RCC_PLLI2SCmd(ENABLE); // new for STM32F4: enable I2S PLL
SPI_I2S_DeInit(SPI3);
I2S_InitTypeDef I2S_InitStructure;
I2S_StructInit(&I2S_InitStructure);
I2S_InitStructure.I2S_Standard = STM32F4D_I2S_STANDARD;
I2S_InitStructure.I2S_DataFormat = STM32F4D_I2S_DATA_FORMAT;
I2S_InitStructure.I2S_MCLKOutput = STM32F4D_I2S_MCLK_ENABLE ? I2S_MCLKOutput_Enable : I2S_MCLKOutput_Disable;
I2S_InitStructure.I2S_AudioFreq = (u16)(STM32F4D_I2S_AUDIO_FREQ);
I2S_InitStructure.I2S_CPOL = I2S_CPOL_Low; // configuration required as well?
I2S_InitStructure.I2S_Mode = I2S_Mode_MasterTx;
I2S_Init(SPI3, &I2S_InitStructure);
I2S_Cmd(SPI3, ENABLE);
// DMA Configuration for SPI Tx Event
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
DMA_InitTypeDef DMA_InitStructure;
DMA_StructInit(&DMA_InitStructure);
DMA_Cmd(DMA1_Stream5, DISABLE);
DMA_ClearFlag(DMA1_Stream5, DMA_FLAG_TCIF5 | DMA_FLAG_TEIF5 | DMA_FLAG_HTIF5 | DMA_FLAG_FEIF5);
DMA_InitStructure.DMA_Channel = DMA_Channel_0;
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI3->DR;
// DMA_InitStructure.DMA_MemoryBaseAddr = ...; // configured in CS43L22_Start
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
// DMA_InitStructure.DMA_BufferSize = ...; // configured in CS43L22_Start
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(DMA1_Stream5, &DMA_InitStructure);
// DMA_Cmd(DMA1_Stream5, ENABLE); // done on CS43L22_Start
DMA_ITConfig(DMA1_Stream5, DMA_IT_TE | DMA_IT_FE, DISABLE);
// trigger interrupt when transfer half complete/complete
DMA_ITConfig(DMA1_Stream5, DMA_IT_HT | DMA_IT_TC, ENABLE);
// enable SPI interrupts to DMA
SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx, ENABLE);
// Configure and enable DMA interrupt
/* Configure the DMA IRQ handler priority */
NVIC_SetPriority(DMA1_Stream5_IRQn, 0x0);
NVIC_EnableIRQ(DMA1_Stream5_IRQn);
// configure I2C
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
I2C_DeInit(CODEC_I2C);
I2C_InitTypeDef I2C_InitStructure;
I2C_StructInit(&I2C_InitStructure);
I2C_InitStructure.I2C_ClockSpeed = 100000;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_OwnAddress1 = CORE_I2C_ADDRESS;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_Cmd(CODEC_I2C, ENABLE);
I2C_Init(CODEC_I2C, &I2C_InitStructure);
codec_init();
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
static size_t buff_size;
int datasize, res, frame_counter, total_frames, seek_frame_offset;
uint8_t *bit_buffer;
int elapsed = 0;
size_t resume_offset;
intptr_t param;
long action;
if (codec_init()) {
DEBUGF("codec init failed\n");
return CODEC_ERROR;
}
action = CODEC_ACTION_NULL;
param = ci->id3->elapsed;
resume_offset = ci->id3->offset;
codec_set_replaygain(ci->id3);
ci->memset(&q,0,sizeof(ATRAC3Context));
ci->configure(DSP_SET_FREQUENCY, ci->id3->frequency);
ci->configure(DSP_SET_SAMPLE_DEPTH, 17); /* Remark: atrac3 uses s15.0 by default, s15.2 was hacked. */
ci->configure(DSP_SET_STEREO_MODE, ci->id3->channels == 1 ?
STEREO_MONO : STEREO_NONINTERLEAVED);
ci->seek_buffer(0);
res = atrac3_decode_init(&q, ci->id3);
if(res < 0) {
DEBUGF("failed to initialize OMA atrac decoder\n");
return CODEC_ERROR;
}
total_frames = (ci->id3->filesize - ci->id3->first_frame_offset) / FRAMESIZE;
frame_counter = 0;
/* check for a mid-track resume and force a seek time accordingly */
if (resume_offset) {
resume_offset -= MIN(resume_offset, ci->id3->first_frame_offset);
/* calculate resume_offset in frames */
param = (resume_offset/FRAMESIZE) * ((FRAMESIZE * 8)/BITRATE);
}
if ((unsigned long)param) {
action = CODEC_ACTION_SEEK_TIME;
}
else {
ci->set_elapsed(0);
ci->seek_buffer(ci->id3->first_frame_offset);
}
/* The main decoder loop */
while(frame_counter < total_frames)
{
if (action == CODEC_ACTION_NULL)
action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
if (action == CODEC_ACTION_SEEK_TIME) {
/* Do not allow seeking beyond the file's length */
if ((unsigned long) param > ci->id3->length) {
ci->set_elapsed(ci->id3->length);
ci->seek_complete();
break;
}
/* Seek to the start of the track */
if (param == 0) {
elapsed = 0;
ci->set_elapsed(0);
ci->seek_buffer(ci->id3->first_frame_offset);
ci->seek_complete();
action = CODEC_ACTION_NULL;
continue;
}
seek_frame_offset = (param * BITRATE) / (8 * FRAMESIZE);
frame_counter = seek_frame_offset;
ci->seek_buffer(ci->id3->first_frame_offset + seek_frame_offset* FRAMESIZE);
elapsed = param;
ci->set_elapsed(elapsed);
ci->seek_complete();
}
action = CODEC_ACTION_NULL;
bit_buffer = (uint8_t *) ci->request_buffer(&buff_size, FRAMESIZE);
res = atrac3_decode_frame(FRAMESIZE, &q, &datasize, bit_buffer, FRAMESIZE);
if(res != (int)FRAMESIZE) {
DEBUGF("codec error\n");
return CODEC_ERROR;
}
if(datasize)
ci->pcmbuf_insert(q.outSamples, q.outSamples + 1024,
q.samples_per_frame / ci->id3->channels);
elapsed += (FRAMESIZE * 8) / BITRATE;
ci->set_elapsed(elapsed);
ci->advance_buffer(FRAMESIZE);
frame_counter++;
}
return CODEC_OK;
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
uint32_t elapsedtime;
int retval;
asf_waveformatex_t wfx; /* Holds the stream properties */
size_t resume_offset;
int res; /* Return values from asf_read_packet() and decode_packet() */
uint8_t* audiobuf; /* Pointer to the payload of one wma pro packet */
int audiobufsize; /* Payload size */
int packetlength = 0; /* Logical packet size (minus the header size) */
int outlen = 0; /* Number of bytes written to the output buffer */
int pktcnt = 0; /* Count of the packets played */
/* Generic codec initialisation */
ci->configure(DSP_SET_SAMPLE_DEPTH, 31);
next_track:
retval = CODEC_OK;
/* Wait for the metadata to be read */
if (codec_wait_taginfo() != 0)
goto done;
/* Remember the resume position */
resume_offset = ci->id3->offset;
restart_track:
retval = CODEC_OK;
if (codec_init()) {
LOGF("(WMA Voice) Error: Error initialising codec\n");
retval = CODEC_ERROR;
goto done;
}
/* Copy the format metadata we've stored in the id3 TOC field. This
saves us from parsing it again here. */
memcpy(&wfx, ci->id3->toc, sizeof(wfx));
memset(&avctx, 0, sizeof(AVCodecContext));
memset(&avpkt, 0, sizeof(AVPacket));
ci->configure(DSP_SWITCH_FREQUENCY, wfx.rate);
ci->configure(DSP_SET_STEREO_MODE, wfx.channels == 1 ?
STEREO_MONO : STEREO_INTERLEAVED);
codec_set_replaygain(ci->id3);
/* Initialise the AVCodecContext */
init_codec_ctx(&avctx, &wfx);
if (wmavoice_decode_init(&avctx) < 0) {
LOGF("(WMA Voice) Error: Unsupported or corrupt file\n");
retval = CODEC_ERROR;
goto done;
}
/* Now advance the file position to the first frame */
ci->seek_buffer(ci->id3->first_frame_offset);
elapsedtime = 0;
resume_offset = 0;
/* The main decoding loop */
while (pktcnt < wfx.numpackets)
{
ci->yield();
if (ci->stop_codec || ci->new_track) {
goto done;
}
/* Deal with any pending seek requests */
if (ci->seek_time){
if (ci->seek_time == 1) {
ci->seek_complete();
goto restart_track; /* Pretend you never saw this... */
}
elapsedtime = asf_seek(ci->seek_time, &wfx);
if (elapsedtime < 1){
ci->seek_complete();
goto next_track;
}
ci->set_elapsed(elapsedtime);
ci->seek_complete();
}
new_packet:
res = asf_read_packet(&audiobuf, &audiobufsize, &packetlength, &wfx);
if (res < 0) {
LOGF("(WMA Voice) read_packet error %d\n",res);
goto done;
} else {
avpkt.data = audiobuf;
avpkt.size = audiobufsize;
pktcnt++;
while(avpkt.size > 0)
{
/* wmavoice_decode_packet checks for the output buffer size to
avoid overflows */
outlen = BUFSIZE*sizeof(int32_t);
res = wmavoice_decode_packet(&avctx, decoded, &outlen, &avpkt);
if(res < 0) {
LOGF("(WMA Voice) Error: decode_packet returned %d", res);
if(res == ERROR_WMAPRO_IN_WMAVOICE){
/* Just skip this packet */
ci->advance_buffer(packetlength);
goto new_packet;
}
else
goto done;
}
avpkt.data += res;
avpkt.size -= res;
if(outlen) {
ci->yield ();
outlen /= sizeof(int32_t);
ci->pcmbuf_insert(decoded, NULL, outlen);
elapsedtime += outlen*10/(wfx.rate/100);
ci->set_elapsed(elapsedtime);
ci->yield ();
}
}
}
/* Advance to the next logical packet */
ci->advance_buffer(packetlength);
}
done:
if (ci->request_next_track())
goto next_track;
return retval;
}
int
main(int argc, char *argv[])
{
const char *codec_name, *repair_name;
codec_id_t cid;
repair_id_t rid;
struct s_sndfile *sf_in = NULL, *sf_out = NULL;
sndfile_fmt_t sff;
double drop = 0.0;
int ac, did_query = FALSE;
int csra = TRUE; /* codec specific repair allowed */
long seed = 100;
codec_init();
ac = 1;
while(ac < argc && argv[ac][0] == '-') {
if (strlen(argv[ac]) > 2) {
/* should be -codecs or -repairs */
switch(argv[ac][1]) {
case 'c':
list_codecs();
break;
case 'r':
list_repairs();
break;
default:
usage();
}
did_query = TRUE;
} else {
if (argc - ac < 1) {
usage();
}
switch(argv[ac][1]) {
case 's':
seed = atoi(argv[++ac]);
break;
case 'd':
drop = strtod(argv[++ac], NULL);
break;
case 'c':
cid = codec_get_by_name(argv[++ac]);
codec_name = argv[ac];
break;
case 'n':
csra = FALSE;
break;
case 'r':
resolve_repair(argv[++ac], &rid, &repair_name);
break;
case 'u':
units_per_packet = atoi(argv[++ac]);
break;
default:
usage();
}
}
ac++;
}
if (did_query == TRUE) {
/* Not sensible to be running query and executing test */
exit(-1);
}
if (argc - ac != 2) {
usage();
}
if (snd_read_open(&sf_in, argv[ac], NULL) == FALSE) {
fprintf(stderr, "Could not open %s\n", argv[ac]);
exit(-1);
}
ac++;
if (snd_get_format(sf_in, &sff) == FALSE) {
fprintf(stderr, "Failed to get format of %s\n", argv[ac]);
exit(-1);
}
if (snd_write_open(&sf_out, argv[ac], "au", &sff) == FALSE) {
fprintf(stderr, "Could not open %s\n", argv[ac]);
exit(-1);
}
if (file_and_codec_compatible(&sff, cid) == FALSE) {
fprintf(stderr, "Codec and file type are not compatible\n");
exit(-1);
}
printf("# Parameters
#\tseed: %ld
#\tdrop: %.2f
#\tcodec: %s
#\tunits per packet: %d
#\trepair: %s
#\tcodec specific repair (when available): %d
#\tsource file: %s
#\tdestination file %s\n",
seed, drop, codec_name, units_per_packet, repair_name, csra, argv[argc - 2], argv[argc - 1]);
repair_set_codec_specific_allowed(csra);
init_drop(seed, drop);
test_repair(sf_out, cid, rid, sf_in);
/* snd_read_close(&sf_in) not needed because files gets closed
* at eof automatically.
*/
snd_write_close(&sf_out);
codec_exit();
xmemdmp();
return 0;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
WavpackContext *wpc;
char error [80];
/* rockbox: comment 'set but unused' variables
int bps;
*/
int nchans, sr_100;
intptr_t param;
if (codec_init())
return CODEC_ERROR;
ci->seek_buffer (ci->id3->offset);
/* Create a decoder instance */
wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc)
return CODEC_ERROR;
ci->configure(DSP_SWITCH_FREQUENCY, WavpackGetSampleRate (wpc));
codec_set_replaygain(ci->id3);
/* bps = WavpackGetBytesPerSample (wpc); */
nchans = WavpackGetReducedChannels (wpc);
ci->configure(DSP_SET_STEREO_MODE, nchans == 2 ? STEREO_INTERLEAVED : STEREO_MONO);
sr_100 = ci->id3->frequency / 100;
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
/* The main decoder loop */
while (1) {
int32_t nsamples;
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
if (action == CODEC_ACTION_SEEK_TIME) {
int curpos_ms = WavpackGetSampleIndex (wpc) / sr_100 * 10;
int n, d, skip;
if (param > curpos_ms) {
n = param - curpos_ms;
d = ci->id3->length - curpos_ms;
skip = (int)((int64_t)(ci->filesize - ci->curpos) * n / d);
ci->seek_buffer (ci->curpos + skip);
}
else if (curpos_ms != 0) {
n = curpos_ms - param;
d = curpos_ms;
skip = (int)((int64_t) ci->curpos * n / d);
ci->seek_buffer (ci->curpos - skip);
}
wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc)
{
ci->seek_complete();
break;
}
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
ci->seek_complete();
}
nsamples = WavpackUnpackSamples (wpc, temp_buffer, BUFFER_SIZE / nchans);
if (!nsamples)
break;
ci->pcmbuf_insert (temp_buffer, NULL, nsamples);
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
}
return CODEC_OK;
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
struct ape_ctx_t ape_ctx;
uint32_t samplesdone;
uint32_t elapsedtime;
size_t bytesleft;
int retval;
uint32_t currentframe;
uint32_t newfilepos;
uint32_t samplestoskip;
int nblocks;
int bytesconsumed;
unsigned char* inbuffer;
uint32_t blockstodecode;
int res;
int firstbyte;
size_t resume_offset;
/* Generic codec initialisation */
ci->configure(DSP_SET_SAMPLE_DEPTH, APE_OUTPUT_DEPTH-1);
next_track:
retval = CODEC_OK;
if (codec_init()) {
LOGF("APE: Error initialising codec\n");
retval = CODEC_ERROR;
goto exit;
}
if (codec_wait_taginfo() != 0)
goto done;
/* Remember the resume position - when the codec is opened, the
playback engine will reset it. */
resume_offset = ci->id3->offset;
inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
/* Read the file headers to populate the ape_ctx struct */
if (ape_parseheaderbuf(inbuffer,&ape_ctx) < 0) {
LOGF("APE: Error reading header\n");
retval = CODEC_ERROR;
goto exit;
}
/* Initialise the seektable for this file */
ape_ctx.seektable = seektablebuf;
ape_ctx.numseekpoints = MIN(MAX_SEEKPOINTS,ape_ctx.numseekpoints);
ci->advance_buffer(ape_ctx.seektablefilepos);
/* The seektable may be bigger than the guard buffer (32KB), so we
do a read() */
ci->read_filebuf(ape_ctx.seektable, ape_ctx.numseekpoints * sizeof(uint32_t));
#ifdef ROCKBOX_BIG_ENDIAN
/* Byte-swap the little-endian seekpoints */
{
uint32_t i;
for(i = 0; i < ape_ctx.numseekpoints; i++)
ape_ctx.seektable[i] = swap32(ape_ctx.seektable[i]);
}
#endif
/* Now advance the file position to the first frame */
ci->advance_buffer(ape_ctx.firstframe -
(ape_ctx.seektablefilepos +
ape_ctx.numseekpoints * sizeof(uint32_t)));
ci->configure(DSP_SWITCH_FREQUENCY, ape_ctx.samplerate);
ci->configure(DSP_SET_STEREO_MODE, ape_ctx.channels == 1 ?
STEREO_MONO : STEREO_NONINTERLEAVED);
codec_set_replaygain(ci->id3);
/* The main decoding loop */
if (resume_offset) {
/* The resume offset is a value in bytes - we need to
turn it into a frame number and samplestoskip value */
ape_resume(&ape_ctx, resume_offset,
¤tframe, &samplesdone, &samplestoskip, &firstbyte);
} else {
currentframe = 0;
samplesdone = 0;
samplestoskip = 0;
firstbyte = 3; /* Take account of the little-endian 32-bit byte ordering */
}
/* Initialise the buffer */
inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
/* The main decoding loop - we decode the frames a small chunk at a time */
while (currentframe < ape_ctx.totalframes)
{
frame_start:
/* Calculate how many blocks there are in this frame */
if (currentframe == (ape_ctx.totalframes - 1))
nblocks = ape_ctx.finalframeblocks;
else
nblocks = ape_ctx.blocksperframe;
ape_ctx.currentframeblocks = nblocks;
/* Initialise the frame decoder */
init_frame_decoder(&ape_ctx, inbuffer, &firstbyte, &bytesconsumed);
ci->advance_buffer(bytesconsumed);
inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
/* Decode the frame a chunk at a time */
while (nblocks > 0)
{
ci->yield();
if (ci->stop_codec || ci->new_track) {
goto done;
}
/* Deal with any pending seek requests */
if (ci->seek_time)
{
if (ape_calc_seekpos(&ape_ctx,
((ci->seek_time-1)/10) * (ci->id3->frequency/100),
¤tframe,
&newfilepos,
&samplestoskip))
{
samplesdone = currentframe * ape_ctx.blocksperframe;
/* APE's bytestream is weird... */
firstbyte = 3 - (newfilepos & 3);
newfilepos &= ~3;
ci->seek_buffer(newfilepos);
inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
ci->seek_complete();
goto frame_start; /* Sorry... */
}
ci->seek_complete();
}
blockstodecode = MIN(BLOCKS_PER_LOOP, nblocks);
if ((res = decode_chunk(&ape_ctx, inbuffer, &firstbyte,
&bytesconsumed,
decoded0, decoded1,
blockstodecode)) < 0)
{
/* Frame decoding error, abort */
LOGF("APE: Frame %lu, error %d\n",(unsigned long)currentframe,res);
retval = CODEC_ERROR;
goto done;
}
ci->yield();
if (samplestoskip > 0) {
if (samplestoskip < blockstodecode) {
ci->pcmbuf_insert(decoded0 + samplestoskip,
decoded1 + samplestoskip,
blockstodecode - samplestoskip);
samplestoskip = 0;
} else {
samplestoskip -= blockstodecode;
}
} else {
ci->pcmbuf_insert(decoded0, decoded1, blockstodecode);
}
samplesdone += blockstodecode;
if (!samplestoskip) {
/* Update the elapsed-time indicator */
elapsedtime = (samplesdone*10)/(ape_ctx.samplerate/100);
ci->set_elapsed(elapsedtime);
}
ci->advance_buffer(bytesconsumed);
inbuffer = ci->request_buffer(&bytesleft, INPUT_CHUNKSIZE);
/* Decrement the block count */
nblocks -= blockstodecode;
}
currentframe++;
}
done:
LOGF("APE: Decoded %lu samples\n",(unsigned long)samplesdone);
if (ci->request_next_track())
goto next_track;
exit:
return retval;
}
int main(int argc, char * const argv[])
{
int ret = CODEC_ERROR_NONE;
std::string input_filename;
if (argc > 1) {
for (int i = 1; i < argc; i++) {
if (strncasecmp(argv[i], "--input", 7) == 0) {
// check the next arg with the proper value.
int next = i + 1;
if (next < argc) {
input_filename = argv[next];
i++;
}
} else if (strncasecmp(argv[i], "-h", 2) == 0 || strncasecmp(argv[i], "--help", 6) == 0) {
printf("Usage: %s [OPTIONS]...\n", argv[0]);
printf("Arguments:\n");
printf(" --input <filename> \tInput video filename\n");
exit(0);
}
}
}
if (input_filename.empty()) {
printf("no input file specified\n");
exit(0);
}
// install signal handlers
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
// initialize App contex.
AVPacket avpkt;
AppContext ctx;
memset(&ctx, 0, sizeof(ctx));
player_para_init(&ctx);
am_packet_init(&ctx.am_pkt);
ctx.am_pkt.avpkt = &avpkt;
av_init_packet(ctx.am_pkt.avpkt);
// create the ffmepg file reader/demuxer
ctx.demuxer = new FFmpegFileReader(input_filename.c_str());
if (!ctx.demuxer->Initialize()) {
fprintf(stderr, "ERROR: Can't initialize FFmpegFileReader\n");
goto fail;
}
ctx.codec_context = ctx.demuxer->GetCodecContext();
ctx.format_context = ctx.demuxer->GetFormatContext();
if (!ctx.codec_context) {
fprintf(stderr, "ERROR: Invalid FFmpegFileReader Codec Context\n");
goto fail;
}
dump_extradata(&ctx);
printf("video width(%d), height(%d), extradata_size(%d)\n",
(int)ctx.codec_context->width, (int)ctx.codec_context->height, ctx.codec_context->extradata_size);
AVStream *pStream;
pStream = ctx.format_context->streams[ctx.demuxer->GetVideoIndex()];
//ctx.vstream_info.video_pid = (unsigned short)ctx.codec_context->id;
if (pStream->time_base.den) {
ctx.vstream_info.start_time = pStream->start_time * pStream->time_base.num * PTS_FREQ / pStream->time_base.den;
ctx.vstream_info.video_duration = ((float)pStream->time_base.num / pStream->time_base.den) * UNIT_FREQ;
ctx.vstream_info.video_pts = ((float)pStream->time_base.num / pStream->time_base.den) * PTS_FREQ;
}
ctx.vstream_info.video_width = ctx.codec_context->width;
ctx.vstream_info.video_height = ctx.codec_context->height;
ctx.vstream_info.video_ratio = (float)pStream->sample_aspect_ratio.num / pStream->sample_aspect_ratio.den;
if (ctx.codec_context->time_base.den) {
ctx.vstream_info.video_codec_rate = (int64_t)UNIT_FREQ * ctx.codec_context->time_base.num / ctx.codec_context->time_base.den;
}
if (pStream->r_frame_rate.num) {
ctx.vstream_info.video_rate = (int64_t)UNIT_FREQ * pStream->r_frame_rate.den / pStream->r_frame_rate.num;
}
log_print("time_base.num(%d), pStream->time_base.den(%d)\n",
pStream->time_base.num, pStream->time_base.den);
ctx.vstream_info.video_duration = ((float)pStream->time_base.num / pStream->time_base.den) * UNIT_FREQ;
ctx.vstream_info.video_pts = ((float)pStream->time_base.num / pStream->time_base.den) * PTS_FREQ;
printf("\n*********AMLOGIC CODEC PLAYER DEMO************\n\n");
osd_blank("/sys/class/graphics/fb0/blank", 1);
osd_blank("/sys/class/graphics/fb1/blank", 1);
//osd_blank("/sys/class/tsync/enable", 1);
osd_blank("/sys/class/tsync/enable", 0);
switch(ctx.codec_context->codec_id)
{
case CODEC_ID_H264:
printf("CODEC_ID_H264\n");
ctx.vcodec.has_video = 1;
ctx.vcodec.has_audio = 0;
ctx.stream_type = STREAM_ES;
//ctx.vcodec.video_pid = ctx.demuxer->GetVideoIndex();
ctx.vcodec.video_type = VFORMAT_H264;
ctx.vcodec.stream_type = STREAM_TYPE_ES_VIDEO;
//ctx.vcodec.noblock = !!p_para->buffering_enable;
ctx.vcodec.am_sysinfo.format = VIDEO_DEC_FORMAT_H264;
ctx.vcodec.am_sysinfo.width = ctx.vstream_info.video_width;
ctx.vcodec.am_sysinfo.height = ctx.vstream_info.video_height;
ctx.vcodec.am_sysinfo.rate = ctx.vstream_info.video_rate;
ctx.vcodec.am_sysinfo.ratio = ctx.vstream_info.video_ratio;
ctx.vcodec.am_sysinfo.param = (void*)(EXTERNAL_PTS | SYNC_OUTSIDE);
break;
case CODEC_ID_MPEG4:
printf("CODEC_ID_MPEG4\n");
ctx.vcodec.video_type = VFORMAT_MPEG4;
break;
case CODEC_ID_MPEG2VIDEO:
printf("CODEC_ID_MPEG2VIDEO\n");
ctx.vcodec.video_type = VFORMAT_MPEG12;
break;
default:
fprintf(stderr, "ERROR: Invalid FFmpegFileReader Codec Format (not h264/mpeg4) = %d\n",
ctx.codec_context->codec_id);
goto fail;
break;
}
ret = codec_init(&ctx.vcodec);
if(ret != CODEC_ERROR_NONE)
{
printf("codec init failed, ret=-0x%x", -ret);
return -1;
}
printf("video codec ok!\n");
ret = codec_init_cntl(&ctx.vcodec);
if( ret != CODEC_ERROR_NONE )
{
printf("codec_init_cntl error\n");
return -1;
}
codec_set_cntl_avthresh(&ctx.vcodec, AV_SYNC_THRESH);
codec_set_cntl_syncthresh(&ctx.vcodec, ctx.vcodec.has_audio);
{
int frame_count, total = 0;
int64_t bgn_us, end_us;
ctx.am_pkt.codec = &ctx.vcodec;
pre_header_feeding(&ctx, &ctx.am_pkt);
ctx.demuxer->Read(ctx.am_pkt.avpkt);
printf("byte_count(%d), dts(%llu), pts(%llu)\n",
ctx.am_pkt.avpkt->size, ctx.am_pkt.avpkt->dts, ctx.am_pkt.avpkt->pts);
if (!ctx.am_pkt.avpkt->size) {
fprintf(stderr, "ERROR: Zero bytes read from input\n");
//goto fail;
}
ctx.am_pkt.type = CODEC_VIDEO;
ctx.am_pkt.data = ctx.am_pkt.avpkt->data;
ctx.am_pkt.data_size = ctx.am_pkt.avpkt->size;
ctx.am_pkt.avpkt_newflag = 1;
ctx.am_pkt.avpkt_isvalid = 1;
frame_count = 0;
bool done = false;
struct buf_status vbuf;
struct vdec_status vdec;
float vlevel;
while (!g_signal_abort && !done && (frame_count < 5000)) {
h264_update_frame_header(&ctx.am_pkt);
bgn_us = CurrentHostCounter() * 1000 / CurrentHostFrequency();
log_print("avpts(%lld), avdts(%lld)\n",
ctx.am_pkt.avpkt->pts, ctx.am_pkt.avpkt->dts);
ret = write_av_packet(&ctx, &ctx.am_pkt);
end_us = CurrentHostCounter() * 1000 / CurrentHostFrequency();
frame_count++;
//fprintf(stdout, "decode time(%llu) us\n", end_us-bgn_us);
check_vcodec_state(&ctx.vcodec, &vdec, &vbuf);
vlevel = 100.0 * (float)vbuf.data_len / vbuf.size;
//log_print("buffering_states,vlevel=%d,vsize=%d,level=%f\n", vbuf.data_len, vbuf.size, vlevel);
usleep(vlevel * 5000);
ctx.demuxer->Read(ctx.am_pkt.avpkt);
ctx.am_pkt.type = CODEC_VIDEO;
ctx.am_pkt.data = ctx.am_pkt.avpkt->data;
ctx.am_pkt.data_size = ctx.am_pkt.avpkt->size;
ctx.am_pkt.avpkt_newflag = 1;
ctx.am_pkt.avpkt_isvalid = 1;
if (!ctx.am_pkt.data_size) done = true;
total += ctx.am_pkt.data_size;
}
}
fail:
codec_close_cntl(&ctx.vcodec);
codec_close(&ctx.vcodec);
return 0;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
int error = CODEC_ERROR;
SpeexBits bits;
int eof = 0;
spx_ogg_sync_state oy;
spx_ogg_page og;
spx_ogg_packet op;
spx_ogg_stream_state os;
spx_int64_t page_granule = 0;
spx_int64_t cur_granule = 0;
int enh_enabled = 1;
int nframes = 2;
int eos = 0;
SpeexStereoState *stereo;
int channels = -1;
int samplerate = ci->id3->frequency;
int extra_headers = 0;
int stream_init = 0;
/* rockbox: comment 'set but unused' variables
int page_nb_packets;
*/
int frame_size;
int packet_count = 0;
int lookahead;
int headerssize = 0;
unsigned long strtoffset = ci->id3->offset;
void *st = NULL;
int j = 0;
intptr_t param;
memset(&bits, 0, sizeof(bits));
memset(&oy, 0, sizeof(oy));
/* Ogg handling still uses mallocs, so reset the malloc buffer per track */
if (codec_init()) {
goto exit;
}
ci->seek_buffer(0);
ci->set_elapsed(0);
stereo = speex_stereo_state_init();
spx_ogg_sync_init(&oy);
spx_ogg_alloc_buffer(&oy,2*CHUNKSIZE);
codec_set_replaygain(ci->id3);
eof = 0;
while (!eof) {
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
/*seek (seeks to the page before the position) */
if (action == CODEC_ACTION_SEEK_TIME) {
if(samplerate!=0&&packet_count>1){
LOGF("Speex seek page:%lld,%lld,%ld,%lld,%d\n",
((spx_int64_t)param/1000) *
(spx_int64_t)samplerate,
page_granule, param,
(page_granule/samplerate)*1000, samplerate);
speex_seek_page_granule(((spx_int64_t)param/1000) *
(spx_int64_t)samplerate,
page_granule, &oy, headerssize);
}
ci->set_elapsed(param);
ci->seek_complete();
}
next_page:
/*Get the ogg buffer for writing*/
if(get_more_data(&oy)<1){/*read error*/
goto done;
}
/* Loop for all complete pages we got (most likely only one) */
while (spx_ogg_sync_pageout(&oy, &og) == 1) {
int packet_no;
if (stream_init == 0) {
spx_ogg_stream_init(&os, spx_ogg_page_serialno(&og));
stream_init = 1;
}
/* Add page to the bitstream */
spx_ogg_stream_pagein(&os, &og);
page_granule = spx_ogg_page_granulepos(&og);
/* page_nb_packets = spx_ogg_page_packets(&og); */
cur_granule = page_granule;
/* Extract all available packets */
packet_no=0;
while (!eos && spx_ogg_stream_packetout(&os, &op)==1){
/* If first packet, process as Speex header */
if (packet_count==0){
st = process_header(&op, enh_enabled, &frame_size,
&samplerate, &nframes, &channels,
stereo, &extra_headers);
speex_decoder_ctl(st, SPEEX_GET_LOOKAHEAD, &lookahead);
if (!nframes)
nframes=1;
if (!st){
goto done;
}
ci->configure(DSP_SET_FREQUENCY, ci->id3->frequency);
ci->configure(DSP_SET_SAMPLE_DEPTH, 16);
if (channels == 2) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
} else if (channels == 1) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
}
/* Speex header in its own page, add the whole page
headersize */
headerssize += og.header_len+og.body_len;
} else if (packet_count<=1+extra_headers){
/* add packet to headersize */
headerssize += op.bytes;
/* Ignore extra headers */
} else {
if (packet_count <= 2+extra_headers) {
if (strtoffset) {
ci->seek_buffer(strtoffset);
spx_ogg_sync_reset(&oy);
packet_count++;
goto next_page;
}
}
packet_no++;
if (op.e_o_s) /* End of stream condition */
eos=1;
/* Set Speex bitstream to point to Ogg packet */
speex_bits_set_bit_buffer(&bits, (char *)op.packet,
op.bytes);
for (j = 0; j != nframes; j++){
int ret;
/* Decode frame */
ret = speex_decode_int(st, &bits, output);
if (ret == -1)
break;
if (ret == -2)
break;
if (speex_bits_remaining(&bits) < 0)
break;
if (channels == 2)
speex_decode_stereo_int(output, frame_size, stereo);
if (frame_size > 0) {
spx_int16_t *frame_start = output + lookahead;
if (channels == 2)
frame_start += lookahead;
ci->pcmbuf_insert(frame_start, NULL,
frame_size - lookahead);
lookahead = 0;
/* 2 bytes/sample */
cur_granule += frame_size / 2;
ci->set_offset((long) ci->curpos);
ci->set_elapsed((samplerate == 0) ? 0 :
cur_granule * 1000 / samplerate);
}
}
}
packet_count++;
}
}
}
error = CODEC_OK;
done:
/* Clean things up for the next track */
speex_bits_destroy(&bits);
if (st)
speex_decoder_destroy(st);
if (stream_init)
spx_ogg_stream_destroy(&os);
spx_ogg_sync_destroy(&oy);
exit:
return error;
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
int n_bytes;
int song;
int duration;
char* module;
int bytesPerSample =2;
next_track:
if (codec_init()) {
DEBUGF("codec init failed\n");
return CODEC_ERROR;
}
while (!*ci->taginfo_ready && !ci->stop_codec)
ci->sleep(1);
codec_set_replaygain(ci->id3);
int bytes_done =0;
size_t filesize;
ci->seek_buffer(0);
module = ci->request_buffer(&filesize, ci->filesize);
if (!module || (size_t)filesize < (size_t)ci->filesize)
{
DEBUGF("loading error\n");
return CODEC_ERROR;
}
/*Init ASAP */
if (!ASAP_Load(&asap, ci->id3->path, module, filesize))
{
DEBUGF("%s: format not supported",ci->id3->path);
return CODEC_ERROR;
}
/* Make use of 44.1khz */
ci->configure(DSP_SET_FREQUENCY, 44100);
/* Sample depth is 16 bit little endian */
ci->configure(DSP_SET_SAMPLE_DEPTH, 16);
/* Stereo or Mono output ? */
if(asap.module_info.channels ==1)
{
ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
bytesPerSample = 2;
}
else
{
ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
bytesPerSample = 4;
}
/* reset eleapsed */
ci->set_elapsed(0);
song = asap.module_info.default_song;
duration = asap.module_info.durations[song];
if (duration < 0)
duration = 180 * 1000;
/* set id3 length, because metadata parse might not have done it */
ci->id3->length = duration;
ASAP_PlaySong(&asap, song, duration);
ASAP_MutePokeyChannels(&asap, 0);
/* The main decoder loop */
while (1) {
ci->yield();
if (ci->stop_codec || ci->new_track)
break;
if (ci->seek_time) {
/* New time is ready in ci->seek_time */
/* seek to pos */
ASAP_Seek(&asap,ci->seek_time);
/* update elapsed */
ci->set_elapsed(ci->seek_time);
/* update bytes_done */
bytes_done = ci->seek_time*44.1*2;
/* seek ready */
ci->seek_complete();
}
/* Generate a buffer full of Audio */
#ifdef ROCKBOX_LITTLE_ENDIAN
n_bytes = ASAP_Generate(&asap, samples, sizeof(samples), ASAP_FORMAT_S16_LE);
#else
n_bytes = ASAP_Generate(&asap, samples, sizeof(samples), ASAP_FORMAT_S16_BE);
#endif
ci->pcmbuf_insert(samples, NULL, n_bytes /bytesPerSample);
bytes_done += n_bytes;
ci->set_elapsed((bytes_done / 2) / 44.1);
if(n_bytes != sizeof(samples))
break;
}
if (ci->request_next_track())
goto next_track;
return CODEC_OK;
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
size_t n;
demux_res_t demux_res;
stream_t input_stream;
uint32_t samplesdone;
uint32_t elapsedtime = 0;
int samplesdecoded;
unsigned int i;
unsigned char* buffer;
alac_file alac;
intptr_t param;
/* Clean and initialize decoder structures */
memset(&demux_res , 0, sizeof(demux_res));
if (codec_init()) {
LOGF("ALAC: Error initialising codec\n");
return CODEC_ERROR;
}
ci->configure(DSP_SET_FREQUENCY, ci->id3->frequency);
codec_set_replaygain(ci->id3);
ci->seek_buffer(0);
stream_create(&input_stream,ci);
/* Read from ci->id3->offset before calling qtmovie_read. */
samplesdone = (uint32_t)(((uint64_t)(ci->id3->offset) * ci->id3->frequency) /
(ci->id3->bitrate*128));
/* if qtmovie_read returns successfully, the stream is up to
* the movie data, which can be used directly by the decoder */
if (!qtmovie_read(&input_stream, &demux_res)) {
LOGF("ALAC: Error initialising file\n");
return CODEC_ERROR;
}
/* initialise the sound converter */
alac_set_info(&alac, demux_res.codecdata);
/* Set i for first frame, seek to desired sample position for resuming. */
i=0;
if (samplesdone > 0) {
if (m4a_seek(&demux_res, &input_stream, samplesdone,
&samplesdone, (int*) &i)) {
elapsedtime = (samplesdone * 10) / (ci->id3->frequency / 100);
ci->set_elapsed(elapsedtime);
} else {
samplesdone = 0;
}
}
ci->set_elapsed(elapsedtime);
/* The main decoding loop */
while (i < demux_res.num_sample_byte_sizes) {
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
/* Request the required number of bytes from the input buffer */
buffer=ci->request_buffer(&n, ALAC_BYTE_BUFFER_SIZE);
/* Deal with any pending seek requests */
if (action == CODEC_ACTION_SEEK_TIME) {
if (m4a_seek(&demux_res, &input_stream,
(param/10) * (ci->id3->frequency/100),
&samplesdone, (int *)&i)) {
elapsedtime=(samplesdone*10)/(ci->id3->frequency/100);
}
ci->set_elapsed(elapsedtime);
ci->seek_complete();
}
/* Request the required number of bytes from the input buffer */
buffer=ci->request_buffer(&n, ALAC_BYTE_BUFFER_SIZE);
/* Decode one block - returned samples will be host-endian */
samplesdecoded=alac_decode_frame(&alac, buffer, outputbuffer, ci->yield);
ci->yield();
/* Advance codec buffer by amount of consumed bytes */
ci->advance_buffer(alac.bytes_consumed);
/* Output the audio */
ci->pcmbuf_insert(outputbuffer[0], outputbuffer[1], samplesdecoded);
/* Update the elapsed-time indicator */
samplesdone+=samplesdecoded;
elapsedtime=(samplesdone*10)/(ci->id3->frequency/100);
ci->set_elapsed(elapsedtime);
i++;
}
LOGF("ALAC: Decoded %lu samples\n",(unsigned long)samplesdone);
return CODEC_OK;
}