static int filter_frame(AVFilterLink *inlink, AVFrame *buf) { AVFilterContext *ctx = inlink->dst; MixContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; int i, ret = 0; for (i = 0; i < ctx->nb_inputs; i++) if (ctx->inputs[i] == inlink) break; if (i >= ctx->nb_inputs) { av_log(ctx, AV_LOG_ERROR, "unknown input link\n"); ret = AVERROR(EINVAL); goto fail; } if (i == 0) { int64_t pts = av_rescale_q(buf->pts, inlink->time_base, outlink->time_base); ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts); if (ret < 0) goto fail; } ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data, buf->nb_samples); av_frame_free(&buf); return output_frame(outlink); fail: av_frame_free(&buf); return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; MixContext *s = ctx->priv; int ret; int wanted_samples; ret = calc_active_inputs(s); if (ret < 0) return ret; if (!(s->input_state[0] & INPUT_ON)) return request_samples(ctx, 1); if (s->frame_list->nb_frames == 0) { ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF) { s->input_state[0] = 0; if (s->nb_inputs == 1) return AVERROR_EOF; return output_frame(ctx->outputs[0]); } return ret; } av_assert0(s->frame_list->nb_frames > 0); wanted_samples = frame_list_next_frame_size(s->frame_list); return request_samples(ctx, wanted_samples); }
/** * Requests a frame, if needed, from each input link other than the first. */ static int request_samples(AVFilterContext *ctx, int min_samples) { MixContext *s = ctx->priv; int i, ret; av_assert0(s->nb_inputs > 1); for (i = 1; i < s->nb_inputs; i++) { ret = 0; if (!(s->input_state[i] & INPUT_ON)) continue; if (av_audio_fifo_size(s->fifos[i]) >= min_samples) continue; ret = ff_request_frame(ctx->inputs[i]); if (ret == AVERROR_EOF) { s->input_state[i] |= INPUT_EOF; if (av_audio_fifo_size(s->fifos[i]) == 0) { s->input_state[i] = 0; continue; } } else if (ret < 0) return ret; } return output_frame(ctx->outputs[0]); }
static int fmt(uintptr_t pc, int sig, void *userdata) { fmt_userdata_t *u = userdata; diag_backtrace_param_t *p = u->p; diag_output_t *o = u->o; int rc; Dl_info dlip = {0}; #ifdef BROKEN_SIGNAL_UCONTEXT_T if (u->skips) { --u->skips; return 0; } #endif rc = dladdr1((void *)pc, &dlip, NULL, 0); if (rc != 0) { char buf[128]; char addr_buf[20]; char offset_buf[20]; const char *module_path = dlip.dli_fname; const char *module = NULL; const char *function = dlip.dli_sname; module = module_path; if (module) { module = strrchr(module_path, '/'); if (module) { module += 1; } } add_int(addr_buf, addr_buf + sizeof addr_buf - 1, (long long)pc, 16); add_int(offset_buf, offset_buf + sizeof offset_buf - 1, (long long)((char *)pc - (char *)dlip.dli_saddr), 16); output_frame(buf, buf + sizeof buf - 1, p->backtrace_fields, module_path, module, function, offset_buf, addr_buf); if (o->output_mode == DIAG_CALL_FN) { o->output_fn(o->user_data, buf); } else { write(o->outfile, buf, strlen(buf)); write(o->outfile, "\n", 1); } } else { /* printf("dladdr1 failed, errno %d\n", errno); */ } ++u->cur; return u->cur >= u->count; }
/** * Requests a frame, if needed, from each input link other than the first. */ static int request_samples(AVFilterContext *ctx, int min_samples) { MixContext *s = ctx->priv; int i; av_assert0(s->nb_inputs > 1); for (i = 1; i < s->nb_inputs; i++) { if (!(s->input_state[i] & INPUT_ON) || (s->input_state[i] & INPUT_EOF)) continue; if (av_audio_fifo_size(s->fifos[i]) >= min_samples) continue; ff_inlink_request_frame(ctx->inputs[i]); } return output_frame(ctx->outputs[0]); }
static void format_frameinfo(const char *s, unsigned int fields, char *buf, size_t buf_size) { char *outch = buf; char *lastoutch = buf + buf_size - 1; const char *module_path = NULL; /* not implemented */ const char *module, *address, *function, *offset; /* skip over frame number to find module */ module = s; while (!isspace(*module)) { ++module; } while (isspace(*module)) { ++module; } /* find address */ address = strstr(module, "0x"); /* find function */ function = address; if (function) { while (!isspace(*function)) { ++function; } while (isspace(*function)) { ++function; } } /* find offset */ offset = function; if (offset) { offset = strstr(function, " + "); if (offset) { offset += 3; } } output_frame(outch, lastoutch, fields, module_path, module, function, offset, address); }
void *obs_video_thread(void *param) { uint64_t last_time = 0; while (video_output_wait(obs->video.video)) { uint64_t cur_time = video_gettime(obs->video.video); tick_sources(cur_time, &last_time); render_displays(); output_frame(cur_time); } UNUSED_PARAMETER(param); return NULL; }
/* 0x400ba7 <_init+807> at /usr/home/trawick/myhg/apache/mod/diag/testdiag */ static void format_frameinfo(const char *s, unsigned int fields, char *buf, size_t buf_size) { char *outch = buf; char *lastoutch = buf + buf_size - 1; const char *module_path, *module, *address, *function, *offset; address = s; function = address; function = strchr(function, '<'); if (function) { function += 1; } offset = function; if (offset) { offset = strchr(offset, '+'); if (offset) { offset += 1; } } module_path = offset; if (module_path) { module_path = strstr(module_path, " at "); if (module_path) { module_path += 4; } } module = module_path; if (module) { module = strrchr(module, '/'); if (module) { module += 1; } } output_frame(outch, lastoutch, fields, module_path, module, function, offset, address); }
void *obs_video_thread(void *param) { uint64_t last_time = 0; uint64_t cur_time = os_gettime_ns(); uint64_t interval = video_output_get_frame_time(obs->video.video); os_set_thread_name("libobs: graphics thread"); while (!video_output_stopped(obs->video.video)) { last_time = tick_sources(cur_time, last_time); render_displays(); output_frame(&cur_time, interval); } UNUSED_PARAMETER(param); return NULL; }
void *obs_video_thread(void *param) { uint64_t last_time = 0; uint64_t interval = video_output_get_frame_time(obs->video.video); obs->video.video_time = os_gettime_ns(); os_set_thread_name("libobs: graphics thread"); const char *video_thread_name = profile_store_name(obs_get_profiler_name_store(), "obs_video_thread(%g ms)", interval / 1000000.); profile_register_root(video_thread_name, interval); while (!video_output_stopped(obs->video.video)) { profile_start(video_thread_name); profile_start(tick_sources_name); last_time = tick_sources(obs->video.video_time, last_time); profile_end(tick_sources_name); profile_start(render_displays_name); render_displays(); profile_end(render_displays_name); profile_start(output_frame_name); output_frame(); profile_end(output_frame_name); profile_end(video_thread_name); profile_reenable_thread(); video_sleep(&obs->video, &obs->video.video_time, interval); } UNUSED_PARAMETER(param); return NULL; }
// 'slot' callback emitted from the timer timing out. // Takes next frame, feeds it into the tracker, and displays // the results on our Qt window. void Tracker::nextFrame() { // load frame. cv::Mat3b frame = getFrame(); if (!frame.data) { return; } cv::Mat gray(frame); cv::cvtColor(frame, gray, CV_BGR2GRAY); if (frame_number % 20 == 0) { detectAndSeedTrackers(gray); } cv::Mat3b output_frame(frame.rows, frame.cols); frame.copyTo(output_frame); trackFrame(gray, output_frame); updateGUI(frame, output_frame); frame_number++; }
int main(int argc, char **argv) { int i = 0, j = 0, addr = 0;; int count = 10000; unsigned char frame[192] = {0}; unsigned long delay; if (argc > 1) { delay = strtoul(argv[1], NULL, 0); } else { delay = 0; } srand(time(NULL)); for (;;) { if (count > 2000) { count = 0; srand(time(NULL)); for (i = 0; i < 48; i++) { for (j = 0; j < 24; j++) { alive[0][i][j] = rand()%2; neighbor_counts[0][i][j] = rand()%9; } } } count++; if (!(count % 2)) step_sim(); for (addr = 13; addr <= 30; addr++) { for (i = 0; i < 64; i++) { int xpos = FIRST_X(addr) + (i%8); int ypos = FIRST_Y(addr) + (i/8); int is_alive = alive[current_frame][xpos][ypos]; int was_alive = alive[(1 - current_frame)][xpos][ypos]; if (count % 2) { frame[i] = 0; frame[i+64] = 0; frame[i+128] = (is_alive) ? 0xF : 0; } else if (is_alive) { if (was_alive) { // blue frame[i] = 0; frame[64+i] = 0; frame[128+i] = 0xF; } else { // green frame[i] = 0xF; frame[64+i] = 0; frame[128+i] = 0; } } else { if (was_alive) { // red frame[i] = 0; frame[64+i] = 0xF; frame[128+i] = 0; } else { // black frame[i] = 0; frame[64+i] = 0; frame[128+i] = 0; } } } output_frame(addr, frame); } usleep(delay); } }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; MixContext *s = ctx->priv; int ret; int wanted_samples, available_samples; ret = calc_active_inputs(s); if (ret < 0) return ret; if (s->input_state[0] == INPUT_OFF) { ret = request_samples(ctx, 1); if (ret < 0) return ret; ret = calc_active_inputs(s); if (ret < 0) return ret; available_samples = get_available_samples(s); if (!available_samples) return AVERROR(EAGAIN); return output_frame(outlink, available_samples); } if (s->frame_list->nb_frames == 0) { ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF) { s->input_state[0] = INPUT_OFF; if (s->nb_inputs == 1) return AVERROR_EOF; else return AVERROR(EAGAIN); } else if (ret < 0) return ret; } av_assert0(s->frame_list->nb_frames > 0); wanted_samples = frame_list_next_frame_size(s->frame_list); if (s->active_inputs > 1) { ret = request_samples(ctx, wanted_samples); if (ret < 0) return ret; ret = calc_active_inputs(s); if (ret < 0) return ret; } if (s->active_inputs > 1) { available_samples = get_available_samples(s); if (!available_samples) return AVERROR(EAGAIN); available_samples = FFMIN(available_samples, wanted_samples); } else { available_samples = wanted_samples; } s->next_pts = frame_list_next_pts(s->frame_list); frame_list_remove_samples(s->frame_list, available_samples); return output_frame(outlink, available_samples); }
/* ./testdiag(diag_backtrace+0x75)[0x401824] */ static void format_frameinfo(const char *s, unsigned int fields, char *buf, size_t buf_size) { size_t s_len = strlen(s); char *outch = buf; char *lastoutch = buf + buf_size - 1; const char *lastslash, *firstparen, *firstbracket; const char *module_path, *module, *function, *offset, *address; lastslash = strrchr(s, '/'); firstparen = strchr(s, '('); firstbracket = strchr(s, '['); if (!lastslash || !firstbracket) { /* format of string not recognized; just copy and get out */ if (s_len < buf_size) { strcpy(buf, s); } else { memcpy(buf, s, buf_size - 1); buf[buf_size - 1] = 0; } return; } module_path = s; module = lastslash; if (module) { module += 1; } function = firstparen; if (function) { function += 1; if (*function == ')' || *function == '+') { /* here's one such scenario: * "/home/trawick/inst/24-64/modules/mod_backtrace.so(+0x2b6c) [0x7f2727df4b6c]" */ function = NULL; } } offset = function; if (offset) { offset = strchr(function, '+'); if (offset) { offset += 1; } } address = firstbracket; if (address) { address += 1; } output_frame(outch, lastoutch, fields, module_path, module, function, offset, address); }
void *obs_graphics_thread(void *param) { uint64_t last_time = 0; uint64_t interval = video_output_get_frame_time(obs->video.video); uint64_t frame_time_total_ns = 0; uint64_t fps_total_ns = 0; uint32_t fps_total_frames = 0; obs->video.video_time = os_gettime_ns(); os_set_thread_name("libobs: graphics thread"); const char *video_thread_name = profile_store_name(obs_get_profiler_name_store(), "obs_graphics_thread(%g"NBSP"ms)", interval / 1000000.); profile_register_root(video_thread_name, interval); srand((unsigned int)time(NULL)); while (!video_output_stopped(obs->video.video)) { uint64_t frame_start = os_gettime_ns(); uint64_t frame_time_ns; profile_start(video_thread_name); profile_start(tick_sources_name); last_time = tick_sources(obs->video.video_time, last_time); profile_end(tick_sources_name); profile_start(render_displays_name); render_displays(); profile_end(render_displays_name); profile_start(output_frame_name); output_frame(); profile_end(output_frame_name); frame_time_ns = os_gettime_ns() - frame_start; profile_end(video_thread_name); profile_reenable_thread(); video_sleep(&obs->video, &obs->video.video_time, interval); frame_time_total_ns += frame_time_ns; fps_total_ns += (obs->video.video_time - last_time); fps_total_frames++; if (fps_total_ns >= 1000000000ULL) { obs->video.video_fps = (double)fps_total_frames / ((double)fps_total_ns / 1000000000.0); obs->video.video_avg_frame_time_ns = frame_time_total_ns / (uint64_t)fps_total_frames; frame_time_total_ns = 0; fps_total_ns = 0; fps_total_frames = 0; } } UNUSED_PARAMETER(param); return NULL; }
void View::output(string x) { if (x == "") { std::cout << "View: " << name << endl; } else { std::cout << "View: " << x << endl; } vector<int> longestEachCol; //pre-process int columnsSize = (int)columns.size(); int i = 0; int row = 0; bool finish = false; while (i < columnsSize) { longestEachCol.push_back(columns[i].name.size()); i++; } while (!finish) { i = 0; finish = true; while (i < columnsSize) { if (row < columns[i].spans.size()) { finish = false; int span_length = columns[i].spans[row].to - columns[i].spans[row].from; stringstream stream; string string_temp; stream << columns[i].spans[row].from; stream << columns[i].spans[row].to; string_temp = stream.str(); span_length += string_temp.length(); span_length += 6; if (span_length > longestEachCol[i]) { longestEachCol[i] = span_length; } } i++; } row++; } output_frame(columnsSize, longestEachCol); //output name i = 0; std::cout << "|"; while (i < columnsSize) { std::cout << " " << columns[i].name; int j = 0; while (j < longestEachCol[i] - columns[i].name.size()-1) { std::cout << " "; j++; } std::cout << "|"; i++; } std::cout << endl; output_frame(columnsSize, longestEachCol); i = 0; finish = false; row = 0; int rowSize; if (columnsSize > 0) { rowSize = (int)columns[0].spans.size(); } while (row < rowSize) { i = 0; std::cout << "|"; finish = true; while (i < columnsSize) { if (row < columns[i].spans.size()) { stringstream stream_from; stringstream stream_to; string string_temp; stream_from << columns[i].spans[row].from; stream_to << columns[i].spans[row].to; string temp_span = " " + columns[i].spans[row].value + ":(" + stream_from.str() + "," + stream_to.str() +")"; std::cout << temp_span; int j = 0; while (j < longestEachCol[i] - temp_span.size()) { std::cout << " "; j++; } } std::cout << "|"; i++; } row++; std::cout << endl; } output_frame(columnsSize, longestEachCol); std::cout << rowSize << " rows in set" << endl << endl; }
static int activate(AVFilterContext *ctx) { AVFilterLink *outlink = ctx->outputs[0]; MixContext *s = ctx->priv; AVFrame *buf = NULL; int i, ret; for (i = 0; i < s->nb_inputs; i++) { AVFilterLink *inlink = ctx->inputs[i]; if ((ret = ff_inlink_consume_frame(ctx->inputs[i], &buf)) > 0) { if (i == 0) { int64_t pts = av_rescale_q(buf->pts, inlink->time_base, outlink->time_base); ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts); if (ret < 0) { av_frame_free(&buf); return ret; } } ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data, buf->nb_samples); if (ret < 0) { av_frame_free(&buf); return ret; } av_frame_free(&buf); ret = output_frame(outlink); if (ret < 0) return ret; } } for (i = 0; i < s->nb_inputs; i++) { int64_t pts; int status; if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) { if (status == AVERROR_EOF) { if (i == 0) { s->input_state[i] = 0; if (s->nb_inputs == 1) { ff_outlink_set_status(outlink, status, pts); return 0; } } else { s->input_state[i] |= INPUT_EOF; if (av_audio_fifo_size(s->fifos[i]) == 0) { s->input_state[i] = 0; } } } } } if (calc_active_inputs(s)) { ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts); return 0; } if (ff_outlink_frame_wanted(outlink)) { int wanted_samples; if (!(s->input_state[0] & INPUT_ON)) return request_samples(ctx, 1); if (s->frame_list->nb_frames == 0) { ff_inlink_request_frame(ctx->inputs[0]); return 0; } av_assert0(s->frame_list->nb_frames > 0); wanted_samples = frame_list_next_frame_size(s->frame_list); return request_samples(ctx, wanted_samples); } return 0; }
int diag_backtrace(diag_output_t *o, diag_backtrace_param_t *p, diag_context_t *c) { char frame[128]; char addr_buf[20]; char offset_buf[20]; char name_buf[80]; char *name; const char *module_path, *module; int count, cur, rc; unw_context_t ctx; unw_cursor_t csr; unw_word_t ip, offp; #if DIAG_PLATFORM_LINUX || DIAG_PLATFORM_FREEBSD || DIAG_PLATFORM_MACOSX Dl_info info; #endif if (p->backtrace_count && p->backtrace_count < DIAG_BT_LIMIT) { count = p->backtrace_count; } else { count = DIAG_BT_LIMIT; } rc = unw_getcontext(&ctx); if (!rc) { rc = unw_init_local(&csr, &ctx); } if (rc) { return DIAG_ERR_INIT; } cur = 0; while ((rc = unw_step(&csr)) > 0) { cur++; if (cur > count) { break; } unw_get_reg(&csr, UNW_REG_IP, &ip); if (!ip) { break; } add_int(addr_buf, addr_buf + sizeof addr_buf - 1, ip, 16); rc = unw_get_proc_name(&csr, name_buf, sizeof name_buf, &offp); if (rc && rc != UNW_ENOMEM) { name = NULL; } else { name = name_buf; } module = module_path = NULL; #if DIAG_PLATFORM_LINUX || DIAG_PLATFORM_FREEBSD || DIAG_PLATFORM_MACOSX if (p->backtrace_fields & (DIAG_BTFIELDS_MODULE_PATH | DIAG_BTFIELDS_MODULE_NAME)) { if ((rc = dladdr((void *)ip, &info)) != 0) { module_path = info.dli_fname; module = strrchr(module_path, '/'); if (module) { module += 1; } } } #endif add_int(offset_buf, offset_buf + sizeof offset_buf - 1, offp, 16); output_frame(frame, frame + sizeof frame - 1, p->backtrace_fields, module_path, module, name, offset_buf, addr_buf); if (o->output_mode == DIAG_CALL_FN) { o->output_fn(o->user_data, frame); } else { write(o->outfile, frame, strlen(frame)); write(o->outfile, "\n", 1); } } return 0; }
void *obs_graphics_thread(void *param) { uint64_t last_time = 0; uint64_t interval = video_output_get_frame_time(obs->video.video); uint64_t frame_time_total_ns = 0; uint64_t fps_total_ns = 0; uint32_t fps_total_frames = 0; bool gpu_was_active = false; bool raw_was_active = false; bool was_active = false; obs->video.video_time = os_gettime_ns(); os_set_thread_name("libobs: graphics thread"); const char *video_thread_name = profile_store_name(obs_get_profiler_name_store(), "obs_graphics_thread(%g"NBSP"ms)", interval / 1000000.); profile_register_root(video_thread_name, interval); srand((unsigned int)time(NULL)); while (!video_output_stopped(obs->video.video)) { uint64_t frame_start = os_gettime_ns(); uint64_t frame_time_ns; bool raw_active = obs->video.raw_active > 0; #ifdef _WIN32 bool gpu_active = obs->video.gpu_encoder_active > 0; #else const bool gpu_active = 0; #endif bool active = raw_active || gpu_active; if (!was_active && active) clear_base_frame_data(); if (!raw_was_active && raw_active) clear_raw_frame_data(); #ifdef _WIN32 if (!gpu_was_active && gpu_active) clear_gpu_frame_data(); #endif raw_was_active = raw_active; gpu_was_active = gpu_active; was_active = active; profile_start(video_thread_name); profile_start(tick_sources_name); last_time = tick_sources(obs->video.video_time, last_time); profile_end(tick_sources_name); profile_start(output_frame_name); output_frame(raw_active, gpu_active); profile_end(output_frame_name); profile_start(render_displays_name); render_displays(); profile_end(render_displays_name); frame_time_ns = os_gettime_ns() - frame_start; profile_end(video_thread_name); profile_reenable_thread(); video_sleep(&obs->video, raw_active, gpu_active, &obs->video.video_time, interval); frame_time_total_ns += frame_time_ns; fps_total_ns += (obs->video.video_time - last_time); fps_total_frames++; if (fps_total_ns >= 1000000000ULL) { obs->video.video_fps = (double)fps_total_frames / ((double)fps_total_ns / 1000000000.0); obs->video.video_avg_frame_time_ns = frame_time_total_ns / (uint64_t)fps_total_frames; frame_time_total_ns = 0; fps_total_ns = 0; fps_total_frames = 0; } } UNUSED_PARAMETER(param); return NULL; }
int diag_backtrace(diag_output_t *o, diag_backtrace_param_t *p, diag_context_t *c) { int cur = 0, count; STACKFRAME64 stackframe; CONTEXT context; HANDLE process = GetCurrentProcess(); HANDLE thread = GetCurrentThread(); DWORD bytes_written; if (c) { context = *c->context; } else { RtlCaptureContext(&context); } if (p->backtrace_count && p->backtrace_count < DIAG_BT_LIMIT) { count = p->backtrace_count; } else { count = DIAG_BT_LIMIT; } memset(&stackframe, 0, sizeof stackframe); stackframe.AddrPC.Mode = stackframe.AddrFrame.Mode = stackframe.AddrStack.Mode = AddrModeFlat; #ifdef DIAG_BITS_64 stackframe.AddrPC.Offset = context.Rip; stackframe.AddrFrame.Offset = context.Rbp; stackframe.AddrStack.Offset = context.Rsp; #else stackframe.AddrPC.Offset = context.Eip; stackframe.AddrFrame.Offset = context.Ebp; stackframe.AddrStack.Offset = context.Esp; #endif if (!p->symbols_initialized) { SymInitialize(process, NULL, TRUE); } while (StackWalk64( #ifdef DIAG_BITS_64 IMAGE_FILE_MACHINE_AMD64, #else IMAGE_FILE_MACHINE_I386, #endif process, thread, &stackframe, &context, NULL, /* ReadMemoryRoutine */ SymFunctionTableAccess64, /* FunctionTableAccessRoutine */ SymGetModuleBase64, /* GetModuleBaseRoutine */ NULL) /* TranslateAddress */ == TRUE) { char symbol_buffer[128] = {0}; IMAGEHLP_SYMBOL64 *symbol = (IMAGEHLP_SYMBOL64 *)&symbol_buffer; DWORD64 ignored; const char *function; const char *offset; char address_buf[20], offset_buf[20]; char buf[128]; char *outch = buf; char *lastoutch = buf + sizeof buf - 1; if (cur + 1 > count) { /* avoid loop on corrupted chain, respect caller's wishes */ break; } symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64); symbol->MaxNameLength = sizeof(symbol_buffer) - sizeof(IMAGEHLP_SYMBOL64); ignored = 0; if (SymGetSymFromAddr64(process, stackframe.AddrPC.Offset, &ignored, symbol) != TRUE) { function = NULL; offset = NULL; } else { function = symbol->Name; add_int(offset_buf, offset_buf + sizeof offset_buf - 1, stackframe.AddrPC.Offset - symbol->Address, 16); offset = offset_buf; } add_int(address_buf, address_buf + sizeof address_buf - 1, stackframe.AddrPC.Offset, 16); if (function && !strcmp(function, "diag_backtrace")) { /* filter outselves out */ continue; } cur++; /* gonna keep this frame, so count it */ output_frame(outch, lastoutch, p->backtrace_fields, NULL, /* no module path */ NULL, /* no module */ function, offset, address_buf); if (o->output_mode == DIAG_CALL_FN) { o->output_fn(o->user_data, buf); } else { WriteFile(o->outfile, buf, strlen(buf), &bytes_written, NULL); WriteFile(o->outfile, "\r\n", 2, &bytes_written, NULL); } } return 0; }