int main(int argc, char **argv) { struct state state; if (initialize_state(&state)) { printf("ERROR in initialization\n"); return 1; } if (parse_args(argc, argv, &state)) { printf("ERROR parsing arguments\n"); return 1; // TODO: cleanup_state() } if (bmp_load(state.inf, state.inname, &state)) { printf("ERROR loading BMP!\n"); return 1; // TODO: cleanup_state() } if (font_save(state.outf, state.outname, &state)) { printf("ERROR saving font!\n"); return 1; // TODO: cleanup_state() } cleanup_state(&state); return 0; }
void vl_zscan_cleanup(struct vl_zscan *zscan) { assert(zscan); cleanup_shaders(zscan); cleanup_state(zscan); }
void jpeg_compress_done(void *arg) { struct compress_jpeg_state *s = (struct compress_jpeg_state *) arg; cleanup_state(s); free(s); }
void vl_idct_cleanup(struct vl_idct *idct) { cleanup_shaders(idct); cleanup_state(idct); pipe_sampler_view_reference(&idct->matrix, NULL); pipe_sampler_view_reference(&idct->transpose, NULL); }
static void jpeg_compress_done(struct module *mod) { struct state_video_compress_jpeg *s = (struct state_video_compress_jpeg *) mod->priv_data; cleanup_state(s); platform_spin_destroy(&s->spin); free(s); }
int main_split(int argc, char** argv) { int ret = 1; parsed_opts_t* opts = parse_args(argc, argv); if (!opts) goto cleanup_opts; state_t* status = init(opts); if (!status) goto cleanup_opts; if (!split(status)) { cleanup_state(status, false); goto cleanup_opts; } ret = cleanup_state(status, true); cleanup_opts: cleanup_opts(opts); return ret; }
int main_addreplacerg(int argc, char** argv) { parsed_opts_t* opts = NULL; state_t* state = NULL; if (!parse_args(argc, argv, &opts)) goto error; if (opts == NULL) return EXIT_SUCCESS; // Not an error but user doesn't want us to proceed if (!opts || !init(opts, &state)) goto error; if (!readgroupise(state)) goto error; cleanup_opts(opts); cleanup_state(state); return EXIT_SUCCESS; error: cleanup_opts(opts); cleanup_state(state); return EXIT_FAILURE; }
static struct packet_module_state *init_state(int thread_id) { static const u_int16_t proto_family[] = { AF_INET, AF_INET6 }; int i; struct packet_module_state *state = malloc(sizeof(struct packet_module_state)); if (!state) { return NULL; } /* Setup nfqueue connection */ state->handle = nfq_open(); if (!state->handle) { message(HAKA_LOG_ERROR, MODULE_NAME, L"unable to open nfqueue handle"); cleanup_state(state); return NULL; } for (i=0; i<sizeof(proto_family)/sizeof(proto_family[0]); ++i) { if (nfq_unbind_pf(state->handle, proto_family[i]) < 0) { message(HAKA_LOG_ERROR, MODULE_NAME, L"cannot unbind queue"); cleanup_state(state); return NULL; } if (nfq_bind_pf(state->handle, proto_family[i]) < 0) { message(HAKA_LOG_ERROR, MODULE_NAME, L"cannot bind queue"); cleanup_state(state); return NULL; } state->send_fd = open_send_socket(false); if (state->send_fd < 0) { cleanup_state(state); return NULL; } state->send_mark_fd = open_send_socket(true); if (state->send_fd < 0) { cleanup_state(state); return NULL; } } state->queue = nfq_create_queue(state->handle, thread_id, &packet_callback, state); if (!state->queue) { message(HAKA_LOG_ERROR, MODULE_NAME, L"cannot create queue"); cleanup_state(state); return NULL; } if (nfq_set_mode(state->queue, NFQNL_COPY_PACKET, PACKET_BUFFER_SIZE) < 0) { message(HAKA_LOG_ERROR, MODULE_NAME, L"cannot set mode to copy packet"); cleanup_state(state); return NULL; } state->fd = nfq_fd(state->handle); /* Change nfq queue len and netfilter receive size */ if (nfq_set_queue_maxlen(state->queue, nfqueue_len) < 0) { message(HAKA_LOG_WARNING, MODULE_NAME, L"cannot change netfilter queue len"); } nfnl_rcvbufsiz(nfq_nfnlh(state->handle), nfqueue_len * 1500); return state; }
// Set the initial state static state_t* init(parsed_opts_t* opts) { state_t* retval = calloc(sizeof(state_t), 1); if (!retval) { fprintf(pysamerr, "Out of memory"); return NULL; } retval->merged_input_file = sam_open(opts->merged_input_name, "rb"); if (!retval->merged_input_file) { fprintf(pysamerr, "Could not open input file (%s)\n", opts->merged_input_name); free(retval); return NULL; } retval->merged_input_header = sam_hdr_read(retval->merged_input_file); if (opts->unaccounted_name) { if (opts->unaccounted_header_name) { samFile* hdr_load = sam_open(opts->unaccounted_header_name, "r"); if (!hdr_load) { fprintf(pysamerr, "Could not open unaccounted header file (%s)\n", opts->unaccounted_header_name); cleanup_state(retval); return NULL; } retval->unaccounted_header = sam_hdr_read(hdr_load); sam_close(hdr_load); } else { retval->unaccounted_header = bam_hdr_dup(retval->merged_input_header); } retval->unaccounted_file = sam_open(opts->unaccounted_name, "wb"); if (retval->unaccounted_file == NULL) { fprintf(pysamerr, "Could not open unaccounted output file: %s\n", opts->unaccounted_name); cleanup_state(retval); return NULL; } } // Open output files for RGs if (!count_RG(retval->merged_input_header, &retval->output_count, &retval->rg_id)) return NULL; if (opts->verbose) fprintf(pysamerr, "@RG's found %zu\n",retval->output_count); retval->rg_output_file = (samFile**)calloc(retval->output_count, sizeof(samFile*)); retval->rg_output_header = (bam_hdr_t**)calloc(retval->output_count, sizeof(bam_hdr_t*)); retval->rg_hash = kh_init_c2i(); if (!retval->rg_output_file || !retval->rg_output_header) { fprintf(pysamerr, "Could not allocate memory for output file array. Out of memory?"); cleanup_state(retval); return NULL; } char* dirsep = strrchr(opts->merged_input_name, '/'); char* input_base_name = strdup(dirsep? dirsep+1 : opts->merged_input_name); if (!input_base_name) { fprintf(pysamerr, "Out of memory\n"); cleanup_state(retval); return NULL; } char* extension = strrchr(input_base_name, '.'); if (extension) *extension = '\0'; size_t i; for (i = 0; i < retval->output_count; i++) { char* output_filename = NULL; if ( ( output_filename = expand_format_string(opts->output_format_string, input_base_name, retval->rg_id[i], i) ) == NULL) { fprintf(pysamerr, "Error expanding output filename format string.\r\n"); cleanup_state(retval); free(input_base_name); return NULL; } retval->rg_output_file[i] = sam_open(output_filename, "wb"); if (retval->rg_output_file[i] == NULL) { fprintf(pysamerr, "Could not open output file: %s\r\n", output_filename); cleanup_state(retval); free(input_base_name); return NULL; } // Record index in hash int ret; khiter_t iter = kh_put_c2i(retval->rg_hash, retval->rg_id[i], &ret); kh_val(retval->rg_hash,iter) = i; // Set and edit header retval->rg_output_header[i] = bam_hdr_dup(retval->merged_input_header); if ( !filter_header_rg(retval->rg_output_header[i], retval->rg_id[i]) ) { fprintf(pysamerr, "Could not rewrite header for file: %s\r\n", output_filename); cleanup_state(retval); free(output_filename); free(input_base_name); return NULL; } free(output_filename); } free(input_base_name); return retval; }
struct video_frame * jpeg_compress(struct module *mod, struct video_frame * tx, int buffer_idx) { struct state_video_compress_jpeg *s = (struct state_video_compress_jpeg *) mod->priv_data; int i; unsigned char *line1, *line2; struct video_frame *out; unsigned int x; cudaSetDevice(cuda_devices[0]); if(!s->encoder) { int ret; ret = configure_with(s, tx); if(!ret) { return NULL; } } struct video_desc desc; desc = video_desc_from_frame(tx); // if format changed, reconfigure if(!video_desc_eq_excl_param(s->saved_desc, desc, PARAM_INTERLACING)) { cleanup_state(s); int ret; ret = configure_with(s, tx); if(!ret) { return NULL; } } out = s->out[buffer_idx]; for (x = 0; x < tx->tile_count; ++x) { struct tile *in_tile = vf_get_tile(tx, x); struct tile *out_tile = vf_get_tile(out, x); line1 = (unsigned char *) in_tile->data; line2 = (unsigned char *) s->decoded; for (i = 0; i < (int) in_tile->height; ++i) { s->decoder(line2, line1, s->encoder_input_linesize, 0, 8, 16); line1 += vc_get_linesize(in_tile->width, tx->color_spec); line2 += s->encoder_input_linesize; } line1 = (unsigned char *) out_tile->data + (in_tile->height - 1) * s->encoder_input_linesize; for( ; i < (int) out->tiles[0].height; ++i) { memcpy(line2, line1, s->encoder_input_linesize); line2 += s->encoder_input_linesize; } /*if(s->interlaced_input) vc_deinterlace((unsigned char *) s->decoded, s->encoder_input_linesize, s->out->tiles[0].height);*/ uint8_t *compressed; int size; int ret; struct gpujpeg_encoder_input encoder_input; gpujpeg_encoder_input_set_image(&encoder_input, (uint8_t *) s->decoded); ret = gpujpeg_encoder_encode(s->encoder, &encoder_input, &compressed, &size); if(ret != 0) return NULL; out_tile->data_len = size; memcpy(out_tile->data, compressed, size); } return out; }