uint32_t tgen_generate_debug_chunk(const char * filename, uint32_t x, uint32_t y) { // restore heap mem.restore_heap(saved_heap); cpu.reset_stack(); cpu.push_dword(y); cpu.push_dword(x); get_self() = MANAGER_ADDRESS; add_ret(); generator_func(); // save_chunk_now(); // return 0; // address 405E30 is // void * __thiscall get_sector_chunk_data(__int64 chunk_pos) cpu.push_dword(y); cpu.push_dword(x); get_self() = MANAGER_ADDRESS; add_ret(); sub_405E30(); uint32_t chunk_offset = cpu.reg[EAX]; tgen_dump_mem(filename); return chunk_offset; }
/* * Start the backup of a specific file */ static bRC startBackupFile(bpContext *ctx, struct save_pkt *sp) { delta_test *self = get_self(ctx); if (!self) { return bRC_Error; } time_t now = time(NULL); sp->fname = (char *)"/delta.txt"; sp->type = FT_REG; sp->statp.st_mode = 0700 | S_IFREG; sp->statp.st_ctime = now; sp->statp.st_mtime = now; sp->statp.st_atime = now; sp->statp.st_size = -1; sp->statp.st_blksize = 4096; sp->statp.st_blocks = 1; if (self->level == 'I' || self->level == 'D') { bRC state = bfuncs->checkChanges(ctx, sp); /* Should always be bRC_OK */ sp->type = (state == bRC_Seen)? FT_NOCHG : FT_REG; sp->flags |= (FO_DELTA|FO_OFFSETS); self->delta = sp->delta_seq + 1; } pm_strcpy(self->fname, files[self->delta % nb_files]); Dmsg(ctx, dbglvl, "delta-test-fd: delta_seq=%i delta=%i fname=%s\n", sp->delta_seq, self->delta, self->fname); // Dmsg(ctx, dbglvl, "delta-test-fd: startBackupFile\n"); return bRC_OK; }
/* * This is called during restore to create the file (if necessary) * We must return in rp->create_status: * * CF_ERROR -- error * CF_SKIP -- skip processing this file * CF_EXTRACT -- extract the file (i.e.call i/o routines) * CF_CREATED -- created, but no content to extract (typically directories) * */ static bRC createFile(bpContext *ctx, struct restore_pkt *rp) { delta_test *self = get_self(ctx); pm_strcpy(self->fname, rp->ofname); rp->create_status = CF_EXTRACT; return bRC_OK; }
SCM ffmpeg_crop_audio_frame_size(SCM scm_self, SCM scm_size) { struct ffmpeg_t *self = get_self(scm_self); self->audio_target_frame->nb_samples = scm_to_int(scm_size); self->audio_packed_frame->nb_samples = scm_to_int(scm_size); return SCM_UNSPECIFIED; }
SCM ffmpeg_decode_audio_video(SCM scm_self) { SCM retval = SCM_BOOL_F; struct ffmpeg_t *self = get_self(scm_self); if (!is_input_context(self)) scm_misc_error("ffmpeg-decode-audio/video", "Attempt to read frame from FFmpeg output video", SCM_EOL); while (scm_is_false(retval)) { if (packet_empty(self)) read_packet(self); int reading_cache = packet_empty(self); if (self->pkt.stream_index == self->audio_stream_idx) { av_frame_unref(self->audio_target_frame); retval = decode_audio(self, &self->pkt, self->audio_target_frame); } else if (self->pkt.stream_index == self->video_stream_idx) { av_frame_unref(self->video_target_frame); retval = decode_video(self, &self->pkt, self->video_target_frame); } else consume_packet_data(&self->pkt, self->pkt.size); if (scm_is_false(retval) && reading_cache) break; }; return retval; }
SCM ffmpeg_target_audio_frame(SCM scm_self) { struct ffmpeg_t *self = get_self(scm_self); if (!is_input_context(self)) make_frame_writable(self->audio_target_frame); return list_audio_frame_info(self, self->audio_target_frame); }
/** * The ckernel destructor function, which is placed in * base.destructor. */ static void destruct(ckernel_prefix *rawself) { self_type *self = get_self(rawself); // If there are any child kernels, a child class // must implement this to destroy them. self->destruct_children(); self->~self_type(); }
SCM ffmpeg_flush(SCM scm_self) { struct ffmpeg_t *self = get_self(scm_self); if (self->video_codec_ctx) avcodec_flush_buffers(self->video_codec_ctx); if (self->audio_codec_ctx) avcodec_flush_buffers(self->audio_codec_ctx); if (self->audio_buffer.buffer) ringbuffer_flush(&self->audio_buffer); return scm_self; }
thread_state_enum at_timer(SchedulingPolicy& scheduler, boost::chrono::steady_clock::time_point& abs_time, thread_id_type const& thrd, thread_state_enum newstate, thread_state_ex_enum newstate_ex, thread_priority priority) { if (HPX_UNLIKELY(!thrd)) { HPX_THROW_EXCEPTION(null_thread_id, "threads::detail::at_timer", "NULL thread id encountered"); return terminated; } // create a new thread in suspended state, which will execute the // requested set_state when timer fires and will re-awaken this thread, // allowing the deadline_timer to go out of scope gracefully thread_id_type self_id = get_self_id(); boost::shared_ptr<boost::atomic<bool> > triggered( boost::make_shared<boost::atomic<bool> >(false)); thread_init_data data( boost::bind(&wake_timer_thread, thrd, newstate, newstate_ex, priority, self_id, triggered), "wake_timer", 0, priority); thread_id_type wake_id = invalid_thread_id; create_thread(&scheduler, data, wake_id, suspended); // create timer firing in correspondence with given time typedef boost::asio::basic_deadline_timer< boost::chrono::steady_clock , util::chrono_traits<boost::chrono::steady_clock> > deadline_timer; deadline_timer t ( get_thread_pool("timer-pool")->get_io_service(), abs_time); // let the timer invoke the set_state on the new (suspended) thread t.async_wait(boost::bind(&detail::set_thread_state, wake_id, pending, wait_timeout, priority, std::size_t(-1), boost::ref(throws))); // this waits for the thread to be reactivated when the timer fired // if it returns signaled the timer has been canceled, otherwise // the timer fired and the wake_timer_thread above has been executed bool oldvalue = false; thread_state_ex_enum statex = get_self().yield(suspended); if (wait_timeout != statex && triggered->compare_exchange_strong(oldvalue, true)) //-V601 { // wake_timer_thread has not been executed yet, cancel timer t.cancel(); } return terminated; }
/* * Free a plugin instance, i.e. release our private storage */ static bRC freePlugin(bpContext *ctx) { delta_test *self = get_self(ctx); if (!self) { return bRC_Error; } delete self; return bRC_OK; }
SCM ffmpeg_seek(SCM scm_self, SCM scm_position) { struct ffmpeg_t *self = get_self(scm_self); if (!is_input_context(self)) scm_misc_error("ffmpeg-seek", "Attempt to seek in FFmpeg output video", SCM_EOL); int64_t position = (int64_t)(scm_to_double(scm_position) * AV_TIME_BASE); av_seek_frame(self->fmt_ctx, -1, position, AVSEEK_FLAG_ANY);// TODO: check error return scm_position; }
static void block(void) { struct mythread_thread* self = get_self(); pthread_mutex_lock(&g_mutex); self->should_run = false; pthread_cond_signal(&g_schedule); while (!self->should_run) { pthread_cond_wait(&self->cv, &g_mutex); } pthread_mutex_unlock(&g_mutex); }
SCM ffmpeg_encode_audio(SCM scm_self) { struct ffmpeg_t *self = get_self(scm_self); AVCodecContext *codec = audio_codec_ctx(self); AVFrame *audio_frame = self->audio_target_frame; audio_frame->pts = av_rescale_q(self->samples_count, (AVRational){1, codec->sample_rate}, codec->time_base); self->samples_count += audio_frame->nb_samples; encode_audio(self, self->audio_target_frame); return SCM_UNSPECIFIED; }
Object *new_exception_frame(Object *cxt, Object *frame, Object *ex) { Object *catch_frame = new_object(cxt, find_catch_frame(cxt, frame)); Object *ret_frame = get(cxt, catch_frame, "return"); Object *self = get_self(cxt, catch_frame); Object *catch_block = get_catch_block(cxt, catch_frame); Object *new_catch_frame = new_frame(cxt, self, catch_block, ret_frame); Object *old_local = get(cxt, catch_frame, "local"); set_lexical_parent(cxt, new_catch_frame, old_local); push(cxt, get(cxt, ret_frame, "stack"), ex); return new_catch_frame; }
static AVStream *open_output_stream(SCM scm_self, AVCodec *encoder, int *stream_idx, const char *output_type, SCM scm_file_name) { struct ffmpeg_t *self = get_self(scm_self); AVStream *retval = avformat_new_stream(self->fmt_ctx, encoder); if (!retval) { ffmpeg_destroy(scm_self); scm_misc_error("make-ffmpeg-output", "Error allocating ~a stream for file '~a'", scm_list_2(scm_from_locale_string(output_type), scm_file_name)); }; retval->id = self->fmt_ctx->nb_streams - 1; *stream_idx = retval->id; return retval; }
cyg_bool_t cyg_mutex_lock(cyg_mutex_t* mutex) { struct mythread_mutex* shadow = get_shadow_mutex(mutex); struct mythread_thread* self = get_self(); block(); while (shadow->locked) { block(); } shadow->owner = self->id; shadow->locked = true; return true; }
SCM ffmpeg_encode_video(SCM scm_self) { // TODO: AVFMT_RAWPICTURE struct ffmpeg_t *self = get_self(scm_self); if (is_input_context(self)) scm_misc_error("ffmpeg-encode-video", "Attempt to write to FFmpeg input video", SCM_EOL); // Set frame timestamp self->video_target_frame->pts = self->output_video_pts++; encode_video(self, self->video_target_frame); return SCM_UNSPECIFIED; }
uint32_t tgen_generate_chunk(uint32_t x, uint32_t y) { // restore heap mem.restore_heap(saved_heap); cpu.reset_stack(); cpu.push_dword(y); cpu.push_dword(x); get_self() = MANAGER_ADDRESS; add_ret(); generator_func(); // save_chunk_now(); // return 0; // address 405E30 is // void * __thiscall get_sector_chunk_data(__int64 chunk_pos) cpu.push_dword(y); cpu.push_dword(x); get_self() = MANAGER_ADDRESS; add_ret(); sub_405E30(); return cpu.reg[EAX]; }
void basic_local_buffer<Document, Selector>::session_close_impl() { // Remove all users except for the local one user_table& table = this->m_user_table; for(user_table::iterator iter = table.begin(user::flags::CONNECTED, user::flags::NONE); iter != table.end(user::flags::CONNECTED, user::flags::NONE); ++ iter) { if(&(*iter) == &get_self() ) continue; // This tells documents that the user has gone. This causes // the user to be unsubscribed from documents basic_buffer<Document, Selector>::user_part(*iter); } }
/** * Initializes an instance of this ckernel in-place according to the * kernel request. This calls the constructor in-place, and initializes * the base function and destructor */ static inline self_type *init(ckernel_prefix *rawself, kernel_request_t kernreq) { // Alignment requirement of the type DYND_STATIC_ASSERT((size_t)scalar_align_of<self_type>::value <= (size_t)scalar_align_of<uint64_t>::value, "ckernel types require alignment <= 64 bits"); // Call the constructor in-place self_type *self = new (rawself) self_type(); // Double check that the C++ struct layout is as we expect if (self != get_self(rawself)) { throw std::runtime_error( "internal ckernel error: struct layout is not valid"); } self->base.destructor = &self_type::destruct; // A child class must implement this to fill in self->base.function self->init_kernfunc(kernreq); return self; }
static int l_obj_is_optional(lua_State* L) { struct obj* self = get_self(L); lua_pushboolean(L, self->is_optional); return 1; }
static int l_obj_children(lua_State* L) { struct obj* self = get_self(L); struct obj* children = self->children; return children ? get_new_obj(L, children) : 0; }
static int l_obj_length(lua_State* L) { struct obj* self = get_self(L); lua_pushinteger(L, self->length); return 1; }
static int l_obj_name(lua_State* L) { struct obj* self = get_self(L); lua_pushstring(L, self->name); return 1; }
static int l_obj_ctype(lua_State* L) { struct obj* self = get_self(L); lua_pushstring(L, obj_strctype(self)); return 1; }
static int l_obj_next(lua_State* L) { struct obj* self = get_self(L); struct obj* next = self->next; return next ? get_new_obj(L, next) : 0; }
/* * Bacula is calling us to do the actual I/O */ static bRC pluginIO(bpContext *ctx, struct io_pkt *io) { delta_test *self = get_self(ctx); struct stat statp; if (!self) { return bRC_Error; } io->status = 0; io->io_errno = 0; switch(io->func) { case IO_OPEN: Dmsg(ctx, dbglvl, "delta-test-fd: IO_OPEN\n"); if (io->flags & (O_CREAT | O_WRONLY)) { /* TODO: if the file already exists, the result is undefined */ if (stat(io->fname, &statp) == 0) { /* file exists */ self->fd = fopen(io->fname, "r+"); } else { self->fd = fopen(io->fname, "w"); /* file doesn't exist,create it */ } if (!self->fd) { io->io_errno = errno; Jmsg(ctx, M_FATAL, "Open failed: ERR=%s\n", strerror(errno)); return bRC_Error; } } else { self->fd = fopen(self->fname, "r"); if (!self->fd) { io->io_errno = errno; Jmsg(ctx, M_FATAL, "Open failed: ERR=%s\n", strerror(errno)); return bRC_Error; } } break; case IO_READ: if (!self->fd) { Jmsg(ctx, M_FATAL, "Logic error: NULL read FD\n"); return bRC_Error; } if (self->done) { io->status = 0; } else { /* first time, read 300, then replace 50-250 by other data */ if (self->delta == 0) { io->status = fread(io->buf, 1, 400, self->fd); } else { io->offset = self->delta * 100 / 2; /* chunks are melted */ io->status = fread(io->buf, 1, 100, self->fd); } Dmsg(ctx, dbglvl, "delta-test-fd: READ offset=%lld\n", (int64_t)io->offset); self->done = true; } if (io->status == 0 && ferror(self->fd)) { Jmsg(ctx, M_FATAL, "Pipe read error: ERR=%s\n", strerror(errno)); Dmsg(ctx, dbglvl, "Pipe read error: ERR=%s\n", strerror(errno)); return bRC_Error; } Dmsg(ctx, dbglvl, "offset=%d\n", io->offset); break; case IO_WRITE: if (!self->fd) { Jmsg(ctx, M_FATAL, "Logic error: NULL write FD\n"); return bRC_Error; } Dmsg(ctx, dbglvl, "delta-test-fd: WRITE count=%lld\n", (int64_t)io->count); io->status = fwrite(io->buf, 1, io->count, self->fd); if (io->status == 0 && ferror(self->fd)) { Jmsg(ctx, M_FATAL, "Pipe write error\n"); Dmsg(ctx, dbglvl, "Pipe read error: ERR=%s\n", strerror(errno)); return bRC_Error; } break; case IO_CLOSE: if (!self->fd) { Jmsg(ctx, M_FATAL, "Logic error: NULL FD on delta close\n"); return bRC_Error; } io->status = fclose(self->fd); break; case IO_SEEK: if (!self->fd) { Jmsg(ctx, M_FATAL, "Logic error: NULL FD on delta close\n"); return bRC_Error; } Dmsg(ctx, dbglvl, "delta-test-fd: SEEK offset=%lld\n", (int64_t)io->offset); io->status = fseek(self->fd, io->offset, io->whence); Dmsg(ctx, dbglvl, "after SEEK=%lld\n", (int64_t)ftell(self->fd)); break; } return bRC_OK; }
const std::string& basic_local_buffer<Document, Selector>::get_name() const { return get_self().get_name(); }
/* * Handle an event that was generated in Bacula */ static bRC handlePluginEvent(bpContext *ctx, bEvent *event, void *value) { delta_test *self = get_self(ctx); int accurate=0; if (!self) { return bRC_Error; } // char *name; /* * Most events don't interest us so we ignore them. * the printfs are so that plugin writers can enable them to see * what is really going on. */ switch (event->eventType) { case bEventPluginCommand: // Dmsg(ctx, dbglvl, // "delta-test-fd: PluginCommand=%s\n", (char *)value); break; case bEventJobStart: // Dmsg(ctx, dbglvl, "delta-test-fd: JobStart=%s\n", (char *)value); break; case bEventJobEnd: // Dmsg(ctx, dbglvl, "delta-test-fd: JobEnd\n"); break; case bEventStartBackupJob: // Dmsg(ctx, dbglvl, "delta-test-fd: StartBackupJob\n"); break; case bEventEndBackupJob: // Dmsg(ctx, dbglvl, "delta-test-fd: EndBackupJob\n"); break; case bEventLevel: // Dmsg(ctx, dbglvl, "delta-test-fd: JobLevel=%c %d\n", (int)value, (int)value); self->level = (int)(intptr_t)value; break; case bEventSince: // Dmsg(ctx, dbglvl, "delta-test-fd: since=%d\n", (int)value); break; case bEventStartRestoreJob: // Dmsg(ctx, dbglvl, "delta-test-fd: StartRestoreJob\n"); break; case bEventEndRestoreJob: // Dmsg(ctx, dbglvl, "delta-test-fd: EndRestoreJob\n"); break; /* Plugin command e.g. plugin = <plugin-name>:<name-space>:read command:write command */ case bEventRestoreCommand: // Dmsg(ctx, dbglvl, "delta-test-fd: EventRestoreCommand cmd=%s\n", (char *)value); /* Fall-through wanted */ break; case bEventBackupCommand: Dmsg(ctx, dbglvl, "delta-test-fd: pluginEvent cmd=%s\n", (char *)value); if (self->level == 'I' || self->level == 'D') { bfuncs->getBaculaValue(ctx, bVarAccurate, (void *)&accurate); if (!accurate) { /* can be changed to FATAL */ Jmsg(ctx, M_FATAL, "Accurate mode should be turned on when using the " "delta-test plugin\n"); return bRC_Error; } } break; default: // Dmsg(ctx, dbglvl, "delta-test-fd: unknown event=%d\n", event->eventType); break; } return bRC_OK; }
thread_self::impl_type* get_ctx_ptr() { return hpx::util::coroutines::detail::coroutine_accessor::get_impl(get_self()); }