static int cameras_init(void)
{
int i;
CHKRET(cameras_off(1));
for (i=0; i<p.num_cameras; i++) {
switch (p.camera[i].sensor) {
case OV5650:
// FIXME: to do
break;
case AP8140:
mclk(1);
mdelay(2); // min 2400 cycles
camera_on(i, 1);
mdelay(4); // min 5000 cycles
cameras_off(1);
mdelay(2); // min 2400 cycles
mclk(0);
break;
case OV7692:
case OV7739:
case SOC380:
// do nothing for these
break;
default:
printk(KERN_ERR "unsupported sensor type\n");
return -ENODEV;
}
}
return 0;
}
void
GTIMER_FCN(mtimer_arm_rel)
(GTIMER_TRACEID_ mtimer_t *gti, mti_callback_t *callback, void *opaque, int64_t delta)
{
#if ENABLE_GTIMER_CHECK
GTIMER_FCN(mtimer_arm_abs)(id, gti, callback, opaque, mclk() + delta);
#else
mtimer_arm_abs(gti, callback, opaque, mclk() + delta);
#endif
}
static ssize_t nvodmcam_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
#define CMDBUFLEN 100
unsigned char cmdbuf[CMDBUFLEN+1];
int lcount = (count < CMDBUFLEN) ? count : CMDBUFLEN;
int ret = -EFAULT;
mutex_lock(&lock);
if (lcount <= 0) {
goto done;
}
if (copy_from_user(cmdbuf, buf, lcount)) {
printk(KERN_ERR "nvodmcam: failed to copy_from_user\n");
goto done;
}
cmdbuf[lcount] = 0;
if (cmdbuf[lcount-1] == '\n') {
cmdbuf[lcount-1] = 0;
lcount--;
}
printk("nvodmcam: cmd = '%s'\n", cmdbuf);
if (!strcmp(cmdbuf,"on1")) { ret = camera_on(0, 0); }
else
if (!strcmp(cmdbuf,"on2")) { ret = camera_on(1, 0); }
else
if (!strcmp(cmdbuf,"off")) { ret = cameras_off(0); }
else
if (!strcmp(cmdbuf,"mclkon")){ ret = mclk(1); }
else
if (!strcmp(cmdbuf,"mclkoff")){ ret = mclk(0); }
else {
printk(KERN_ERR "nvodmcam: unknown command: %s\n", cmdbuf);
goto done;
}
if (ret) {
printk(KERN_ERR "nvodmcam: camera on failed: %d\n", ret);
} else {
ret = count;
}
done:
mutex_unlock(&lock);
return ret;
}
int
h264_decode_pic_parameter_set(elementary_stream_t *st, bitstream_t *bs)
{
h264_private_t *p;
uint32_t pps_id, sps_id;
if((p = st->es_priv) == NULL) {
p = st->es_priv = calloc(1, sizeof(h264_private_t));
p->start = mclk();
}
pps_id = read_golomb_ue(bs);
if(pps_id >= MAX_PPS_COUNT)
return 0;
sps_id = read_golomb_ue(bs);
if(sps_id >= MAX_SPS_COUNT)
return -1;
if (!p->sps[sps_id].valid)
return -1;
p->pps[pps_id].sps_id = sps_id;
p->pps[pps_id].valid = 1;
return 0;
}
/*
* Read thread
*/
static void *
iptv_file_thread ( void *aux )
{
iptv_mux_t *im = aux;
file_priv_t *fp = im->im_data;
ssize_t r;
int fd = fp->fd, pause = 0;
char buf[32*1024];
off_t off = 0;
int64_t mono;
int e;
#if defined(PLATFORM_DARWIN)
fcntl(fd, F_NOCACHE, 1);
#endif
pthread_mutex_lock(&iptv_lock);
while (!fp->shutdown && fd > 0) {
while (!fp->shutdown && pause) {
mono = mclk() + sec2mono(1);
do {
e = tvh_cond_timedwait(&fp->cond, &iptv_lock, mono);
if (e == ETIMEDOUT)
break;
} while (ERRNO_AGAIN(e));
}
if (fp->shutdown)
break;
pause = 0;
pthread_mutex_unlock(&iptv_lock);
r = read(fd, buf, sizeof(buf));
pthread_mutex_lock(&iptv_lock);
if (r == 0)
break;
if (r < 0) {
if (ERRNO_AGAIN(errno))
continue;
break;
}
sbuf_append(&im->mm_iptv_buffer, buf, r);
if (iptv_input_recv_packets(im, r) == 1)
pause = 1;
#ifndef PLATFORM_DARWIN
#if !ENABLE_ANDROID
posix_fadvise(fd, off, r, POSIX_FADV_DONTNEED);
#endif
#endif
off += r;
}
pthread_mutex_unlock(&iptv_lock);
return NULL;
}
int
tvh_write(int fd, const void *buf, size_t len)
{
int64_t limit = mclk() + sec2mono(25);
ssize_t c;
while (len) {
c = write(fd, buf, len);
if (c < 0) {
if (ERRNO_AGAIN(errno)) {
if (mclk() > limit)
break;
tvh_safe_usleep(100);
continue;
}
break;
}
len -= c;
buf += c;
}
return len ? 1 : 0;
}
static void *
tvhdhomerun_device_discovery_thread( void *aux )
{
struct hdhomerun_discover_device_t result_list[MAX_HDHOMERUN_DEVICES];
int numDevices, brk;
while (tvheadend_is_running()) {
numDevices =
hdhomerun_discover_find_devices_custom(0,
HDHOMERUN_DEVICE_TYPE_TUNER,
HDHOMERUN_DEVICE_ID_WILDCARD,
result_list,
MAX_HDHOMERUN_DEVICES);
if (numDevices > 0) {
while (numDevices > 0 ) {
numDevices--;
struct hdhomerun_discover_device_t* cDev = &result_list[numDevices];
if ( cDev->device_type == HDHOMERUN_DEVICE_TYPE_TUNER ) {
pthread_mutex_lock(&global_lock);
tvhdhomerun_device_t *existing = tvhdhomerun_device_find(cDev->device_id);
if ( tvheadend_is_running() ) {
if ( !existing ) {
tvhinfo(LS_TVHDHOMERUN,"Found HDHomerun device %08x with %d tuners",
cDev->device_id, cDev->tuner_count);
tvhdhomerun_device_create(cDev);
} else if ( ((struct sockaddr_in *)&existing->hd_info.ip_address)->sin_addr.s_addr !=
htonl(cDev->ip_addr) ) {
struct sockaddr_storage detected_dev_addr;
memset(&detected_dev_addr, 0, sizeof(detected_dev_addr));
detected_dev_addr.ss_family = AF_INET;
((struct sockaddr_in *)&detected_dev_addr)->sin_addr.s_addr = htonl(cDev->ip_addr);
char existing_ip[64];
tcp_get_str_from_ip(&existing->hd_info.ip_address, existing_ip, sizeof(existing_ip));
char detected_ip[64];
tcp_get_str_from_ip(&detected_dev_addr, detected_ip, sizeof(detected_ip));
tvhinfo(LS_TVHDHOMERUN,"HDHomerun device %08x switched IPs from %s to %s, updating",
cDev->device_id, existing_ip, detected_ip);
tvhdhomerun_device_destroy(existing);
tvhdhomerun_device_create(cDev);
}
}
pthread_mutex_unlock(&global_lock);
}
}
}
pthread_mutex_lock(&tvhdhomerun_discovery_lock);
brk = 0;
if (tvheadend_is_running()) {
brk = tvh_cond_timedwait(&tvhdhomerun_discovery_cond,
&tvhdhomerun_discovery_lock,
mclk() + sec2mono(15));
brk = !ERRNO_AGAIN(brk) && brk != ETIMEDOUT;
}
pthread_mutex_unlock(&tvhdhomerun_discovery_lock);
if (brk)
break;
}
return NULL;
}
int
h264_decode_slice_header(elementary_stream_t *st, bitstream_t *bs, int *pkttype,
int *isfield)
{
h264_private_t *p;
h264_pps_t *pps;
h264_sps_t *sps;
uint32_t slice_type, pps_id, width, height, v;
uint64_t d;
*pkttype = 0;
*isfield = 0;
if ((p = st->es_priv) == NULL)
return -1;
read_golomb_ue(bs); /* first_mb_in_slice */
slice_type = read_golomb_ue(bs);
if (slice_type > 4)
slice_type -= 5; /* Fixed slice type per frame */
pps_id = read_golomb_ue(bs);
if (pps_id >= MAX_PPS_COUNT)
return -1;
pps = &p->pps[pps_id];
if (!pps->valid)
return -1;
sps = &p->sps[pps->sps_id];
if (!sps->valid)
return -1;
if (!sps->max_frame_num_bits)
return -1;
switch(slice_type) {
case 0:
*pkttype = PKT_P_FRAME;
break;
case 1:
*pkttype = PKT_B_FRAME;
break;
case 2:
*pkttype = PKT_I_FRAME;
break;
default:
return -1;
}
skip_bits(bs, sps->max_frame_num_bits);
if (!sps->mbs_only_flag)
if (read_bits1(bs)) {
skip_bits1(bs); // bottom field
*isfield = 1;
}
d = 0;
if (sps->time_scale)
d = 180000 * (uint64_t)sps->units_in_tick / (uint64_t)sps->time_scale;
if (d == 0 && st->es_frame_duration < 2 && p->start + sec2mono(4) < mclk()) {
tvhwarn("parser", "H264 stream has not timing information, using 30fps");
d = 3000; /* 90000/30 = 3000 : 30fps */
}
#if 0
if (sps->cbpsize)
st->es_vbv_size = sps->cbpsize;
#endif
width = sps->width;
height = sps->height * (2 - sps->mbs_only_flag);
if (width && height && d)
parser_set_stream_vparam(st, width, height, d);
if (sps->aspect_num && sps->aspect_den) {
width *= sps->aspect_num;
height *= sps->aspect_den;
if (width && height) {
v = gcdU32(width, height);
st->es_aspect_num = width / v;
st->es_aspect_den = height / v;
}
} else {
st->es_aspect_num = 0;
st->es_aspect_den = 1;
}
return 0;
}
int
h264_decode_seq_parameter_set(elementary_stream_t *st, bitstream_t *bs)
{
uint32_t profile_idc, level_idc, poc_type;
uint32_t sps_id, tmp, i, width, height;
uint32_t cbpsize, mbs_only_flag, aff;
uint32_t max_frame_num_bits;
uint32_t crop_left, crop_right, crop_top, crop_bottom;
h264_private_t *p;
h264_sps_t *sps;
if ((p = st->es_priv) == NULL) {
p = st->es_priv = calloc(1, sizeof(h264_private_t));
p->start = mclk();
}
profile_idc = read_bits(bs, 8);
skip_bits1(bs); //constraint_set0_flag
skip_bits1(bs); //constraint_set1_flag
skip_bits1(bs); //constraint_set2_flag
skip_bits1(bs); //constraint_set3_flag
skip_bits(bs, 4); // reserved
level_idc = read_bits(bs, 8);
sps_id = read_golomb_ue(bs);
if(sps_id >= MAX_SPS_COUNT)
return -1;
sps = &p->sps[sps_id];
i = 0;
cbpsize = -1;
while (h264_lev2cpbsize[i][0] != -1) {
if (h264_lev2cpbsize[i][0] >= level_idc) {
cbpsize = h264_lev2cpbsize[i][1];
break;
}
i++;
}
if (cbpsize == -1)
return -1;
if (profile_idc >= 100){ //high profile
tmp = read_golomb_ue(bs);
if (tmp == 3) //chroma_format_idc
read_bits1(bs); //residual_color_transform_flag
read_golomb_ue(bs); //bit_depth_luma_minus8
read_golomb_ue(bs); //bit_depth_chroma_minus8
read_bits1(bs); //transform_bypass
if(read_bits1(bs)) {
/* Scaling matrices */
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 16);
decode_scaling_list(bs, 64);
decode_scaling_list(bs, 64);
}
}
max_frame_num_bits = read_golomb_ue(bs) + 4;
poc_type = read_golomb_ue(bs); // pic_order_cnt_type
if(poc_type == 0){
read_golomb_ue(bs);
} else if(poc_type == 1){
skip_bits1(bs);
read_golomb_se(bs);
read_golomb_se(bs);
tmp = read_golomb_ue(bs); /* poc_cycle_length */
for(i = 0; i < tmp; i++)
read_golomb_se(bs);
}else if(poc_type != 2){
/* Illegal poc */
return -1;
}
tmp = read_golomb_ue(bs);
read_bits1(bs);
width = read_golomb_ue(bs) + 1; /* mb width */
height = read_golomb_ue(bs) + 1; /* mb height */
mbs_only_flag = read_bits1(bs);
aff = 0;
if(!mbs_only_flag)
aff = read_bits1(bs);
read_bits1(bs);
/* CROP */
crop_left = crop_right = crop_top = crop_bottom = 0;
if (read_bits1(bs)){
crop_left = read_golomb_ue(bs) * 2;
crop_right = read_golomb_ue(bs) * 2;
crop_top = read_golomb_ue(bs) * 2;
crop_bottom = read_golomb_ue(bs) * 2;
}
if (read_bits1(bs)) /* vui present */
if (decode_vui(sps, bs))
return -1;
sps->max_frame_num_bits = max_frame_num_bits;
sps->mbs_only_flag = mbs_only_flag;
sps->aff = aff;
sps->cbpsize = cbpsize * 125; /* Convert from kbit to bytes */
sps->width = width * 16 - crop_left - crop_right;
sps->height = height * 16 - crop_top - crop_bottom;
sps->valid = 1;
return 0;
}
