void ES_PlayInjectionMediaDatas ( MEDIA_CODEC_TYPE_E data_type, void *es_buffer, unsigned int buffer_len, unsigned int PTS )
{
int ret;
if( (DAL_ES_VCODEC_TYPE_H264 == data_type) && ( vpcodec != NULL) )
{
int len = buffer_len;
int wcnt = buffer_len;
if( PTS != 0xffffffff )
ret = codec_checkin_pts( vpcodec, PTS);
while( 1 )
{
wcnt = codec_write( vpcodec, es_buffer, buffer_len);
if( wcnt > 0 )
{
len = len - wcnt;
if( len <= 0 )
{
break;
}
memmove( es_buffer, (unsigned char*)es_buffer+wcnt, len );
}
else
{
break;
}
}
}
else if( (DAL_ES_ACODEC_TYPE_AAC == data_type) && ( apcodec != NULL) )
{
int len = buffer_len;
int wcnt = buffer_len;
ret = codec_checkin_pts( apcodec, PTS);
while( 1 )
{
wcnt = codec_write( apcodec, es_buffer, buffer_len);
if( wcnt > 0 )
{
len = len - wcnt;
if( len <= 0 )
{
break;
}
memmove( es_buffer, (unsigned char*)es_buffer+wcnt, len );
}
else
{
break;
}
}
}
}
void codec_init()
{
// Setup Initial Codec
// Initialize I2C
i2c_init();
delay(100);
// Setup Reset pin (GPIO)
// Right now assuming that we're using Teensy pin 2
// which is Port D pin 0
// Setup Pin muxing for GPIO (alt 1)
PORTD_PCR0 = PORT_PCR_MUX(1);
// Setup pin for digital out
GPIOD_PDDR |= (1 << 0);
// Make sure pin is cleared (still driving reset)
GPIOD_PCOR = (1 << 0);
delay(1);
// Release Reset (drive pin high)
GPIOD_PSOR = (1 << 0);
// Wait for ~2-5ms (1-10 ms time window spec'd in datasheet)
delay(2);
// Set power down and control port enable as spec'd in the
// datasheet for control port mode
codec_write(CODEC_MODE_CTRL2, CODEC_MODE_CTRL2_POWER_DOWN
| CODEC_MODE_CTRL2_CTRL_PORT_EN);
// Further setup
delay(1);
// Set ratio select for MCLK=512*LRCLK (BCLK = 64*LRCLK), and master mode
codec_write(CODEC_MODE_CONTROL, CODEC_MC_RATIO_SEL(3) | CODEC_MC_MASTER_SLAVE);
delay(10);
// Release power down bit to start up codec
// TODO: May need other bits set in this reg
codec_write(CODEC_MODE_CTRL2, CODEC_MODE_CTRL2_CTRL_PORT_EN);
// Wait for everything to come up
delay(10);
}
static int write_header(AppContext *para, am_packet_t *pkt)
{
int write_bytes = 0, len = 0;
if (pkt->hdr && pkt->hdr->size > 0) {
if ((NULL == pkt->codec) || (NULL == pkt->hdr->data)) {
log_error("[write_header]codec null!\n");
return PLAYER_EMPTY_P;
}
while (1) {
write_bytes = codec_write(pkt->codec, pkt->hdr->data + len, pkt->hdr->size - len);
if (write_bytes < 0 || write_bytes > (pkt->hdr->size - len)) {
if (-errno != AVERROR(EAGAIN)) {
log_print("ERROR:write header failed!\n");
return PLAYER_WR_FAILED;
} else {
continue;
}
} else {
len += write_bytes;
if (len == pkt->hdr->size) {
break;
}
}
}
}
return PLAYER_SUCCESS;
}
int main(){
float input_data;
int32 output_data;
//Configure hardware
codec_init();
fir_init(banda1,banda2,banda3,banda4,banda5);
while(1){
//Processing data
if(DSK6713_DIP_get(3)==0){
//Initialize processing
leds_output(LED_STATE_ACTIVE);
while(DSK6713_DIP_get(3)==0){
input_data = codec_read();
output_data = fir_filter(input_data);
codec_write(output_data);
}
}
//Waiting
else{
leds_output(LED_STATE_WATING);
}
}
}
int CTsPlayer::WriteData(unsigned char* pBuffer, unsigned int nSize)
{
#if DUMP_TSPACKET1
fwrite(pBuffer,nSize,1,m_fStream);
#endif
#ifdef USE_UDP
gUDPClient.push(pBuffer,nSize);
#endif
if(0 == ++iActiveCount%1500){
LOGI("CTsPlayer::WriteData is active.\n");
}
return codec_write(pcodec,pBuffer,nSize);
}
static void
ice_1712_shutdown(ice1712 *ice)
{
delete_sem(ice->buffer_ready_sem);
remove_io_interrupt_handler(ice->irq, ice_1712_int, ice);
if (ice->mem_id_pb != B_ERROR)
delete_area(ice->mem_id_pb);
if (ice->mem_id_rec != B_ERROR)
delete_area(ice->mem_id_rec);
codec_write(ice, AK45xx_RESET_REGISTER, 0x00);
}
void main( void )
{
I2C_init();
Sampling(SAMPLES_PER_SECOND, ADCgain);
while(1){
left_input = generate_sinewave_L(250, 10000);
right_input = generate_sinewave_R(250, 10000);
//filter input
left_output = FIR_filter_asm(&hp[0], left_input);
right_output = FIR_filter_asm_2(&hp[0], right_input);
codec_write(left_output, right_output);
}
}
int aml_submit_decode_unit(PDECODE_UNIT decodeUnit) {
int result = DR_OK;
PLENTRY entry = decodeUnit->bufferList;
while (entry != NULL) {
int api = codec_write(&codecParam, entry->data, entry->length);
if (api != entry->length) {
fprintf(stderr, "codec_write error: %x\n", api);
codec_reset(&codecParam);
result = DR_NEED_IDR;
break;
}
entry = entry->next;
}
return result;
}
int write_av_packet(AppContext *para, am_packet_t *pkt)
{
int write_bytes = 0, len = 0, ret;
unsigned char *buf;
int size ;
if (pkt->avpkt_newflag) {
if (pkt->type != CODEC_SUBTITLE) {
if (pkt->avpkt_isvalid) {
ret = check_in_pts(para, pkt);
if (ret != PLAYER_SUCCESS) {
log_error("check in pts failed\n");
return PLAYER_WR_FAILED;
}
}
if (write_header(para, pkt) == PLAYER_WR_FAILED) {
log_error("[%s]write header failed!\n", __FUNCTION__);
return PLAYER_WR_FAILED;
}
} else {
// process_es_subtitle(para, pkt);
}
pkt->avpkt_newflag = 0;
}
buf = pkt->data;
size = pkt->data_size ;
if (size == 0 && pkt->avpkt_isvalid) {
if ((pkt->type == CODEC_VIDEO)) {
para->write_size.vpkt_num++;
}
if (pkt->avpkt) {
av_free_packet(pkt->avpkt);
}
pkt->avpkt_isvalid = 0;
}
while (size > 0 && pkt->avpkt_isvalid) {
write_bytes = codec_write(pkt->codec, (char *)buf, size);
if (write_bytes < 0 || write_bytes > size) {
if (-errno != AVERROR(EAGAIN)) {
para->playctrl_info.check_lowlevel_eagain_cnt = 0;
log_print("write codec data failed!\n");
return PLAYER_WR_FAILED;
} else {
// EAGAIN to see if buffer full or write time out too much
if (check_avbuffer_enough(para, pkt)) {
para->playctrl_info.check_lowlevel_eagain_cnt++;
} else {
para->playctrl_info.check_lowlevel_eagain_cnt = 0;
}
if (para->playctrl_info.check_lowlevel_eagain_cnt > 50) {
// reset decoder
para->playctrl_info.check_lowlevel_eagain_cnt = 0;
para->playctrl_info.reset_flag = 1;
para->playctrl_info.end_flag = 1;
if (para->state.start_time != -1) {
para->playctrl_info.time_point = (para->state.pts_video - para->state.start_time)/ PTS_FREQ;
} else {
para->playctrl_info.time_point = para->state.pts_video/ PTS_FREQ;
}
log_print("$$$$$$[type:%d] write blocked, need reset decoder!$$$$$$\n", pkt->type);
}
pkt->data += len;
pkt->data_size -= len;
usleep(RW_WAIT_TIME);
if (para->playctrl_info.check_lowlevel_eagain_cnt > 0) {
log_print("[%s]eagain:data_size=%d type=%d rsize=%lld wsize=%lld cnt=%d\n", \
__FUNCTION__, pkt->data_size, pkt->type, para->read_size.total_bytes, \
para->write_size.total_bytes, para->playctrl_info.check_lowlevel_eagain_cnt);
}
return PLAYER_SUCCESS;
}
} else {
para->playctrl_info.check_lowlevel_eagain_cnt = 0;
len += write_bytes;
if (len == pkt->data_size) {
if ((pkt->type == CODEC_VIDEO)) {
para->write_size.vpkt_num++;
}
if (pkt->avpkt) {
av_free_packet(pkt->avpkt);
}
pkt->avpkt_isvalid = 0;
pkt->data_size = 0;
//log_print("[%s:%d]write finish pkt->data_size=%d\r",__FUNCTION__, __LINE__,pkt->data_size);
break;
} else if (len < pkt->data_size) {
buf += write_bytes;
size -= write_bytes;
} else {
return PLAYER_WR_FAILED;
}
}
}
if (check_write_finish(para, pkt) == PLAYER_WR_FINISH) {
return PLAYER_WR_FINISH;
}
return PLAYER_SUCCESS;
}
static void
start_DMA(ice1712 *card)
{
uint16 size = card->buffer_size * MAX_DAC;
write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);
write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS, (uint32)card->phys_addr_pb);
write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1);
//We want interrupt only from playback
write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1);
TRACE("SIZE DMA PLAYBACK %#x\n", size);
size = card->buffer_size * MAX_ADC;
write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS, (uint32)card->phys_addr_rec);
write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1);
//We do not want any interrupt from the record
write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0);
TRACE("SIZE DMA RECORD %#x\n", size);
//Enable output AND Input from Analog CODEC
switch (card->product) {
//TODO: find correct value for all card
case ICE1712_SUBDEVICE_DELTA66:
case ICE1712_SUBDEVICE_DELTA44:
case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
case ICE1712_SUBDEVICE_DELTADIO2496:
case ICE1712_SUBDEVICE_DELTA410:
case ICE1712_SUBDEVICE_DELTA1010LT:
case ICE1712_SUBDEVICE_DELTA1010:
codec_write(card, AK45xx_CLOCK_FORMAT_REGISTER, 0x69);
codec_write(card, AK45xx_RESET_REGISTER, 0x03);
break;
case ICE1712_SUBDEVICE_VX442:
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1);
break;
}
//Set Data Format for SPDif codec
switch (card->product) {
//TODO: find correct value for all card
case ICE1712_SUBDEVICE_DELTA1010:
break;
case ICE1712_SUBDEVICE_DELTADIO2496:
break;
case ICE1712_SUBDEVICE_DELTA66:
case ICE1712_SUBDEVICE_DELTA44:
// ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_1);
break;
case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
spdif_write(card, CS84xx_SERIAL_INPUT_FORMAT_REG, 0x85);
spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x85);
// spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x41);
break;
case ICE1712_SUBDEVICE_DELTA410:
break;
case ICE1712_SUBDEVICE_DELTA1010LT:
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_1);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_2);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_3);
break;
case ICE1712_SUBDEVICE_VX442:
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1);
break;
}
card->buffer = 1;
write_mt_uint8(card, MT_PROF_PB_CONTROL, 5);
}
int main(int argc,char *argv[])
{
int ret = CODEC_ERROR_NONE;
char buffer[READ_SIZE];
unsigned int vformat = 0, aformat = 0;
int len = 0;
int size = READ_SIZE;
uint32_t Readlen;
uint32_t isize;
struct buf_status vbuf;
if (argc < 8) {
printf("Corret command: tsplay <filename> <vid> <vformat(1 for mpeg2, 2 for h264)> <aid> <aformat(1 for mp3)> <channel> <samplerate>\n");
return -1;
}
osd_blank("/sys/class/graphics/fb0/blank",1);
osd_blank("/sys/class/graphics/fb1/blank",0);
set_display_axis(0);
set_stb_source_hiu();
set_stb_demux_source_hiu();
pcodec = &codec_para;
memset(pcodec, 0, sizeof(codec_para_t ));
pcodec->noblock = 0;
pcodec->has_video = 1;
pcodec->video_pid = atoi(argv[2]);
vformat = atoi(argv[3]);
if (vformat == 1)
pcodec->video_type = VFORMAT_MPEG12;
else if (vformat == 2)
pcodec->video_type = VFORMAT_H264;
else
pcodec->video_type = VFORMAT_MPEG12;
pcodec->has_audio = 1;
pcodec->audio_pid = atoi(argv[4]);
aformat = atoi(argv[5]);
pcodec->audio_type = AFORMAT_MPEG; // take mp for example
pcodec->audio_channels = atoi(argv[6]);
pcodec->audio_samplerate = atoi(argv[7]);
pcodec->audio_info.channels = 2;
pcodec->audio_info.sample_rate = pcodec->audio_samplerate;
pcodec->audio_info.valid = 1;
pcodec->stream_type = STREAM_TYPE_TS;
pcodec->packet_size = 188; // standard ts packet size
printf("\n*********CODEC PLAYER DEMO************\n\n");
filename = argv[1];
printf("file %s to be played\n", filename);
if((fp = fopen(filename,"rb")) == NULL)
{
printf("open file error!\n");
return -1;
}
ret = codec_init(pcodec);
if(ret != CODEC_ERROR_NONE)
{
printf("codec init failed, ret=-0x%x", -ret);
return -1;
}
printf("ps codec ok!\n");
//codec_set_cntl_avthresh(vpcodec, AV_SYNC_THRESH);
//codec_set_cntl_syncthresh(vpcodec, 0);
set_avsync_enable(1);
while(!feof(fp))
{
Readlen = fread(buffer, 1, READ_SIZE,fp);
//printf("Readlen %d\n", Readlen);
if(Readlen <= 0)
{
printf("read file error!\n");
rewind(fp);
}
isize = 0;
do{
ret = codec_write(pcodec, buffer+isize, Readlen);
if (ret < 0) {
if (errno != EAGAIN) {
printf("write data failed, errno %d\n", errno);
goto error;
}
else {
continue;
}
}
else {
isize += ret;
}
//printf("ret %d, isize %d\n", ret, isize);
}while(isize < Readlen);
signal(SIGCHLD, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGSEGV, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
}
do {
ret = codec_get_vbuf_state(pcodec, &vbuf);
if (ret != 0) {
printf("codec_get_vbuf_state error: %x\n", -ret);
goto error;
}
} while (vbuf.data_len > 0x100);
error:
codec_close(pcodec);
fclose(fp);
set_display_axis(1);
return 0;
}
static GstFlowReturn
gst_aml_vdec_decode (GstAmlVdec *amlvdec, GstBuffer * buf)
{
GstFlowReturn ret = GST_FLOW_OK;
guint8 *data;
guint size;
gint written;
GstClockTime timestamp, pts;
struct buf_status vbuf;
GstMapInfo map;
if (!amlvdec->info) {
return GST_FLOW_OK;
}
if (amlvdec->pcodec && amlvdec->codec_init_ok) {
while (codec_get_vbuf_state(amlvdec->pcodec, &vbuf) == 0) {
if (vbuf.data_len * 10 < vbuf.size * 7) {
break;
}
if (amlvdec->is_paused) {
break;
}
usleep(20000);
}
timestamp = GST_BUFFER_TIMESTAMP (buf);
pts = timestamp * 9LL / 100000LL + 1L;
if (timestamp != GST_CLOCK_TIME_NONE) {
GST_INFO_OBJECT(amlvdec, " video pts = %x", (unsigned long) pts);
if (codec_checkin_pts(amlvdec->pcodec, (unsigned long) pts) != 0)
GST_ERROR_OBJECT(amlvdec, "pts checkin flied maybe lose sync");
}
if (!amlvdec->is_headerfeed) {
if (amlvdec->info->writeheader) {
amlvdec->info->writeheader(amlvdec->info, amlvdec->pcodec);
}
amlvdec->is_headerfeed = TRUE;
}
if (amlvdec->info->add_startcode) {
amlvdec->info->add_startcode(amlvdec->info, amlvdec->pcodec, buf);
}
gst_buffer_map(buf, &map, GST_MAP_READ);
data = map.data;
size = map.size;
while (size > 0) {
written = codec_write(amlvdec->pcodec, data, size);
if (written >= 0) {
size -= written;
data += written;
} else if (errno == EAGAIN || errno == EINTR) {
GST_WARNING_OBJECT(amlvdec, "codec_write busy");
if (amlvdec->is_paused) {
break;
}
usleep(20000);
} else {
GST_ERROR_OBJECT(amlvdec, "codec_write failed");
ret = GST_FLOW_ERROR;
break;
}
}
gst_buffer_unmap(buf, &map);
}
return ret;
}
int main(int argc,char *argv[])
{
int ret = CODEC_ERROR_NONE;
char buffer[READ_SIZE];
int len = 0;
int size = READ_SIZE;
uint32_t Readlen;
uint32_t isize;
struct buf_status vbuf;
if (argc < 6) {
printf("Corret command: esplayer <filename> <width> <height> <fps> <format(1:mpeg4 2:h264 6:vc1)> [subformat for mpeg4/vc1]\n");
return -1;
}
osd_blank("/sys/class/graphics/fb0/blank",1);
osd_blank("/sys/class/graphics/fb1/blank",0);
set_display_axis(0);
#ifdef AUDIO_ES
apcodec = &a_codec_para;
memset(apcodec, 0, sizeof(codec_para_t ));
#endif
vpcodec = &v_codec_para;
memset(vpcodec, 0, sizeof(codec_para_t ));
vpcodec->has_video = 1;
vpcodec->video_type = atoi(argv[5]);
if (vpcodec->video_type == VFORMAT_H264) {
vpcodec->am_sysinfo.format = VIDEO_DEC_FORMAT_H264;
vpcodec->am_sysinfo.param = (void *)(EXTERNAL_PTS | SYNC_OUTSIDE);
}
else if (vpcodec->video_type == VFORMAT_VC1) {
if (argc < 7) {
printf("No subformat for vc1, take the default VIDEO_DEC_FORMAT_WVC1\n");
vpcodec->am_sysinfo.format = VIDEO_DEC_FORMAT_WVC1;
}
else {
vpcodec->am_sysinfo.format = atoi(argv[6]);
}
}
else if (vpcodec->video_type == VFORMAT_MPEG4) {
if (argc < 7) {
printf("No subformat for mpeg4, take the default VIDEO_DEC_FORMAT_MPEG4_5\n");
vpcodec->am_sysinfo.format = VIDEO_DEC_FORMAT_MPEG4_5;
}
else {
vpcodec->am_sysinfo.format = atoi(argv[6]);
}
}
vpcodec->stream_type = STREAM_TYPE_ES_VIDEO;
vpcodec->am_sysinfo.rate = 96000 / atoi(argv[4]);
vpcodec->am_sysinfo.height = atoi(argv[3]);
vpcodec->am_sysinfo.width = atoi(argv[2]);
vpcodec->has_audio = 0;
vpcodec->noblock = 0;
#ifdef AUDIO_ES
apcodec->audio_type = AFORMAT_MPEG;
apcodec->stream_type = STREAM_TYPE_ES_AUDIO;
apcodec->audio_pid = 0x1023;
apcodec->has_audio = 1;
apcodec->audio_channels = 2;
apcodec->audio_samplerate = 48000;
apcodec->noblock = 0;
apcodec->audio_info.channels = 2;
apcodec->audio_info.sample_rate = 48000;
#endif
printf("\n*********CODEC PLAYER DEMO************\n\n");
filename = argv[1];
printf("file %s to be played\n", filename);
if((fp = fopen(filename,"rb")) == NULL)
{
printf("open file error!\n");
return -1;
}
#ifdef AUDIO_ES
ret = codec_init(apcodec);
if(ret != CODEC_ERROR_NONE)
{
printf("codec init failed, ret=-0x%x", -ret);
return -1;
}
#endif
ret = codec_init(vpcodec);
if(ret != CODEC_ERROR_NONE)
{
printf("codec init failed, ret=-0x%x", -ret);
return -1;
}
printf("video codec ok!\n");
//codec_set_cntl_avthresh(vpcodec, AV_SYNC_THRESH);
//codec_set_cntl_syncthresh(vpcodec, 0);
set_tsync_enable(0);
pcodec = vpcodec;
while(!feof(fp))
{
Readlen = fread(buffer, 1, READ_SIZE,fp);
//printf("Readlen %d\n", Readlen);
if(Readlen <= 0)
{
printf("read file error!\n");
rewind(fp);
}
isize = 0;
do {
ret = codec_write(pcodec, buffer+isize, Readlen);
if (ret < 0) {
if (errno != EAGAIN) {
printf("write data failed, errno %d\n", errno);
goto error;
}
else {
continue;
}
}
else {
isize += ret;
}
//printf("ret %d, isize %d\n", ret, isize);
} while(isize < Readlen);
signal(SIGCHLD, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGSEGV, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
}
do {
ret = codec_get_vbuf_state(pcodec, &vbuf);
if (ret != 0) {
printf("codec_get_vbuf_state error: %x\n", -ret);
goto error;
}
} while (vbuf.data_len > 0x100);
error:
#ifdef AUDIO_ES
codec_close(apcodec);
#endif
codec_close(vpcodec);
fclose(fp);
set_display_axis(1);
return 0;
}
