bool protocol_send(uint16_t address, uint16_t command, sent_cb_t* cb) { // gpiote0 (toggles gpio) NRF_GPIOTE->POWER = GPIOTE_POWER_POWER_Enabled << GPIOTE_POWER_POWER_Pos; nrf_gpiote_task_config(0, context.led_pin, NRF_GPIOTE_POLARITY_TOGGLE, NRF_GPIOTE_INITIAL_VALUE_LOW); if (context.state != PROTOCOL_STATE_IDLE) { return false; } context.state = PROTOCOL_STATE_PREAMBLE_DONE; context.address = address; context.command = command; context.cb = cb; NRF_POWER->TASKS_CONSTLAT = 1; // PAN 11 "HFCLK: Base current with HFCLK running is too high" NRF_RTC1->TASKS_STOP = 1; NRF_RTC1->TASKS_CLEAR = 1; NRF_RTC1->PRESCALER = ROUNDED_DIV(LFCLK_FREQUENCY, ROUNDED_DIV(1000000, context.protocol->preamble.leader + context.protocol->preamble.pause - RTC_TASK_JITTER )) - 1; NRF_RTC1->CC[0] = 1; NRF_RTC1->TASKS_START = 1; pulse(ROUNDED_DIV(context.protocol->preamble.leader, context.protocol->pulse_width)); return true; }
int16_t timer_start(int16_t id, uint32_t us) { uint32_t ticks; if (id < 0) return -EINVAL; if (!timers[id].enabled) return -EINVAL; if (timers[id].active) return -EALREADY; ticks = ROUNDED_DIV((uint64_t)us * HFCLK, TIMER_SECONDS(1) * ROUNDED_DIV(2 << TIMER_PRESCALER, 2)); timers[id].active = 1; timers[id].ticks = ticks; update_cc(id, (uint64_t) ticks); if (active == 0) { NRF_TIMER0->TASKS_START = 1UL; } active++; return 0; }
static void adx_encode(ADXContext *c, uint8_t *adx, const int16_t *wav, ADXChannelState *prev, int channels) { PutBitContext pb; int scale; int i, j; int s0, s1, s2, d; int max = 0; int min = 0; s1 = prev->s1; s2 = prev->s2; for (i = 0, j = 0; j < 32; i += channels, j++) { s0 = wav[i]; d = ((s0 << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS; if (max < d) max = d; if (min > d) min = d; s2 = s1; s1 = s0; } if (max == 0 && min == 0) { prev->s1 = s1; prev->s2 = s2; memset(adx, 0, BLOCK_SIZE); return; } if (max / 7 > -min / 8) scale = max / 7; else scale = -min / 8; if (scale == 0) scale = 1; AV_WB16(adx, scale); init_put_bits(&pb, adx + 2, 16); s1 = prev->s1; s2 = prev->s2; for (i = 0, j = 0; j < 32; i += channels, j++) { d = ((wav[i] << COEFF_BITS) - c->coeff[0] * s1 - c->coeff[1] * s2) >> COEFF_BITS; d = av_clip(ROUNDED_DIV(d, scale), -8, 7); put_sbits(&pb, 4, d); s0 = ((d << COEFF_BITS) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS; s2 = s1; s1 = s0; } prev->s1 = s1; prev->s2 = s2; flush_put_bits(&pb); }
/* * Setup the systick timer to generate the tick interrupts at the required * frequency. */ void vPortSetupTimerInterrupt( void ) { /* Set interrupt priority */ NVIC_SetPriority(SysTick_IRQn, configKERNEL_INTERRUPT_PRIORITY); /* Configure SysTick to interrupt at the requested rate. */ SysTick->LOAD = ROUNDED_DIV(configSYSTICK_CLOCK_HZ, configTICK_RATE_HZ) - 1UL; SysTick->CTRL = ( portNVIC_SYSTICK_CLK_BIT | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk ); }
void protocol_init(struct ir_protocol *protocol, uint8_t led_pin, struct rtc_ctx *c) { ctx = c; context.protocol = protocol; context.led_pin = led_pin; // low freq clock NRF_CLOCK->LFCLKSRC = (CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos); NRF_CLOCK->EVENTS_LFCLKSTARTED = 0; NRF_CLOCK->TASKS_LFCLKSTART = 1; while (NRF_CLOCK->EVENTS_LFCLKSTARTED == 0) /* NOTHING */; NRF_CLOCK->EVENTS_LFCLKSTARTED = 0; // rtc1 interrupt sd_nvic_ClearPendingIRQ(RTC1_IRQn); sd_nvic_SetPriority(RTC1_IRQn, NRF_APP_PRIORITY_LOW); sd_nvic_EnableIRQ(RTC1_IRQn); NRF_RTC1->EVTENSET = RTC_EVTENSET_COMPARE0_Msk; NRF_RTC1->INTENSET = RTC_INTENSET_COMPARE0_Msk; // high freq clock sd_clock_hfclk_request(); // timer1 NRF_TIMER1->TASKS_STOP = 1; NRF_TIMER1->TASKS_CLEAR = 1; NRF_TIMER1->PRESCALER = 4; NRF_TIMER1->MODE = TIMER_MODE_MODE_Timer; NRF_TIMER1->BITMODE = TIMER_BITMODE_BITMODE_16Bit; NRF_TIMER1->SHORTS = TIMER_SHORTS_COMPARE2_CLEAR_Msk; NRF_TIMER1->CC[0] = 1; NRF_TIMER1->CC[1] = ROUNDED_DIV(context.protocol->pulse_width, 3); NRF_TIMER1->CC[2] = context.protocol->pulse_width; // timer2 (counter) NRF_TIMER2->TASKS_STOP = 1; NRF_TIMER2->TASKS_CLEAR = 1; NRF_TIMER2->MODE = TIMER_MODE_MODE_Counter; NRF_TIMER2->BITMODE = TIMER_BITMODE_BITMODE_16Bit; NRF_TIMER2->TASKS_START = 1; NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Msk; // gpio (led) nrf_gpio_cfg_output(led_pin); // ppi's sd_ppi_channel_assign(0, &NRF_TIMER1->EVENTS_COMPARE[0], &NRF_GPIOTE->TASKS_OUT[0]); // toggle led sd_ppi_channel_assign(1, &NRF_TIMER1->EVENTS_COMPARE[1], &NRF_GPIOTE->TASKS_OUT[0]); // toggle led sd_ppi_channel_assign(2, &NRF_TIMER1->EVENTS_COMPARE[2], &NRF_TIMER2->TASKS_COUNT); // inc timer2 sd_ppi_channel_assign(3, &NRF_TIMER2->EVENTS_COMPARE[0], &NRF_TIMER1->TASKS_STOP); // stops timer1 after timer2 reaches N sd_ppi_channel_enable_set(PPI_CHEN_CH0_Msk | PPI_CHEN_CH1_Msk | PPI_CHEN_CH2_Msk | PPI_CHEN_CH3_Msk); }
static inline void vect_division(int *res, int *vect, int div, int dim) { int i; if (div > 1) for (i=0; i<dim; i++) res[i] = ROUNDED_DIV(vect[i],div); else if (res != vect) memcpy(res, vect, dim*sizeof(int)); }
/**@brief Function for initializing the RTC1 counter. * * @param[in] prescaler Value of the RTC1 PRESCALER register. Set to 0 for no prescaling. */ static void rtc1_init(uint32_t prescaler) { NRF_RTC1->PRESCALER = prescaler; NVIC_SetPriority(RTC1_IRQn, RTC1_IRQ_PRI); //Dhavaltest // Set the CC[1] register to the frequency of the counter, so the COMPARE[1] event will be triggered every second NRF_RTC1->CC[1] = (uint32_t)ROUNDED_DIV((uint64_t)APP_TIMER_CLOCK_FREQ, ((prescaler) + 1)); //Dhaval test }
/** * This routine will precompute the combined DCT matrix with qscale * and DCT renorm needed by the MPEG encoder here. It is basically the * same as the routine with the same name in mpegvideo.c, except for * some coefficient changes. The matrix will be computed in two variations, * depending on the DCT version used. The second used by the MMX version of DCT. * * \param s MpegEncContext pointer * \param qmat[OUT] pointer to where the matrix is stored * \param qmat16[OUT] pointer to where matrix for MMX is stored. * This matrix is not permutated * and second 64 entries are bias * \param quant_matrix[IN] the quantizion matrix to use * \param bias bias for the quantizer * \param qmin minimum qscale value to set up for * \param qmax maximum qscale value to set up for * * Only rows between qmin and qmax will be populated in the matrix. * In this MJPEG encoder, only the value 8 for qscale is used. */ static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax) { int qscale; for(qscale = qmin; qscale <= qmax; qscale++) { int i; if (s->dsp.fdct == ff_jpeg_fdct_islow_8) { for (i = 0; i < 64; i++) { const int j = s->dsp.idct_permutation[i]; /* 16 <= qscale * quant_matrix[i] <= 7905 * 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 * (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) * >= (1<<36)/249205026 * 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT-3))/ (qscale*quant_matrix[j])); } } else if (s->dsp.fdct == ff_fdct_ifast) { for (i = 0; i < 64; i++) { const int j = s->dsp.idct_permutation[i]; /* 16 <= qscale * quant_matrix[i] <= 7905 * 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 * (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) * >= (1<<36)/249205026 * 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */ qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11))/(aanscales[i] *qscale * quant_matrix[j])); } } else { for (i = 0; i < 64; i++) { const int j = s->dsp.idct_permutation[i]; /* We can safely assume that 16 <= quant_matrix[i] <= 255 * So 16 <= qscale * quant_matrix[i] <= 7905 * so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 * so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 */ qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT_MMX) / (qscale *quant_matrix[j])); qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /(qscale * quant_matrix[j]); if (qmat16[qscale][0][i] == 0 || qmat16[qscale][0][i] == 128*256) qmat16[qscale][0][i]=128*256-1; qmat16[qscale][1][i]=ROUNDED_DIV(bias <<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); } } } }
uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context) { if ((timeout_ticks < APP_TIMER_MIN_TIMEOUT_TICKS)) { return NRF_ERROR_INVALID_PARAM; } uint32_t timeout_ms = ((uint32_t)ROUNDED_DIV(timeout_ticks * 1000 * (app_timer_control.prescaler + 1), (uint32_t)APP_TIMER_CLOCK_FREQ)); app_timer_info_t * p_timer_info = (app_timer_info_t *)timer_id; if (rt_id2obj((void *)p_timer_info->id) == NULL) return NRF_ERROR_INVALID_PARAM; // Pass p_context to timer_timeout_handler ((os_timer_cb *)(p_timer_info->id))->arg = p_context; if (((os_timer_cb *)(p_timer_info->id))->state == osTimerRunning) { return NRF_SUCCESS; } // osTimerStart() returns osErrorISR if it is called in interrupt routine. switch (osTimerStart((osTimerId)p_timer_info->id, timeout_ms) ) { case osOK: return NRF_SUCCESS; case osErrorISR: break; case osErrorParameter: return NRF_ERROR_INVALID_PARAM; default: return NRF_ERROR_INVALID_PARAM; } // Start timer without svcCall switch (svcTimerStart((osTimerId)p_timer_info->id, timeout_ms)) { case osOK: return NRF_SUCCESS; case osErrorISR: return NRF_ERROR_INVALID_STATE; case osErrorParameter: return NRF_ERROR_INVALID_PARAM; default: return NRF_ERROR_INVALID_PARAM; } }
uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context) { app_timer_info_t * pinfo = (app_timer_info_t*)(timer_id); TimerHandle_t hTimer = pinfo->osHandle; uint32_t rtc_prescaler = portNRF_RTC_REG->PRESCALER + 1; /* Get back the microseconds to wait */ uint32_t timeout_corrected = ROUNDED_DIV(timeout_ticks * m_prescaler, rtc_prescaler); if (hTimer == NULL) { return NRF_ERROR_INVALID_STATE; } if (pinfo->active && (xTimerIsTimerActive(hTimer) != pdFALSE)) { // Timer already running - exit silently return NRF_SUCCESS; } pinfo->argument = p_context; if (__get_IPSR() != 0) { BaseType_t yieldReq = pdFALSE; if (xTimerChangePeriodFromISR(hTimer, timeout_corrected, &yieldReq) != pdPASS) { return NRF_ERROR_NO_MEM; } if ( xTimerStartFromISR(hTimer, &yieldReq) != pdPASS ) { return NRF_ERROR_NO_MEM; } portYIELD_FROM_ISR(yieldReq); } else { if (xTimerChangePeriod(hTimer, timeout_corrected, APP_TIMER_WAIT_FOR_QUEUE) != pdPASS) { return NRF_ERROR_NO_MEM; } if (xTimerStart(hTimer, APP_TIMER_WAIT_FOR_QUEUE) != pdPASS) { return NRF_ERROR_NO_MEM; } } pinfo->active = true; return NRF_SUCCESS; }
void ant_sdm_simulator_one_iteration(ant_sdm_simulator_t * p_simulator) { if (p_simulator->_cb.auto_change) { UNUSED_PARAMETER(sensorsim_measure(&(p_simulator->_cb.sensorsim_state), &(p_simulator->_cb.sensorsim_cfg))); } p_simulator->_cb.time += SIMULATOR_TIME_INCREMENT; p_simulator->_cb.stride_incr += p_simulator->_cb.sensorsim_state.current_val * SIMULATOR_TIME_INCREMENT; p_simulator->p_profile->SDM_PROFILE_strides += p_simulator->_cb.stride_incr / SIMULATOR_STRIDE_UNIT_REVERSAL; p_simulator->_cb.stride_incr = p_simulator->_cb.stride_incr % SIMULATOR_STRIDE_UNIT_REVERSAL; uint32_t distance = value_rescale( p_simulator->p_profile->SDM_PROFILE_strides * p_simulator->_cb.stride_length, SIMULATOR_STRIDE_LENGTH_UNIT_REVERSAL, ANT_SDM_DISTANCE_UNIT_REVERSAL); if (p_simulator->p_profile->SDM_PROFILE_capabilities.cadency_is_valid) { p_simulator->p_profile->SDM_PROFILE_cadence = p_simulator->_cb.sensorsim_state.current_val; } if (p_simulator->p_profile->SDM_PROFILE_capabilities.speed_is_valid) { p_simulator->p_profile->SDM_PROFILE_speed = value_rescale( p_simulator->_cb.sensorsim_state.current_val * p_simulator->_cb.stride_length, ANT_SDM_CADENCE_UNIT_REVERSAL * SIMULATOR_STRIDE_LENGTH_UNIT_REVERSAL * SEC_PER_MIN, ANT_SDM_SPEED_UNIT_REVERSAL); } if (p_simulator->p_profile->SDM_PROFILE_capabilities.distance_is_valid) { p_simulator->p_profile->SDM_PROFILE_distance = distance; } if (p_simulator->p_profile->SDM_PROFILE_capabilities.calorie_is_valid) { p_simulator->p_profile->SDM_PROFILE_calories = value_rescale(distance, SIMULATOR_BURN_RATE_UNIT * ANT_SDM_DISTANCE_UNIT_REVERSAL, p_simulator->_cb.burn_rate); } if (p_simulator->p_profile->SDM_PROFILE_capabilities.time_is_valid) { p_simulator->p_profile->SDM_PROFILE_time = value_rescale(p_simulator->_cb.time, SIMULATOR_TIME_UNIT_REVERSAL, ANT_SDM_TIME_UNIT_REVERSAL); } if (p_simulator->p_profile->SDM_PROFILE_capabilities.latency_is_valid) { p_simulator->p_profile->SDM_PROFILE_update_latency = ROUNDED_DIV(((uint64_t)p_simulator->_cb.stride_incr * ANT_SDM_UPDATE_LATENCY_UNIT_REVERSAL), (uint64_t)SIMULATOR_TIME_UNIT_REVERSAL * p_simulator->_cb.sensorsim_state.current_val); } }
/** * Apply a simple delogo algorithm to the image in src and put the * result in dst. * * The algorithm is only applied to the region specified by the logo * parameters. * * @param w width of the input image * @param h height of the input image * @param logo_x x coordinate of the top left corner of the logo region * @param logo_y y coordinate of the top left corner of the logo region * @param logo_w width of the logo * @param logo_h height of the logo * @param band the size of the band around the processed area * @param show show a rectangle around the processed area, useful for * parameters tweaking * @param direct if non-zero perform in-place processing */ static void apply_delogo(uint8_t *dst, int dst_linesize, uint8_t *src, int src_linesize, int w, int h, AVRational sar, int logo_x, int logo_y, int logo_w, int logo_h, unsigned int band, int show, int direct) { int x, y; uint64_t interp, weightl, weightr, weightt, weightb, weight; uint8_t *xdst, *xsrc; uint8_t *topleft, *botleft, *topright; unsigned int left_sample, right_sample; int xclipl, xclipr, yclipt, yclipb; int logo_x1, logo_x2, logo_y1, logo_y2; xclipl = FFMAX(-logo_x, 0); xclipr = FFMAX(logo_x+logo_w-w, 0); yclipt = FFMAX(-logo_y, 0); yclipb = FFMAX(logo_y+logo_h-h, 0); logo_x1 = logo_x + xclipl; logo_x2 = logo_x + logo_w - xclipr - 1; logo_y1 = logo_y + yclipt; logo_y2 = logo_y + logo_h - yclipb - 1; topleft = src+logo_y1 * src_linesize+logo_x1; topright = src+logo_y1 * src_linesize+logo_x2; botleft = src+logo_y2 * src_linesize+logo_x1; if (!direct) av_image_copy_plane(dst, dst_linesize, src, src_linesize, w, h); dst += (logo_y1 + 1) * dst_linesize; src += (logo_y1 + 1) * src_linesize; for (y = logo_y1+1; y < logo_y2; y++) { left_sample = topleft[src_linesize*(y-logo_y1)] + topleft[src_linesize*(y-logo_y1-1)] + topleft[src_linesize*(y-logo_y1+1)]; right_sample = topright[src_linesize*(y-logo_y1)] + topright[src_linesize*(y-logo_y1-1)] + topright[src_linesize*(y-logo_y1+1)]; for (x = logo_x1+1, xdst = dst+logo_x1+1, xsrc = src+logo_x1+1; x < logo_x2; x++, xdst++, xsrc++) { if (show && (y == logo_y1+1 || y == logo_y2-1 || x == logo_x1+1 || x == logo_x2-1)) { *xdst = 0; continue; } /* Weighted interpolation based on relative distances, taking SAR into account */ weightl = (uint64_t) (logo_x2-x) * (y-logo_y1) * (logo_y2-y) * sar.den; weightr = (uint64_t)(x-logo_x1) * (y-logo_y1) * (logo_y2-y) * sar.den; weightt = (uint64_t)(x-logo_x1) * (logo_x2-x) * (logo_y2-y) * sar.num; weightb = (uint64_t)(x-logo_x1) * (logo_x2-x) * (y-logo_y1) * sar.num; interp = left_sample * weightl + right_sample * weightr + (topleft[x-logo_x1] + topleft[x-logo_x1-1] + topleft[x-logo_x1+1]) * weightt + (botleft[x-logo_x1] + botleft[x-logo_x1-1] + botleft[x-logo_x1+1]) * weightb; weight = (weightl + weightr + weightt + weightb) * 3U; interp = ROUNDED_DIV(interp, weight); if (y >= logo_y+band && y < logo_y+logo_h-band && x >= logo_x+band && x < logo_x+logo_w-band) { *xdst = interp; } else { unsigned dist = 0; if (x < logo_x+band) dist = FFMAX(dist, logo_x-x+band); else if (x >= logo_x+logo_w-band) dist = FFMAX(dist, x-(logo_x+logo_w-1-band)); if (y < logo_y+band) dist = FFMAX(dist, logo_y-y+band); else if (y >= logo_y+logo_h-band) dist = FFMAX(dist, y-(logo_y+logo_h-1-band)); *xdst = (*xsrc*dist + interp*(band-dist))/band; } } dst += dst_linesize; src += src_linesize; } }
uint64_t common_rtc_64bit_us_get(void) { uint32_t ticks = common_rtc_32bit_ticks_get(); // [ticks -> microseconds] return ROUNDED_DIV(((uint64_t)ticks) * 1000000, RTC_INPUT_FREQ); }
/** * Return the optimal value (0 or 1) for the ac_pred element for the given MB in mpeg4. * This function will also update s->block_last_index and s->ac_val. * @param[in,out] block MB coefficients, these will be updated if 1 is returned * @param[in] dir ac prediction direction for each 8x8 block * @param[out] st scantable for each 8x8 block * @param[out] zigzag_last_index index refering to the last non zero coefficient in zigzag order */ static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6]) { int score= 0; int i, n; int8_t * const qscale_table = s->current_picture.f.qscale_table; memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); for(n=0; n<6; n++){ int16_t *ac_val, *ac_val1; score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); ac_val = s->ac_val[0][0] + s->block_index[n] * 16; ac_val1= ac_val; if(dir[n]){ const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; /* top prediction */ ac_val-= s->block_wrap[n]*16; if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ /* same qscale */ for(i=1; i<8; i++){ const int level= block[n][s->dsp.idct_permutation[i ]]; block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; ac_val1[i+8]= level; } }else{ /* different qscale, we must rescale */ for(i=1; i<8; i++){ const int level= block[n][s->dsp.idct_permutation[i ]]; block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; ac_val1[i+8]= level; } } st[n]= s->intra_h_scantable.permutated; }else{ const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; /* left prediction */ ac_val-= 16; if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ /* same qscale */ for(i=1; i<8; i++){ const int level= block[n][s->dsp.idct_permutation[i<<3]]; block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; ac_val1[i ]= level; ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; } }else{ /* different qscale, we must rescale */ for(i=1; i<8; i++){ const int level= block[n][s->dsp.idct_permutation[i<<3]]; block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); ac_val1[i ]= level; ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; } } st[n]= s->intra_v_scantable.permutated; } for(i=63; i>0; i--) //FIXME optimize if(block[n][ st[n][i] ]) break; s->block_last_index[n]= i; score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); } if(score < 0){ return 1; }else{ restore_ac_coeffs(s, block, dir, st, zigzag_last_index); return 0; } }
static void FN(inter_pred)(AVCodecContext *ctx) { static const uint8_t bwlog_tab[2][N_BS_SIZES] = { { 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 }, { 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4 }, }; VP9Context *s = ctx->priv_data; VP9Block *b = s->b; int row = s->row, col = s->col; ThreadFrame *tref1 = &s->refs[s->refidx[b->ref[0]]], *tref2; AVFrame *ref1 = tref1->f, *ref2; int w1 = ref1->width, h1 = ref1->height, w2, h2; ptrdiff_t ls_y = s->y_stride, ls_uv = s->uv_stride; if (b->comp) { tref2 = &s->refs[s->refidx[b->ref[1]]]; ref2 = tref2->f; w2 = ref2->width; h2 = ref2->height; } // y inter pred if (b->bs > BS_8x8) { if (b->bs == BS_8x4) { mc_luma_dir(s, mc[3][b->filter][0], s->dst[0], ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, col << 3, &b->mv[0][0], 8, 4, w1, h1, 0); mc_luma_dir(s, mc[3][b->filter][0], s->dst[0] + 4 * ls_y, ls_y, ref1->data[0], ref1->linesize[0], tref1, (row << 3) + 4, col << 3, &b->mv[2][0], 8, 4, w1, h1, 0); if (b->comp) { mc_luma_dir(s, mc[3][b->filter][1], s->dst[0], ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, col << 3, &b->mv[0][1], 8, 4, w2, h2, 1); mc_luma_dir(s, mc[3][b->filter][1], s->dst[0] + 4 * ls_y, ls_y, ref2->data[0], ref2->linesize[0], tref2, (row << 3) + 4, col << 3, &b->mv[2][1], 8, 4, w2, h2, 1); } } else if (b->bs == BS_4x8) { mc_luma_dir(s, mc[4][b->filter][0], s->dst[0], ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, col << 3, &b->mv[0][0], 4, 8, w1, h1, 0); mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4, ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, (col << 3) + 4, &b->mv[1][0], 4, 8, w1, h1, 0); if (b->comp) { mc_luma_dir(s, mc[4][b->filter][1], s->dst[0], ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, col << 3, &b->mv[0][1], 4, 8, w2, h2, 1); mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4, ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, (col << 3) + 4, &b->mv[1][1], 4, 8, w2, h2, 1); } } else { av_assert2(b->bs == BS_4x4); // FIXME if two horizontally adjacent blocks have the same MV, // do a w8 instead of a w4 call mc_luma_dir(s, mc[4][b->filter][0], s->dst[0], ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, col << 3, &b->mv[0][0], 4, 4, w1, h1, 0); mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4, ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, (col << 3) + 4, &b->mv[1][0], 4, 4, w1, h1, 0); mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4 * ls_y, ls_y, ref1->data[0], ref1->linesize[0], tref1, (row << 3) + 4, col << 3, &b->mv[2][0], 4, 4, w1, h1, 0); mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4 * ls_y + 4, ls_y, ref1->data[0], ref1->linesize[0], tref1, (row << 3) + 4, (col << 3) + 4, &b->mv[3][0], 4, 4, w1, h1, 0); if (b->comp) { mc_luma_dir(s, mc[4][b->filter][1], s->dst[0], ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, col << 3, &b->mv[0][1], 4, 4, w2, h2, 1); mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4, ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, (col << 3) + 4, &b->mv[1][1], 4, 4, w2, h2, 1); mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4 * ls_y, ls_y, ref2->data[0], ref2->linesize[0], tref2, (row << 3) + 4, col << 3, &b->mv[2][1], 4, 4, w2, h2, 1); mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4 * ls_y + 4, ls_y, ref2->data[0], ref2->linesize[0], tref2, (row << 3) + 4, (col << 3) + 4, &b->mv[3][1], 4, 4, w2, h2, 1); } } } else { int bwl = bwlog_tab[0][b->bs]; int bw = bwh_tab[0][b->bs][0] * 4, bh = bwh_tab[0][b->bs][1] * 4; mc_luma_dir(s, mc[bwl][b->filter][0], s->dst[0], ls_y, ref1->data[0], ref1->linesize[0], tref1, row << 3, col << 3, &b->mv[0][0],bw, bh, w1, h1, 0); if (b->comp) mc_luma_dir(s, mc[bwl][b->filter][1], s->dst[0], ls_y, ref2->data[0], ref2->linesize[0], tref2, row << 3, col << 3, &b->mv[0][1], bw, bh, w2, h2, 1); } // uv inter pred { int bwl = bwlog_tab[1][b->bs]; int bw = bwh_tab[1][b->bs][0] * 4, bh = bwh_tab[1][b->bs][1] * 4; VP56mv mvuv; w1 = (w1 + 1) >> 1; h1 = (h1 + 1) >> 1; if (b->comp) { w2 = (w2 + 1) >> 1; h2 = (h2 + 1) >> 1; } if (b->bs > BS_8x8) { mvuv.x = ROUNDED_DIV(b->mv[0][0].x + b->mv[1][0].x + b->mv[2][0].x + b->mv[3][0].x, 4); mvuv.y = ROUNDED_DIV(b->mv[0][0].y + b->mv[1][0].y + b->mv[2][0].y + b->mv[3][0].y, 4); } else { mvuv = b->mv[0][0]; } mc_chroma_dir(s, mc[bwl][b->filter][0], s->dst[1], s->dst[2], ls_uv, ref1->data[1], ref1->linesize[1], ref1->data[2], ref1->linesize[2], tref1, row << 2, col << 2, &mvuv, bw, bh, w1, h1, 0); if (b->comp) { if (b->bs > BS_8x8) { mvuv.x = ROUNDED_DIV(b->mv[0][1].x + b->mv[1][1].x + b->mv[2][1].x + b->mv[3][1].x, 4); mvuv.y = ROUNDED_DIV(b->mv[0][1].y + b->mv[1][1].y + b->mv[2][1].y + b->mv[3][1].y, 4); } else { mvuv = b->mv[0][1]; } mc_chroma_dir(s, mc[bwl][b->filter][1], s->dst[1], s->dst[2], ls_uv, ref2->data[1], ref2->linesize[1], ref2->data[2], ref2->linesize[2], tref2, row << 2, col << 2, &mvuv, bw, bh, w2, h2, 1); } }
/** * Initialize the table_rV, table_gU[i], table_gV, and table_bU fields * in SwsContext * * @param inv_table the YUV -> RGB table (this is a line of Inverse_Table_6_9) * @param fullRange 0->MPEG YUV space 1->JPEG YUV space */ int yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation) { int i; static uint8_t ytable[1024]; int64_t cy, oy; int64_t crv, cbu, cgu, cgv; int entry_size = 0; uint8_t *table_r, *table_g, *table_b; int value; if ((inv_table[0] == 0) || (inv_table[1] == 0) || (inv_table[2] == 0) || (inv_table[3] == 0)) { MSG_ERR("Invalid YUV ---> RGB table!\n"); return -1; } crv = inv_table[0]; cbu = inv_table[1]; cgu = inv_table[2]; cgv = inv_table[3]; if (fullRange) { cy = 1 << 16; oy = 0; crv= (crv*224) / 255; cbu= (cbu*224) / 255; cgu= (cgu*224) / 255; cgv= (cgv*224) / 255; //FIXME maybe its cleaner if the tables where based on full range (*244/255) } else { cy = ((1 << 16) * 255) / 219; oy= 16 << 16; } cy = (cy *contrast )>>16; crv= (crv*contrast * saturation)>>32; cbu= (cbu*contrast * saturation)>>32; cgu= (cgu*contrast * saturation)>>32; cgv= (cgv*contrast * saturation)>>32; oy -= 256*brightness; for (i = 0; i < 1024; i++) { value = (cy*(((i - YTABLE_MIN)<<16) - oy) + (1<<31))>>32; ytable[i] = av_clip_uint8(value); } entry_size = get_entry_size(fmt_depth(c->dstFormat)); av_free(c->yuvTable); c->yuvTable = allocate_tables(&table_r, &table_g, &table_b, fmt_depth(c->dstFormat)); if (c->yuvTable == NULL) { return -1; } switch (fmt_depth(c->dstFormat)) { case 32: for (i = -198; i < 256 + 197; i++) { value = ytable[i + YTABLE_MIN]; if (isBGR(c->dstFormat)) { value <<= 16; } ((uint32_t *)table_r)[i] = value; } for (i = -133; i < 256 + 132; i++) { ((uint32_t *)table_g)[i] = ytable[i + YTABLE_MIN] << 8; } for (i = -233; i < 256 + 232; i++) { value = ytable[i + YTABLE_MIN]; if (!isBGR(c->dstFormat)) { value <<= 16; } ((uint32_t *)table_b)[i] = value; } break; case 24: for (i = -233; i < 256 + 232; i++) { ((uint8_t * )table_b)[i] = ytable[i + YTABLE_MIN]; } break; case 15: case 16: for (i = -198; i < 256 + 197; i++) { value = ytable[i + YTABLE_MIN] >> 3; if (isBGR(c->dstFormat)) { value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10); } ((uint16_t *)table_r)[i] = value; } for (i = -133; i < 256 + 132; i++) { value = ytable[i + YTABLE_MIN]; value >>= ((fmt_depth(c->dstFormat) == 16) ? 2 : 3); ((uint16_t *)table_g)[i] = value << 5; } for (i = -233; i < 256 + 232; i++) { value = ytable[i + YTABLE_MIN] >> 3; if (!isBGR(c->dstFormat)) { value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10); } ((uint16_t *)table_b)[i] = value; } break; case 8: for (i = -198; i < 256 + 197; i++) { value = (ytable[i + YTABLE_MIN - 16] + 18) / 36; if (isBGR(c->dstFormat)) { value <<= 5; } ((uint8_t *)table_r)[i] = value; } for (i = -133; i < 256 + 132; i++) { value = (ytable[i + YTABLE_MIN - 16] + 18) / 36; if (!isBGR(c->dstFormat)) { value <<= 1; } ((uint8_t *)table_g)[i] = value << 2; } for (i = -233; i < 256 + 232; i++) { value = (ytable[i + YTABLE_MIN - 37] + 43) / 85; if (!isBGR(c->dstFormat)) { value <<= 6; } ((uint8_t *)table_b)[i] = value; } break; case 4: for (i = -198; i < 256 + 197; i++) { value = ytable[i + YTABLE_MIN - 110] >> 7; if (isBGR(c->dstFormat)) { value <<= 3; } ((uint8_t *)table_r)[i] = value; } for (i = -133; i < 256 + 132; i++) { value = (ytable[i + YTABLE_MIN - 37]+ 43) / 85; ((uint8_t *)table_g)[i] = value << 1; } for (i = -233; i < 256 + 232; i++) { value = ytable[i + YTABLE_MIN - 110] >> 7; if (!isBGR(c->dstFormat)) { value <<= 3; } ((uint8_t *)table_b)[i] = value; } break; case 1: for (i = 0; i < 256 + 256; i++) { value = ytable[i + YTABLE_MIN - 110] >> 7; ((uint8_t *)table_g)[i] = value; } break; default: MSG_ERR("%ibpp not supported by yuv2rgb\n", fmt_depth(c->dstFormat)); av_free(c->yuvTable); c->yuvTable = NULL; return -1; } for (i = 0; i < 256; i++) { c->table_rV[i] = table_r + entry_size * ROUNDED_DIV(crv * (i - 128), 76309); c->table_gU[i] = table_g + entry_size * ROUNDED_DIV(cgu * (i - 128), 76309); c->table_gV[i] = entry_size * ROUNDED_DIV(cgv * (i - 128), 76309); c->table_bU[i] = table_b + entry_size * ROUNDED_DIV(cbu * (i - 128), 76309); } return 0; }
void RTC1_IRQHandler(void) { if (NRF_RTC1->EVENTS_COMPARE[3] != 0) { // prepare the comparator for the next interval NRF_RTC1->CC[3] += ctx->rtc_x[3].period; // clear the event CC_x NRF_RTC1->EVENTS_COMPARE[3] = 0; //call the registered callback ctx->rtc_x[3].cb(ctx); } if (NRF_RTC1->EVENTS_COMPARE[0] == 0) return; NRF_RTC1->EVENTS_COMPARE[0] = 0; switch (context.state) { case PROTOCOL_STATE_IDLE: /* should not happen */ break; case PROTOCOL_STATE_PREAMBLE_DONE: NRF_RTC1->TASKS_STOP = 1; NRF_RTC1->PRESCALER = ROUNDED_DIV(LFCLK_FREQUENCY, context.protocol->tick_freq) - 1; context.state = PROTOCOL_STATE_ADDRESS; context.bit_position = 0; NRF_RTC1->TASKS_START = 1; /* FALLTHROUGH */ case PROTOCOL_STATE_ADDRESS: clock_bit_position(context.address); if (++context.bit_position == context.protocol->address.length) { context.bit_position = 0; if (context.protocol->address.send_complement) { if (context.invert == 0) { context.invert = 1; } else { context.invert = 0; context.state = PROTOCOL_STATE_COMMAND; } } else { context.state = PROTOCOL_STATE_COMMAND; } } break; case PROTOCOL_STATE_COMMAND: clock_bit_position(context.command); if (++context.bit_position == context.protocol->command.length) { context.bit_position = 0; if (context.protocol->command.send_complement) { if (context.invert == 0) { context.invert = 1; } else { context.invert = 0; context.state = PROTOCOL_STATE_LAST_BIT; } } else { context.state = PROTOCOL_STATE_LAST_BIT; } } break; case PROTOCOL_STATE_LAST_BIT: clock_bit_position(context.command); context.state = PROTOCOL_STATE_END; break; case PROTOCOL_STATE_END: // turn off GPIOTE to avoid overconsumption bug (PAN39) NRF_GPIOTE->POWER = GPIOTE_POWER_POWER_Disabled << GPIOTE_POWER_POWER_Pos; NRF_RTC1->TASKS_STOP = 1; NRF_RTC1->TASKS_CLEAR = 1; NRF_POWER->TASKS_LOWPWR = 1; // PAN 11 "HFCLK: Base current with HFCLK running is too high" context.state = PROTOCOL_STATE_IDLE; if (context.cb) { context.cb(context.address, context.command); } break; } }
static int grabber_ffmpeg_properties_get (grabber_ffmpeg_t *ffmpeg, AVFormatContext *ctx, file_data_t *data) { int res; unsigned int i; unsigned int audio_streams = 0, video_streams = 0, sub_streams = 0; res = avformat_find_stream_info (ctx, NULL); if (res < 0) { vh_log (VALHALLA_MSG_VERBOSE, "FFmpeg can't find stream info: %s", data->file.path); return -1; } /* * The duration is in microsecond. We save in millisecond in order to * have the same unit as libplayer. */ if (data->file.type != VALHALLA_FILE_TYPE_IMAGE && ctx->duration) vh_grabber_parse_int64 (data, ROUNDED_DIV (ctx->duration, 1000), VALHALLA_METADATA_DURATION, ffmpeg->pl); for (i = 0; i < ctx->nb_streams; i++) { float value; const char *name; AVStream *st = ctx->streams[i]; AVCodecParameters *codec = st->codecpar; switch (codec->codec_type) { case AVMEDIA_TYPE_AUDIO: audio_streams++; name = grabber_ffmpeg_codec_name (codec->codec_id); if (name) vh_metadata_add_auto (&data->meta_grabber, VALHALLA_METADATA_AUDIO_CODEC, name, VALHALLA_LANG_UNDEF, ffmpeg->pl); vh_grabber_parse_int (data, codec->channels, VALHALLA_METADATA_AUDIO_CHANNELS, ffmpeg->pl); if (codec->bit_rate) vh_grabber_parse_int (data, codec->bit_rate, VALHALLA_METADATA_AUDIO_BITRATE, ffmpeg->pl); break; case AVMEDIA_TYPE_VIDEO: /* Common part (image + video) */ video_streams++; name = grabber_ffmpeg_codec_name (codec->codec_id); if (name) vh_metadata_add_auto (&data->meta_grabber, VALHALLA_METADATA_VIDEO_CODEC, name, VALHALLA_LANG_UNDEF, ffmpeg->pl); vh_grabber_parse_int (data, codec->width, VALHALLA_METADATA_WIDTH, ffmpeg->pl); vh_grabber_parse_int (data, codec->height, VALHALLA_METADATA_HEIGHT, ffmpeg->pl); /* Only for video */ if (data->file.type == VALHALLA_FILE_TYPE_IMAGE) break; if (codec->bit_rate) vh_grabber_parse_int (data, codec->bit_rate, VALHALLA_METADATA_VIDEO_BITRATE, ffmpeg->pl); if (st->sample_aspect_ratio.num) value = codec->width * st->sample_aspect_ratio.num / (float) (codec->height * st->sample_aspect_ratio.den); else value = codec->width * codec->sample_aspect_ratio.num / (float) (codec->height * codec->sample_aspect_ratio.den); /* * Save in integer with a ratio of 10000 like the constant * PLAYER_VIDEO_ASPECT_RATIO_MULT with libplayer (player.h). */ vh_grabber_parse_int (data, (int) (value * 10000.0), VALHALLA_METADATA_VIDEO_ASPECT, ffmpeg->pl); break; case AVMEDIA_TYPE_SUBTITLE: sub_streams++; break; default: break; } } if (audio_streams) vh_grabber_parse_int (data, audio_streams, VALHALLA_METADATA_AUDIO_STREAMS, ffmpeg->pl); if (video_streams) vh_grabber_parse_int (data, video_streams, VALHALLA_METADATA_VIDEO_STREAMS, ffmpeg->pl); if (sub_streams) vh_grabber_parse_int (data, sub_streams, VALHALLA_METADATA_SUB_STREAMS, ffmpeg->pl); return 0; }