/** demux_action:
* @mod_ctrl: demux module instance
* @action_code: action id
* @data: input parameter data
* @data_size: input parameter size
*
* This function runs in ISP HW thread context.
*
* This function executes an demux module action
*
* Return: 0 - Success
* Negative - action execution error
**/
static int demux_action (void *mod_ctrl, uint32_t action_code, void *data,
uint32_t data_size)
{
int rc = 0;
isp_demux_mod_t *demux = mod_ctrl;
switch (action_code) {
case ISP_HW_MOD_ACTION_HW_UPDATE:
rc = demux_do_hw_update(demux);
break;
case ISP_HW_MOD_ACTION_RESET:
demux_reset(demux);
break;
default:
/* no op */
rc = -EAGAIN;
CDBG_HIGH("%s: action code = %d is not supported. nop",
__func__, action_code);
break;
}
return rc;
} /* demux_action */
demux_t *demux_alloc(void) {
demux_t *dm = kmalloc(sizeof(demux_t), GFP_KERNEL);
BUG_ON(dm == NULL);
memset(dm, 0, sizeof(demux_t));
demux_reset(dm);
return dm;
}
/** demux_init:
* @mod_ctrl: demux module instance
* @in_params: input paramters
* @notify_ops: module notify ops
*
* This function runs in ISP HW thread context.
*
* This function initializes demux module
*
* Return: 0 - Success
* -1 - Parameters size mismatch
**/
static int demux_init (void *mod_ctrl, void *in_params,
isp_notify_ops_t *notify_ops)
{
isp_demux_mod_t *demux = mod_ctrl;
isp_hw_mod_init_params_t *init_params = in_params;
demux->fd = init_params->fd;
demux->notify_ops = notify_ops;
demux->old_streaming_mode = CAM_STREAMING_MODE_MAX;
demux_reset(demux);
return 0;
} /* demux_init */
void
fb_thruput(void)
{
char path[256];
switch_hw_state(MVPMC_STATE_FILEBROWSER);
sprintf(path, "%s/%s", cwd, current_hilite);
if (current)
free(current);
current = strdup(path);
video_functions = &file_functions;
demux_reset(handle);
demux_attr_reset(handle);
video_play(NULL);
}
void*
video_read_start(void *arg)
{
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int ret;
int n = 0, len = 0, reset = 1;
int sent_idle_notify;
demux_attr_t *attr;
video_info_t *vi;
int set_aspect = 1;
char *inbuf = inbuf_static;
char *tsbuf;
int tslen;
int tsmode = TS_MODE_UNKNOWN;
av_state_t state;
pthread_mutex_lock(&mutex);
printf("mpeg read thread started (pid %d)\n", getpid());
pthread_cond_wait(&video_cond, &mutex);
while (1) {
sent_idle_notify = 0;
while (!video_playing) {
demux_reset(handle);
ts_demux_reset(tshandle);
demux_seek(handle);
vid_event_discontinuity_possible();
if ( !(sent_idle_notify) ) {
if ( video_functions != NULL &&
video_functions->notify != NULL ) {
video_functions->notify(MVP_READ_THREAD_IDLE);
}
printf("mpeg read thread sleeping...\n");
sent_idle_notify = 1;
}
pthread_cond_wait(&video_cond, &mutex);
TRC("%s: past pthread_cond_wait(&video_cond, &mutex)\n", __FUNCTION__);
}
#ifdef STREAM_TEST
if ( stream_test_started == 0 ) {
stream_test_started = 1;
//Get start time
gettimeofday(&start_tv, NULL);
}
#endif
if (video_reopen) {
vid_event_clear();
if (video_functions->open() == 0) {
/* Jump to the start of the new file */
jump_target = 0;
jumping = 1;
video_reopen = 0;
tsmode = TS_MODE_UNKNOWN;
} else {
fprintf(stderr, "video open failed!\n");
video_playing = 0;
continue;
}
len = 0;
reset = 1;
set_aspect = 1;
}
if ((seeking && reset) || jumping) {
demux_reset(handle);
ts_demux_reset(tshandle);
demux_seek(handle);
av_get_state(&state);
av_reset();
av_reset_stc();
vid_event_discontinuity_possible();
if (seeking)
reset = 0;
if (state.mute)
av_set_mute(1);
if (paused) {
av_play();
paused = 0;
mvpw_hide(pause_widget);
screensaver_disable();
}
pcm_decoded = 0;
ac3len = 0;
len = 0;
if (jumping) {
while (jump_target < 0)
usleep(1000);
video_functions->seek(jump_target, SEEK_SET);
}
jumping = 0;
}
if ( !video_playing ) {
continue;
}
if (len == 0) {
if ( video_functions->read_dynb != NULL ){
tslen = video_functions->read_dynb(&tsbuf, 1024 * 256);
}
else {
tsbuf = tsbuf_static;
do {
tslen = video_functions->read(tsbuf,
sizeof(tsbuf_static));
} while ( tslen==-1 && errno==EAGAIN);
}
thruput_count += tslen;
inbuf = inbuf_static;
if (tsmode == TS_MODE_UNKNOWN) {
if (tslen > 0) {
tsmode = ts_demux_is_ts(tshandle, tsbuf, tslen);
printf("auto detection transport stream returned %d\n", tsmode);
if (tsmode == TS_MODE_NO)
len = tslen;
}
} else if (tsmode == TS_MODE_NO) {
len = tslen;
} else {
len = ts_demux_transform(tshandle, tsbuf, tslen, inbuf, sizeof(inbuf_static));
int resyncs = ts_demux_resync_count(tshandle);
if (resyncs > 50) {
printf("resync count = %d, switch back to unknown mode\n", resyncs);
tsmode = TS_MODE_UNKNOWN;
ts_demux_reset(tshandle);
}
}
n = 0;
if (len == 0 && playlist ) {
video_reopen = 2;
playlist_next();
}
}
if ( !video_playing ) {
continue;
}
#ifdef STREAM_TEST
stream_test_cnt += len;
len = 0;
if ( stream_test_cnt > 1024*1024*20 ) {
unsigned int delta_ms;
gettimeofday(&done_tv, NULL);
if ( done_tv.tv_usec < start_tv.tv_usec ) {
done_tv.tv_usec += 1000000;
done_tv.tv_sec -= 1;
}
delta_ms = (done_tv.tv_sec - start_tv.tv_sec) * 1000;
delta_ms += (done_tv.tv_usec - start_tv.tv_usec) / 1000;
printf("Test Done\n");
printf("Bytes transferred: %u\n", stream_test_cnt);
printf("Elapsed time %u mS\n", delta_ms);
while ( 1 ) {
sleep(10);
printf("Test Done....\n");
}
}
continue;
#else
if (tsmode == TS_MODE_YES)
ret = DEMUX_PUT(handle, inbuf+n, len-n);
else
ret = DEMUX_PUT(handle, tsbuf+n, len-n);
#endif
if ((ret <= 0) && (!seeking)) {
pthread_cond_broadcast(&video_cond);
usleep(1000);
continue;
}
if (seeking) {
if (do_seek()) {
len = 0;
continue;
} else {
reset = 1;
}
}
n += ret;
if (n == len)
len = 0;
pthread_cond_broadcast(&video_cond);
attr = demux_get_attr(handle);
vi = &attr->video.stats.info.video;
if (attr->audio.type != audio_type) {
audio_type = attr->audio.type;
switch (audio_type) {
case AUDIO_MODE_AC3:
if (audio_output_mode == AUD_OUTPUT_PASSTHRU ) {
if (av_set_audio_output(AV_AUDIO_AC3) < 0) {
/* revert to downmixing */
audio_output_mode = AUD_OUTPUT_STEREO;
// fall through to PCM
} else {
// don't set audio_type
audio_output = AV_AUDIO_AC3;
printf("switch to AC3 Passthru\n");
break;
}
}
case AUDIO_MODE_PCM:
audio_output = AV_AUDIO_PCM;
printf("switch to PCM audio output device\n");
break;
default:
av_set_audio_type(audio_type);
audio_output = AV_AUDIO_MPEG;
printf("switch to MPEG audio output device\n");
break;
}
av_set_audio_output(audio_output);
} else {
if (audio_type==AUDIO_MODE_AC3){
sync_ac3_audio();
}
}
} //while
return NULL;
}
int
file_open(void)
{
seeking = 1;
audio_selected = 0;
audio_checks = 0;
if ( http_playing == HTTP_FILE_CLOSED ) {
if (video_reopen == 1)
audio_clear();
close(fd);
fd = -1;
}
if (video_write_thread) {
pthread_kill(video_write_thread, SIGURG);
}
if (audio_write_thread) {
pthread_kill(audio_write_thread, SIGURG);
}
if ( http_playing == HTTP_FILE_CLOSED ) {
if (gui_state != MVPMC_STATE_EMULATE) {
fd=open(current, O_RDONLY|O_LARGEFILE);
} else {
fd = open("/tmp/FIFO", O_RDONLY);
}
if (fd < 0) {
printf("Open failed errno %d file %s\n",
errno, current);
video_reopen = 0;
return -1;
}
printf("opened %s\n", current);
} else {
printf("http opened %s\n", current);
}
if (video_reopen == 1) {
av_set_audio_output(AV_AUDIO_MPEG);
fd_audio = av_get_audio_fd();
av_play();
demux_reset(handle);
ts_demux_reset(tshandle);
demux_attr_reset(handle);
demux_seek(handle);
vid_event_discontinuity_possible();
if (gui_state == MVPMC_STATE_EMULATE || http_playing == HTTP_VIDEO_FILE_MPG) {
video_thumbnail(AV_THUMBNAIL_OFF, 0);
} else {
video_thumbnail(AV_THUMBNAIL_EIGTH, 0);
}
av_play();
}
zoomed = 0;
display_on = 0;
seeking = 0;
jumping = 0;
audio_type = 0;
pcm_decoded = 0;
ac3len = 0;
video_reopen = 0;
pthread_cond_broadcast(&video_cond);
printf("write threads released\n");
return 0;
}
