static void deinit_pixel_converter(void) { scaler_ctx_gen_reset(&driver.scaler); memset(&driver.scaler, 0, sizeof(driver.scaler)); free(driver.scaler_out); driver.scaler_out = NULL; }
void ffemu_free(ffemu_t *handle) { if (handle) { deinit_thread(handle); deinit_thread_buf(handle); if (handle->audio.codec) { avcodec_close(handle->audio.codec); av_free(handle->audio.codec); } if (handle->audio.buffer) av_free(handle->audio.buffer); if (handle->video.codec) { avcodec_close(handle->video.codec); av_free(handle->video.codec); } if (handle->video.conv_frame) av_free(handle->video.conv_frame); if (handle->video.conv_frame_buf) av_free(handle->video.conv_frame_buf); scaler_ctx_gen_reset(&handle->video.scaler); free(handle); } }
static void switch_set_texture_frame( void *data, const void *frame, bool rgb32, unsigned width, unsigned height, float alpha) { switch_video_t *sw = data; if ( !sw->menu_texture.pixels || sw->menu_texture.width != width || sw->menu_texture.height != height) { if (sw->menu_texture.pixels) free(sw->menu_texture.pixels); sw->menu_texture.pixels = malloc(width * height * (rgb32 ? 4 : 2)); if (!sw->menu_texture.pixels) { RARCH_ERR("failed to allocate buffer for menu texture\n"); return; } int xsf = 1280 / width; int ysf = 720 / height; int sf = xsf; if (ysf < sf) sf = ysf; sw->menu_texture.width = width; sw->menu_texture.height = height; sw->menu_texture.tgtw = width * sf; sw->menu_texture.tgth = height * sf; struct scaler_ctx *sctx = &sw->menu_texture.scaler; scaler_ctx_gen_reset(sctx); sctx->in_width = width; sctx->in_height = height; sctx->in_stride = width * (rgb32 ? 4 : 2); sctx->in_fmt = rgb32 ? SCALER_FMT_ARGB8888 : SCALER_FMT_RGB565; sctx->out_width = sw->menu_texture.tgtw; sctx->out_height = sw->menu_texture.tgth; sctx->out_stride = 1280 * 4; sctx->out_fmt = SCALER_FMT_ABGR8888; sctx->scaler_type = SCALER_TYPE_POINT; if (!scaler_ctx_gen_filter(sctx)) { RARCH_ERR("failed to generate scaler for menu texture\n"); return; } } memcpy(sw->menu_texture.pixels, frame, width * height * (rgb32 ? 4 : 2)); }
static bool screenshot_dump_direct(screenshot_task_state_t *state) { struct scaler_ctx *scaler = (struct scaler_ctx*)&state->scaler; bool ret = false; #ifdef HAVE_RBMP enum rbmp_source_type bmp_type = RBMP_SOURCE_TYPE_DONT_CARE; (void)bmp_type; #endif #if defined(HAVE_RPNG) if (state->bgr24) scaler->in_fmt = SCALER_FMT_BGR24; else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888) scaler->in_fmt = SCALER_FMT_ARGB8888; else scaler->in_fmt = SCALER_FMT_RGB565; video_frame_convert_to_bgr24( scaler, state->out_buffer, (const uint8_t*)state->frame + ((int)state->height - 1) * state->pitch, state->width, state->height, -state->pitch); scaler_ctx_gen_reset(&state->scaler); ret = rpng_save_image_bgr24( state->filename, state->out_buffer, state->width, state->height, state->width * 3 ); free(state->out_buffer); #elif defined(HAVE_RBMP) if (state->bgr24) bmp_type = RBMP_SOURCE_TYPE_BGR24; else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888) bmp_type = RBMP_SOURCE_TYPE_XRGB888; ret = rbmp_save_image(state->filename, state->frame, state->width, state->height, state->pitch, bmp_type); #endif return ret; }
static void ffmpeg_free(void *data) { ffmpeg_t *handle = (ffmpeg_t*)data; if (!handle) return; deinit_thread(handle); deinit_thread_buf(handle); if (handle->audio.codec) { avcodec_close(handle->audio.codec); av_free(handle->audio.codec); } av_free(handle->audio.buffer); if (handle->video.codec) { avcodec_close(handle->video.codec); av_free(handle->video.codec); } av_frame_free(&handle->video.conv_frame); av_free(handle->video.conv_frame_buf); scaler_ctx_gen_reset(&handle->video.scaler); if (handle->video.sws) sws_freeContext(handle->video.sws); if (handle->config.conf) config_file_free(handle->config.conf); if (handle->config.video_opts) av_dict_free(&handle->config.video_opts); if (handle->config.audio_opts) av_dict_free(&handle->config.audio_opts); if (handle->audio.resampler && handle->audio.resampler_data) handle->audio.resampler->free(handle->audio.resampler_data); handle->audio.resampler = NULL; handle->audio.resampler_data = NULL; av_free(handle->audio.float_conv); av_free(handle->audio.resample_out); av_free(handle->audio.fixed_conv); av_free(handle->audio.planar_buf); free(handle); }
static void v4l_free(void *data) { video4linux_t *v4l = (video4linux_t*)data; unsigned i; for (i = 0; i < v4l->n_buffers; i++) if (munmap(v4l->buffers[i].start, v4l->buffers[i].length) == -1) RARCH_ERR("munmap failed.\n"); if (v4l->fd >= 0) close(v4l->fd); free(v4l->buffer_output); scaler_ctx_gen_reset(&v4l->scaler); free(v4l); }
void ffemu_free(ffemu_t *handle) { if (!handle) return; deinit_thread(handle); deinit_thread_buf(handle); if (handle->audio.codec) { avcodec_close(handle->audio.codec); av_free(handle->audio.codec); } av_free(handle->audio.buffer); if (handle->video.codec) { avcodec_close(handle->video.codec); av_free(handle->video.codec); } av_frame_free(&handle->video.conv_frame); av_free(handle->video.conv_frame_buf); scaler_ctx_gen_reset(&handle->video.scaler); if (handle->video.sws) sws_freeContext(handle->video.sws); if (handle->config.conf) config_file_free(handle->config.conf); if (handle->config.video_opts) av_dict_free(&handle->config.video_opts); if (handle->config.audio_opts) av_dict_free(&handle->config.audio_opts); rarch_resampler_freep(&handle->audio.resampler, &handle->audio.resampler_data); av_free(handle->audio.float_conv); av_free(handle->audio.resample_out); av_free(handle->audio.fixed_conv); av_free(handle->audio.planar_buf); free(handle); }
void deinit_pixel_converter(void) { if (!scaler_ptr) return; scaler_ctx_gen_reset(scaler_ptr->scaler); if (scaler_ptr->scaler) free(scaler_ptr->scaler); if (scaler_ptr->scaler_out) free(scaler_ptr->scaler_out); if (scaler_ptr) free(scaler_ptr); scaler_ptr->scaler = NULL; scaler_ptr->scaler_out = NULL; scaler_ptr = NULL; }
static void sdl_gfx_free(void *data) { sdl_video_t *vid = (sdl_video_t*)data; if (!vid) return; if (vid->buffer) SDL_FreeSurface(vid->buffer); SDL_QuitSubSystem(SDL_INIT_VIDEO); #ifdef HAVE_FREETYPE if (vid->font) font_renderer_free(vid->font); #endif scaler_ctx_gen_reset(&vid->scaler); free(vid); }
/* Take frame bottom-up. */ static bool screenshot_dump( const char *global_name_base, const char *folder, const void *frame, unsigned width, unsigned height, int pitch, bool bgr24) { char filename[PATH_MAX_LENGTH] = {0}; char shotname[256] = {0}; bool ret = false; settings_t *settings = config_get_ptr(); #if defined(HAVE_ZLIB_DEFLATE) && defined(HAVE_RPNG) uint8_t *out_buffer = NULL; struct scaler_ctx scaler = {0}; #endif if (settings->auto_screenshot_filename) { fill_dated_filename(shotname, IMG_EXT, sizeof(shotname)); fill_pathname_join(filename, folder, shotname, sizeof(filename)); } else { snprintf(shotname, sizeof(shotname),"%s.png", path_basename(global_name_base)); fill_pathname_join(filename, folder, shotname, sizeof(filename)); } #ifdef _XBOX1 d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(true); D3DSurface *surf = NULL; d3d->dev->GetBackBuffer(-1, D3DBACKBUFFER_TYPE_MONO, &surf); if (XGWriteSurfaceToFile(surf, filename) == S_OK) ret = true; surf->Release(); #elif defined(HAVE_ZLIB_DEFLATE) && defined(HAVE_RPNG) out_buffer = (uint8_t*)malloc(width * height * 3); if (!out_buffer) return false; video_frame_convert_to_bgr24( &scaler, out_buffer, (const uint8_t*)frame + ((int)height - 1) * pitch, width, height, -pitch, bgr24); scaler_ctx_gen_reset(&scaler); ret = rpng_save_image_bgr24( filename, out_buffer, width, height, width * 3 ); free(out_buffer); #elif defined(HAVE_RBMP) enum rbmp_source_type bmp_type = RBMP_SOURCE_TYPE_DONT_CARE; if (bgr24) bmp_type = RBMP_SOURCE_TYPE_BGR24; else if (video_driver_get_pixel_format() == RETRO_PIXEL_FORMAT_XRGB8888) bmp_type = RBMP_SOURCE_TYPE_XRGB888; ret = rbmp_save_image(filename, frame, width, height, pitch, bmp_type); #endif #ifdef HAVE_IMAGEVIEWER if (ret == true) { if (content_push_to_history_playlist(g_defaults.image_history, filename, "imageviewer", "builtin")) playlist_write_file(g_defaults.image_history); } #endif return ret; }
static bool switch_frame(void *data, const void *frame, unsigned width, unsigned height, uint64_t frame_count, unsigned pitch, const char *msg, video_frame_info_t *video_info) { static uint64_t last_frame = 0; unsigned x, y; result_t r; int tgtw, tgth, centerx, centery; uint32_t *out_buffer = NULL; switch_video_t *sw = data; int xsf = 1280 / width; int ysf = 720 / height; int sf = xsf; if (ysf < sf) sf = ysf; tgtw = width * sf; tgth = height * sf; centerx = (1280-tgtw)/2; centery = (720-tgth)/2; // clear image to black for(y = 0; y < 720; y++) { for(x = 0; x < 1280; x++) { sw->image[y*1280+x] = 0xFF000000; } } if(width > 0 && height > 0) { if(sw->last_width != width || sw->last_height != height) { scaler_ctx_gen_reset(&sw->scaler); sw->scaler.in_width = width; sw->scaler.in_height = height; sw->scaler.in_stride = pitch; sw->scaler.in_fmt = sw->rgb32 ? SCALER_FMT_ARGB8888 : SCALER_FMT_RGB565; sw->scaler.out_width = tgtw; sw->scaler.out_height = tgth; sw->scaler.out_stride = 1280 * sizeof(uint32_t); sw->scaler.out_fmt = SCALER_FMT_ABGR8888; sw->scaler.scaler_type = SCALER_TYPE_POINT; if(!scaler_ctx_gen_filter(&sw->scaler)) { RARCH_ERR("failed to generate scaler for main image\n"); return false; } sw->last_width = width; sw->last_height = height; } scaler_ctx_scale(&sw->scaler, sw->image + (centery * 1280) + centerx, frame); } #if defined(HAVE_MENU) if (sw->menu_texture.enable) { menu_driver_frame(video_info); if (sw->menu_texture.pixels) { #if 0 if (sw->menu_texture.fullscreen) { #endif scaler_ctx_scale(&sw->menu_texture.scaler, sw->image + ((720-sw->menu_texture.tgth)/2)*1280 + ((1280-sw->menu_texture.tgtw)/2), sw->menu_texture.pixels); #if 0 } else { } #endif } } else if (video_info->statistics_show) { struct font_params *osd_params = (struct font_params*) &video_info->osd_stat_params; if (osd_params) { font_driver_render_msg(video_info, NULL, video_info->stat_text, (const struct font_params*)&video_info->osd_stat_params); } } #endif #if 0 if (frame_count > 6000) { display_finalize(); exit(0); } #endif if (msg && strlen(msg) > 0) RARCH_LOG("message: %s\n", msg); r = surface_dequeue_buffer(&sw->surface, &out_buffer); if (sw->vsync) switch_wait_vsync(sw); svcSleepThread(10000); if(r != RESULT_OK) { return true; // just skip the frame } gfx_slow_swizzling_blit(out_buffer, sw->image, 1280, 720, 0, 0); r = surface_queue_buffer(&sw->surface); if (r != RESULT_OK) return false; last_frame = svcGetSystemTick(); return true; }
/** * task_screenshot_handler: * @task : the task being worked on * * Saves a screenshot to disk. **/ static void task_screenshot_handler(retro_task_t *task) { #ifdef HAVE_RBMP enum rbmp_source_type bmp_type = RBMP_SOURCE_TYPE_DONT_CARE; #endif screenshot_task_state_t *state = (screenshot_task_state_t*)task->state; struct scaler_ctx *scaler = (struct scaler_ctx*)&state->scaler; bool ret = false; if (task_get_progress(task) == 100) { task_set_finished(task, true); if (state->userbuf) free(state->userbuf); free(state); return; } #ifdef HAVE_RBMP (void)bmp_type; #endif #if defined(_XBOX1) if (XGWriteSurfaceToFile(state->surf, state->filename) == S_OK) ret = true; state->surf->Release(); #elif defined(HAVE_RPNG) if (state->bgr24) scaler->in_fmt = SCALER_FMT_BGR24; else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888) scaler->in_fmt = SCALER_FMT_ARGB8888; else scaler->in_fmt = SCALER_FMT_RGB565; video_frame_convert_to_bgr24( scaler, state->out_buffer, (const uint8_t*)state->frame + ((int)state->height - 1) * state->pitch, state->width, state->height, -state->pitch); scaler_ctx_gen_reset(&state->scaler); ret = rpng_save_image_bgr24( state->filename, state->out_buffer, state->width, state->height, state->width * 3 ); free(state->out_buffer); #elif defined(HAVE_RBMP) if (state->bgr24) bmp_type = RBMP_SOURCE_TYPE_BGR24; else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888) bmp_type = RBMP_SOURCE_TYPE_XRGB888; ret = rbmp_save_image(state->filename, state->frame, state->width, state->height, state->pitch, bmp_type); #endif #ifdef HAVE_IMAGEVIEWER if (ret && !state->silence) { if ( state->history_list_enable && g_defaults.image_history && playlist_push( g_defaults.image_history, state->filename, NULL, "builtin", "imageviewer", NULL, NULL ) ) playlist_write_file(g_defaults.image_history); } #endif task_set_progress(task, 100); if (!ret) { char *msg = strdup(msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT)); runloop_msg_queue_push(msg, 1, state->is_paused ? 1 : 180, true); free(msg); } }