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; }