svg_status_t _svg_android_set_font_size (void *closure, double size) { svg_android_t *svg_android = closure; DEBUG_ENTRY("set_font_size"); svg_android->state->font_size = size; svg_android->state->font_dirty = 1; DEBUG_EXIT("set_font_size"); return SVG_ANDROID_STATUS_SUCCESS; }
/********************************************************** Required procedure of NDIS NDIS wants to cancel sending of each list which has specified CancelID Can be tested only under NDIS Test ***********************************************************/ VOID ParaNdis6_CancelSendNetBufferLists( NDIS_HANDLE miniportAdapterContext, PVOID pCancelId) { PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)miniportAdapterContext; DEBUG_ENTRY(0); for (UINT i = 0; i < pContext->nPathBundles; i++) { pContext->pPathBundles[i].txPath.CancelNBLs(pCancelId); } }
svg_status_t _svg_android_set_font_style (void *closure, svg_font_style_t font_style) { svg_android_t *svg_android = closure; DEBUG_ENTRY("set_font_style"); svg_android->state->font_style = font_style; svg_android->state->font_dirty = 1; DEBUG_EXIT("set_font_style"); return SVG_ANDROID_STATUS_SUCCESS; }
svg_status_t _svg_android_set_font_weight (void *closure, unsigned int font_weight) { svg_android_t *svg_android = closure; DEBUG_ENTRY("set_font_weight"); svg_android->state->font_weight = font_weight; svg_android->state->font_dirty = 1; DEBUG_EXIT("set_font_weight"); return SVG_ANDROID_STATUS_SUCCESS; }
/********************************************************** callback from asynchronous SEND PAUSE ***********************************************************/ static void OnSendPauseComplete(PARANDIS_ADAPTER *pContext) { NDIS_STATUS status; DEBUG_ENTRY(0); status = ParaNdis6_ReceivePauseRestart(pContext, TRUE, OnReceivePauseComplete); if (status != NDIS_STATUS_PENDING) { // pause exit ParaNdis_DebugHistory(pContext, hopSysPause, NULL, 0, 0, 0); NdisMPauseComplete(pContext->MiniportHandle); } }
svg_status_t _svg_android_render_rect (void *closure, svg_length_t *x_len, svg_length_t *y_len, svg_length_t *width_len, svg_length_t *height_len, svg_length_t *rx_len, svg_length_t *ry_len) { svg_android_t *svg_android = closure; double x, y, width, height, rx, ry; DEBUG_ENTRY("render_rect"); _svg_android_length_to_pixel (svg_android, x_len, &x); _svg_android_length_to_pixel (svg_android, y_len, &y); _svg_android_length_to_pixel (svg_android, width_len, &width); _svg_android_length_to_pixel (svg_android, height_len, &height); _svg_android_length_to_pixel (svg_android, rx_len, &rx); _svg_android_length_to_pixel (svg_android, ry_len, &ry); if (rx > width / 2.0) rx = width / 2.0; if (ry > height / 2.0) ry = height / 2.0; if (rx > 0 || ry > 0) { _svg_android_move_to (svg_android, x + rx, y); _svg_android_line_to (svg_android, x + width - rx, y); _svg_android_arc_to (svg_android, rx, ry, 0, 0, 1, x + width, y + ry); _svg_android_line_to (svg_android, x + width, y + height - ry); _svg_android_arc_to (svg_android, rx, ry, 0, 0, 1, x + width - rx, y + height); _svg_android_line_to (svg_android, x + rx, y + height); _svg_android_arc_to (svg_android, rx, ry, 0, 0, 1, x, y + height - ry); _svg_android_line_to (svg_android, x, y + ry); _svg_android_arc_to (svg_android, rx, ry, 0, 0, 1, x + rx, y); } else { _svg_android_move_to (svg_android, x, y); _svg_android_line_to (svg_android, x + width, y); _svg_android_line_to (svg_android, x + width, y + height); _svg_android_line_to (svg_android, x, y + height); } _svg_android_close_path (svg_android); _svg_android_render_path (svg_android); DEBUG_EXIT("render_rect"); return SVG_ANDROID_STATUS_SUCCESS; }
// // Creates a TCP/IP server by binding to a socket and listening. The // returned data structure can be used to 'tcp_accept' incoming // connections. // tcp_server *tcp_server_create( unsigned int port, unsigned int backlog ) { int n; tcp_server *s; DEBUG_ENTRY( "tcp_server_create()" ) s = malloc( sizeof( tcp_server ) ); if ( s == NULL ) { perror( "malloc" ); DEBUG_EXIT( "tcp_server_create()" ) return NULL; }
void make_measurements(u8 num_double_diffs, const sdiff_t *sdiffs, double *raw_measurements) { DEBUG_ENTRY(); double phase0 = sdiffs[0].carrier_phase; double code0 = sdiffs[0].pseudorange; for (u8 i=0; i<num_double_diffs; i++) { raw_measurements[i] = sdiffs[i+1].carrier_phase - phase0; raw_measurements[i+num_double_diffs] = sdiffs[i+1].pseudorange - code0; } DEBUG_EXIT(); }
svg_status_t _svg_android_end_element (void *closure) { svg_android_t *svg_android = closure; DEBUG_ENTRY("end_element"); _svg_android_pop_state (svg_android); ANDROID_RESTORE(svg_android); DEBUG_EXIT("end_element"); return SVG_ANDROID_STATUS_SUCCESS; }
svg_status_t _svg_android_set_stroke_miter_limit (void *closure, double limit) { svg_android_t *svg_android = closure; DEBUG_ENTRY("set_stroke_miter_limit"); ANDROID_PAINT_SET_MITER_LIMIT(svg_android, limit); svg_android->state->miter_limit = limit; DEBUG_EXIT("set_stroke_miter_limit"); return SVG_ANDROID_STATUS_SUCCESS; }
svg_status_t _svg_android_close_path (void *closure) { svg_android_t *svg_android = closure; DEBUG_ENTRY("close_path"); ANDROID_PATH_CLOSE(svg_android); svg_android->state->last_x = 0.0; // don't know if this is right, really... svg_android->state->last_y = 0.0; DEBUG_EXIT("close_path"); return SVG_ANDROID_STATUS_SUCCESS; }
svg_status_t _svg_android_line_to (void *closure, double x, double y) { svg_android_t *svg_android = closure; DEBUG_ENTRY("line_to"); ANDROID_PATH_LINE_TO(svg_android, x, y); svg_android->state->last_x = x; svg_android->state->last_y = y; DEBUG_EXIT("line_to"); return SVG_ANDROID_STATUS_SUCCESS; }
/* XXX: begin_element could be made more efficient in that no extra group is needed if there is only one element in a group */ svg_status_t _svg_android_begin_element (void *closure) { svg_android_t *svg_android = closure; DEBUG_ENTRY("begin_element"); ANDROID_SAVE(svg_android); _svg_android_push_state (svg_android, NULL); DEBUG_EXIT("begin_element"); return SVG_ANDROID_STATUS_SUCCESS; }
svg_status_t _svg_android_pop_state (svg_android_t *svg_android) { DEBUG_ENTRY("pop_state"); svg_android->state = _svg_android_state_pop (svg_android->state); if (svg_android->state && svg_android->state->saved_canvas) { svg_android->canvas = svg_android->state->saved_canvas; svg_android->state->saved_canvas = NULL; } DEBUG_EXIT("pop_state"); return SVG_STATUS_SUCCESS; }
/* TODO use the set abstraction fnoble is working on. */ static void set_reference_sat(const u8 ref_prn, sats_management_t *sats_management, const u8 num_sdiffs, const sdiff_t *sdiffs, sdiff_t *sdiffs_with_ref_first) { DEBUG_ENTRY(); u8 old_ref = sats_management->prns[0]; log_debug("ref_prn = %u", ref_prn); log_debug("old_ref = %u", old_ref); u8 j; if (old_ref != ref_prn) { j = 1; u8 old_prns[sats_management->num_sats]; memcpy(old_prns, sats_management->prns, sats_management->num_sats * sizeof(u8)); u8 set_old_yet = 0; sats_management->prns[0] = ref_prn; for (u8 i=1; i<sats_management->num_sats; i++) { if (old_prns[i] != ref_prn) { if (old_prns[i]>old_ref && set_old_yet == 0) { sats_management->prns[j] = old_ref; j++; i--; set_old_yet++; } else { sats_management->prns[j] = old_prns[i]; j++; } } } if (set_old_yet == 0) { sats_management->prns[j] = old_ref; set_old_yet++; } assert(set_old_yet == 1); } j=1; for (u8 i=0; i<num_sdiffs; i++) { if (sdiffs[i].prn != ref_prn) { log_debug("prn[%u] = %u", j, sdiffs[i].prn); memcpy(&sdiffs_with_ref_first[j], &sdiffs[i], sizeof(sdiff_t)); j++; } else { log_debug("prn[0] = %u", sdiffs[i].prn); memcpy(&sdiffs_with_ref_first[0], &sdiffs[i], sizeof(sdiff_t)); } } DEBUG_EXIT(); }
svg_status_t _svg_android_render_text (void *closure, svg_length_t *x_len, svg_length_t *y_len, const char *utf8) { svg_android_t *svg_android = closure; double x, y; svg_status_t status; svg_paint_t *fill_paint, *stroke_paint; DEBUG_ENTRY("render_text"); fill_paint = &svg_android->state->fill_paint; stroke_paint = &svg_android->state->stroke_paint; _svg_android_select_font (svg_android); _svg_android_length_to_pixel (svg_android, x_len, &x); _svg_android_length_to_pixel (svg_android, y_len, &y); status = _svg_android_move_to (svg_android, x, y); if (status) return status; ANDROID_TEXT_PATH(svg_android, utf8, x, y); _svg_android_render_path (svg_android); #if 0 // this code doesn't work with renderToArea if (fill_paint->type) { _svg_android_set_paint_and_opacity (svg_android, fill_paint, svg_android->state->fill_opacity, SVG_ANDROID_RENDER_TYPE_FILL); // ANDROID_DRAW_TEXT(svg_android, utf8, 0.0, 0.0); ANDROID_DRAW_TEXT(svg_android, utf8, x, y); } if (stroke_paint->type) { _svg_android_set_paint_and_opacity (svg_android, stroke_paint, svg_android->state->stroke_opacity, SVG_ANDROID_RENDER_TYPE_STROKE); ANDROID_DRAW_TEXT(svg_android, utf8, x, y); } #endif DEBUG_EXIT("render_text"); return SVG_ANDROID_STATUS_SUCCESS; }
/********************************************************** NDIS-required procedure for hardware interrupt registration Parameters: IN PVOID MiniportInterruptContext (actually Adapter context) ***********************************************************/ static VOID MiniportEnableInterruptEx(IN PVOID MiniportInterruptContext) { DEBUG_ENTRY(0); PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportInterruptContext; for (UINT i = 0; i < pContext->nPathBundles; i++) { pContext->pPathBundles[i].txPath.EnableInterrupts(); pContext->pPathBundles[i].rxPath.EnableInterrupts(); } if (pContext->bCXPathCreated) { pContext->CXPath.EnableInterrupts(); } }
/********************************************************** NDIS-required procedure for DPC handling Parameters: PVOID MiniportInterruptContext (Adapter context) ***********************************************************/ static VOID MiniportInterruptDPC( IN NDIS_HANDLE MiniportInterruptContext, IN PVOID MiniportDpcContext, IN PVOID ReceiveThrottleParameters, IN PVOID NdisReserved2 ) { PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportInterruptContext; bool requiresDPCRescheduling; #if NDIS_SUPPORT_NDIS620 PNDIS_RECEIVE_THROTTLE_PARAMETERS RxThrottleParameters = (PNDIS_RECEIVE_THROTTLE_PARAMETERS)ReceiveThrottleParameters; DEBUG_ENTRY(5); RxThrottleParameters->MoreNblsPending = 0; requiresDPCRescheduling = ParaNdis_DPCWorkBody(pContext, RxThrottleParameters->MaxNblsToIndicate); if (requiresDPCRescheduling) { GROUP_AFFINITY Affinity; GetAffinityForCurrentCpu(&Affinity); NdisMQueueDpcEx(pContext->InterruptHandle, 0, &Affinity, MiniportDpcContext); } #else /* NDIS 6.0*/ DEBUG_ENTRY(5); UNREFERENCED_PARAMETER(ReceiveThrottleParameters); requiresDPCRescheduling = ParaNdis_DPCWorkBody(pContext, PARANDIS_UNLIMITED_PACKETS_TO_INDICATE); if (requiresDPCRescheduling) { DPrintf(4, ("[%s] Queued additional DPC for %d\n", __FUNCTION__, requiresDPCRescheduling)); NdisMQueueDpc(pContext->InterruptHandle, 0, 1 << KeGetCurrentProcessorNumber(), MiniportDpcContext); } #endif /* NDIS_SUPPORT_NDIS620 */ UNREFERENCED_PARAMETER(NdisReserved2); }
static void OnResetWorkItem(NDIS_WORK_ITEM * pWorkItem, PVOID Context) { tGeneralWorkItem *pwi = (tGeneralWorkItem *)pWorkItem; PARANDIS_ADAPTER *pContext = pwi->pContext; DEBUG_ENTRY(0); ParaNdis_IndicateConnect(pContext, FALSE, FALSE); ParaNdis_Suspend(pContext); ParaNdis_Resume(pContext); ParaNdis_ReportLinkStatus(pContext); NdisFreeMemory(pwi, 0, 0); ParaNdis_DebugHistory(pContext, hopSysReset, NULL, 0, NDIS_STATUS_SUCCESS, 0); NdisMResetComplete(pContext->MiniportHandle, NDIS_STATUS_SUCCESS, TRUE); }
svg_status_t _svg_android_set_font_family (void *closure, const char *family) { svg_android_t *svg_android = closure; DEBUG_ENTRY("set_font_family"); if (svg_android->state->font_family) free (svg_android->state->font_family); svg_android->state->font_family = strdup (family); svg_android->state->font_dirty = 1; DEBUG_EXIT("set_font_family"); return SVG_ANDROID_STATUS_SUCCESS; }
void measure_b_with_external_ambs(u8 state_dim, const double *state_mean, u8 num_sdiffs, sdiff_t *sdiffs, const double receiver_ecef[3], double *b) { DEBUG_ENTRY(); sdiff_t sdiffs_with_ref_first[num_sdiffs]; /* We require the sats updating has already been done with these sdiffs */ u8 ref_prn = sats_management.prns[0]; copy_sdiffs_put_ref_first(ref_prn, num_sdiffs, sdiffs, sdiffs_with_ref_first); measure_b(state_dim, state_mean, num_sdiffs, sdiffs_with_ref_first, receiver_ecef, b); DEBUG_EXIT(); }
svg_status_t _svg_android_quadratic_curve_to (void *closure, double x1, double y1, double x2, double y2) { svg_android_t *svg_android = closure; DEBUG_ENTRY("quadratic_curve_to"); ANDROID_PATH_QUADRATIC_CURVE_TO(svg_android, x1, y1, x2, y2); svg_android->state->last_x = x2; svg_android->state->last_y = y2; DEBUG_EXIT("quadratic_curve_to"); return SVG_ANDROID_STATUS_SUCCESS; }
void measure_iar_b_with_external_ambs(double *state_mean, u8 num_sdiffs, sdiff_t *sdiffs, double receiver_ecef[3], double *b) { DEBUG_ENTRY(); sdiff_t sdiffs_with_ref_first[num_sdiffs]; match_sdiffs_to_sats_man(&ambiguity_test.sats, num_sdiffs, sdiffs, sdiffs_with_ref_first); measure_b(CLAMP_DIFF(ambiguity_test.sats.num_sats, 1), state_mean, num_sdiffs, sdiffs_with_ref_first, receiver_ecef, b); DEBUG_EXIT(); }
void measure_amb_kf_b(u8 num_sdiffs, sdiff_t *sdiffs, const double receiver_ecef[3], double *b) { DEBUG_ENTRY(); sdiff_t sdiffs_with_ref_first[num_sdiffs]; /* We require the sats updating has already been done with these sdiffs */ gnss_signal_t ref_sid = sats_management.sids[0]; copy_sdiffs_put_ref_first(ref_sid, num_sdiffs, sdiffs, sdiffs_with_ref_first); measure_b( nkf.state_dim, nkf.state_mean, num_sdiffs, sdiffs_with_ref_first, receiver_ecef, b); DEBUG_EXIT(); }
/** A least squares solution for baseline from phases using the KF state. * This uses the current state of the KF and a set of phase observations to * solve for the current baseline. * * \param num_dds_u8 State dimension * \param state_mean KF estimated state mean * \param sdiffs_with_ref_first A list of sdiffs. The first in the list must be * the reference sat of the KF, and the rest must * correspond to the KF's DD amb estimates' sats, * sorted in ascending PRN order. * \param dd_measurements A vector of carrier phases. They must be double * differenced and ordered according to the sdiffs * and KF's sats (which must match each other). * \param ref_ecef The reference position in ECEF frame, for * computing the sat direction vectors. * \param b The output baseline in meters. * \param disable_raim True disables raim check/repair * \param raim_threshold Threshold for raim checks. * \return See lesq_solve_raim() */ s8 least_squares_solve_b_external_ambs(u8 num_dds_u8, const double *state_mean, const sdiff_t *sdiffs_with_ref_first, const double *dd_measurements, const double ref_ecef[3], double b[3], bool disable_raim, double raim_threshold) { DEBUG_ENTRY(); integer num_dds = num_dds_u8; double DE[num_dds * 3]; assign_de_mtx(num_dds+1, sdiffs_with_ref_first, ref_ecef, DE); s8 code = lesq_solve_raim(num_dds_u8, dd_measurements, state_mean, DE, b, disable_raim, raim_threshold, 0, 0, 0); DEBUG_EXIT(); return code; }
/********************************************************** NDIS-required procedure for hardware interrupt registration Parameters: IN PVOID MiniportInterruptContext (actually Adapter context) ***********************************************************/ static VOID MiniportDisableInterruptEx(IN PVOID MiniportInterruptContext) { DEBUG_ENTRY(0); PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportInterruptContext; /* TODO - make sure that interrups are not reenabled by the DPC callback*/ for (UINT i = 0; i < pContext->nPathBundles; i++) { pContext->pPathBundles[i].txPath.DisableInterrupts(); pContext->pPathBundles[i].rxPath.DisableInterrupts(); } if (pContext->bCXPathCreated) { pContext->CXPath.DisableInterrupts(); } }
void init_sats_management(sats_management_t *sats_management, const u8 num_sdiffs, const sdiff_t *sdiffs, sdiff_t *sdiffs_with_ref_first) { DEBUG_ENTRY(); if (num_sdiffs == 0) { sats_management->num_sats = 0; DEBUG_EXIT(); return; } u8 ref_prn = choose_reference_sat(num_sdiffs, sdiffs); set_reference_sat_and_prns(ref_prn, sats_management, num_sdiffs, sdiffs, sdiffs_with_ref_first); DEBUG_EXIT(); }
static NDIS_STATUS ParaNdis6_AddDevice(IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE MiniportDriverContext) { NDIS_MINIPORT_ADAPTER_ATTRIBUTES MiniportAttributes; NDIS_STATUS status; UNREFERENCED_PARAMETER(MiniportDriverContext); DEBUG_ENTRY(0); MiniportAttributes.AddDeviceRegistrationAttributes.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_ADD_DEVICE_REGISTRATION_ATTRIBUTES; MiniportAttributes.AddDeviceRegistrationAttributes.Header.Revision = NDIS_MINIPORT_ADD_DEVICE_REGISTRATION_ATTRIBUTES_REVISION_1; MiniportAttributes.AddDeviceRegistrationAttributes.Header.Size = NDIS_SIZEOF_MINIPORT_ADD_DEVICE_REGISTRATION_ATTRIBUTES_REVISION_1; MiniportAttributes.AddDeviceRegistrationAttributes.MiniportAddDeviceContext = MiniportAdapterHandle; MiniportAttributes.AddDeviceRegistrationAttributes.Flags = 0; status = NdisMSetMiniportAttributes(MiniportAdapterHandle, &MiniportAttributes); return status; }
svg_status_t _svg_android_curve_to (void *closure, double x1, double y1, double x2, double y2, double x3, double y3) { svg_android_t *svg_android = closure; DEBUG_ENTRY("curve_to"); ANDROID_PATH_CURVE_TO(svg_android, x1, y1, x2, y2, x3, y3); svg_android->state->last_x = x3; svg_android->state->last_y = y3; DEBUG_EXIT("curve_to"); return SVG_ANDROID_STATUS_SUCCESS; }
//assumes both sets are ordered static u8 intersect_sats(const u8 num_sats1, const u8 num_sdiffs, const u8 *sats1, const sdiff_t *sdiffs, sdiff_t *intersection_sats) { DEBUG_ENTRY(); u8 i, j, n = 0; if(DEBUG) { printf("sdiff prns= {"); for (u8 k=0; k< num_sdiffs; k++) { printf("%u, ", sdiffs[k].prn); } printf("}\n"); printf("sats= {"); for (u8 k=0; k< num_sats1; k++) { printf("%u, ", sats1[k]); } printf("}\n"); printf("(n, i, prn1[i],\t j, prn2[j])\n"); } /* Loop over sats1 and sdffs and check if a PRN is present in both. */ for (i=0, j=0; i<num_sats1 && j<num_sdiffs; i++, j++) { if (sats1[i] < sdiffs[j].prn) { log_debug("(%u, %u, prn1=%u,\t %u, prn2=%u)\t\t prn1 < prn2 i++", n, i, sats1[i], j, sdiffs[j].prn); j--; } else if (sats1[i] > sdiffs[j].prn) { log_debug("(%u, %u, prn1=%u,\t %u, prn2=%u)\t\t prn1 > prn2 j++", n, i, sats1[i], j, sdiffs[j].prn); i--; } else { log_debug("(%u, %u, prn1=%u,\t %u, prn2=%u)\t\t prn1 = prn2 i,j,n++", n, i, sats1[i], j, sdiffs[j].prn); memcpy(&intersection_sats[n], &sdiffs[j], sizeof(sdiff_t)); n++; } } if (DEBUG) { printf("intersection_sats= {"); for (u8 k=0; k< n; k++) { printf("%u, ", intersection_sats[k].prn); } printf("}\n"); } DEBUG_EXIT(); return n; }