void UpdateTexture(SDL_Texture *texture, int frame)
{
SDL_Color *color;
Uint8 *src;
Uint32 *dst;
int row, col;
void *pixels;
int pitch;
if (SDL_LockTexture(texture, NULL, &pixels, &pitch) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't lock texture: %s\n", SDL_GetError());
quit(5);
}
src = MooseFrames[frame];
for (row = 0; row < MOOSEPIC_H; ++row) {
dst = (Uint32*)((Uint8*)pixels + row * pitch);
for (col = 0; col < MOOSEPIC_W; ++col) {
color = &MooseColors[*src++];
*dst++ = (0xFF000000|(color->r<<16)|(color->g<<8)|color->b);
}
}
SDL_UnlockTexture(texture);
}
static int
SDL_UpdateTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
const void *pixels, int pitch)
{
SDL_Texture *native = texture->native;
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
/* We can lock the texture and copy to it */
void *native_pixels;
int native_pitch;
if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
texture->format, pixels, pitch,
native->format, native_pixels, native_pitch);
SDL_UnlockTexture(native);
} else {
/* Use a temporary buffer for updating */
void *temp_pixels;
int temp_pitch;
temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
temp_pixels = SDL_malloc(rect->h * temp_pitch);
if (!temp_pixels) {
SDL_OutOfMemory();
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
texture->format, pixels, pitch,
native->format, temp_pixels, temp_pitch);
SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
SDL_free(temp_pixels);
}
return 0;
}
//==============================================================================
bool Texture::Load(SDL_Renderer* Renderer, std::string Filename) {
if(Renderer == NULL) {
Log("Bad SDL renderer passed");
return false;
}
this->Renderer = Renderer;
this->Filename = Filename;
SDL_Surface* TempSurface = IMG_Load(Filename.c_str());
if(TempSurface == NULL) {
Log("Unable to load image : %s : %s", Filename.c_str(), IMG_GetError());
return false;
}
//Log("Surface Loaded");
// Created to give STREAMING access to texture. This is needed to access
// pixels to determine its masks
SDLTexture = SDL_CreateTexture(Renderer, TempSurface->format->format,
SDL_TEXTUREACCESS_STREAMING, TempSurface->w, TempSurface->h);
//Log("Texture Created");
if(SDLTexture == NULL) {
Log("Unable to create SDL Texture : %s : %s", Filename.c_str(), IMG_GetError());
return false;
}
void* pixels;
SDL_SetTextureBlendMode(SDLTexture, SDL_BLENDMODE_BLEND);
SDL_LockTexture(SDLTexture, &TempSurface->clip_rect, &pixels, &pitch);
memcpy(pixels, TempSurface->pixels, TempSurface->h * TempSurface->pitch);
SDL_UnlockTexture(SDLTexture);
// Grab dimensions and pitch
Width = TempSurface->w;
Height = TempSurface->h;
SDL_FreeSurface(TempSurface);
return true;
}
void displayYUV_displayPicture(unsigned char *pictureBufferY,
unsigned char *pictureBufferU, unsigned char *pictureBufferV,
unsigned int pictureWidth, unsigned int pictureHeight) {
static unsigned int lastWidth = 0;
static unsigned int lastHeight = 0;
SDL_Event event;
if ((pictureHeight != lastHeight) || (pictureWidth != lastWidth)) {
displayYUV_setSize(pictureWidth, pictureHeight);
lastHeight = pictureHeight;
lastWidth = pictureWidth;
}
size1 = pictureWidth * pictureHeight;
SDL_LockTexture(bmpTex1, NULL, (void **)&pixels1, &pitch1);
memcpy(pixels1, pictureBufferY, size1 );
memcpy(pixels1 + size1, pictureBufferV, size1/4);
memcpy(pixels1 + size1*5/4, pictureBufferU, size1/4);
SDL_UnlockTexture(bmpTex1);
SDL_UpdateTexture(bmpTex1, NULL, pixels1, pitch1);
// refresh screen
// SDL_RenderClear(pRenderer1);
SDL_RenderCopy(pRenderer1, bmpTex1, NULL, NULL);
SDL_RenderPresent(pRenderer1);
/* Grab all the events off the queue. */
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
exit(0);
break;
default:
break;
}
}
}
void renderBackgroundImage(AppState* state,Uint8* image)
{
Uint8 *pixels = 0;
int pitch1;
if (0 == SDL_LockTexture(state->background, NULL, (void **)&pixels, &pitch1))
{
GLboolean isLightingOn = glIsEnabled(GL_LIGHTING);
GLboolean isDepthTestOn = glIsEnabled(GL_DEPTH_TEST);
if (isDepthTestOn) glDisable(GL_DEPTH_TEST);
if (isLightingOn) glDisable(GL_LIGHTING);
switch(gsBGTextureFormat) {
case SDL_PIXELFORMAT_YV12:
// memcpy(pixels, image, size1 );
// memcpy(pixels + size1, pFrame_YUV420P->data[2], size1/4);
// memcpy(pixels + size1*5/4, pFrame_YUV420P->data[1], size1/4);
break;
case SDL_PIXELFORMAT_RGB24:
memcpy( pixels, image, gsARTImageHeight*gsARTImageWidth*sizeof(Uint8)*3);
break;
}
SDL_UnlockTexture(state->background);
SDL_UpdateTexture(state->background, NULL, pixels, pitch1);
float width,height;
float posX = 0, posY = 0;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0.0f, gsARTImageWidth, gsARTImageHeight, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
/* this accounts for Texture2D vs TextureRectangle */
if (0 == SDL_GL_BindTexture(state->background, &width, &height ))
{
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(posX,posY);
glTexCoord2f(1*width, 0);
glVertex2f(posX + width, posY);
glTexCoord2f(1*width, 1*height);
glVertex2f(posX + width, posY + height);
glTexCoord2f(0, 1*height);
glVertex2f(posX, posY + height);
glEnd();
// SDL_GL_UnbindTexture(state->background);
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
if (isDepthTestOn) glEnable(GL_DEPTH_TEST);
if (isLightingOn) glEnable(GL_LIGHTING);
}
}
void qtsdl2::Run1()
{
int w = width();
int h = height();
m_Cap->setSize(width(), height());
unsigned char *pData = NULL;
int step = 0;
int width = 0;
int height = 0;
int cn = 0;
SDL_Surface *pRgb = NULL;
void *pixels;
int pitch;
//m_Cap->open("rtsp://159.99.251.194/");
m_Cap->open("r.mp4");
while(1)
{
m_Mutex.lock();
if (m_UpdateSize == true)
updateSize();
if (m_Cap->grabFrame() == false)
{
delete m_Cap;
m_Cap = new CvCapture_FFMPEG;
//m_Cap->open("rtsp://159.99.251.194/");
m_Cap->open("r.mp4");
updateSize();
m_Mutex.unlock();
continue;
}
m_Cap->retrieveFrame(0, &pData, &step, &width, &height, &cn);
#if 0
/* Render the Data to Widget */
pRgb = SDL_CreateRGBSurfaceFrom(pData, width, height, 24, step,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x00000000 /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0x00000000 /* Alpha bit mask. */
#endif
);
pTex = SDL_CreateTextureFromSurface(m_SdlRender, pRgb);
SDL_FreeSurface(pRgb);
pRgb = NULL;
SDL_RenderClear(m_SdlRender);
SDL_RenderCopy(m_SdlRender, pTex, NULL, NULL);
SDL_RenderPresent(m_SdlRender);
SDL_DestroyTexture(pTex);
pTex = NULL;
#else
pixels = NULL;
SDL_LockTexture(m_pTex, NULL, &pixels, &pitch);
if (pixels)
memcpy(pixels, pData, width * height * cn);
SDL_UnlockTexture(m_pTex);
SDL_RenderClear(m_SdlRender);
SDL_RenderCopy(m_SdlRender, m_pTex, NULL, NULL);
SDL_RenderPresent(m_SdlRender);
m_Mutex.unlock();
#endif
Sleep(20);
}
}
void Texture::LoadTexture_fromSurface(const Surface& input_surface, const ScreenVideo& makerVideo, Rect& area_cut) throw(Error){
this->Clean();
if (makerVideo.m_renderer == nullptr)
throw Error("Texture", "LoadTexture_fromMemoryPage", "Impossibile caricare una texture con uno specifico renderer nullo!");
if (makerVideo.m_renderer != m_render) m_render = makerVideo.m_renderer;
if (input_surface.Is_Void()) return;
if (area_cut.Get_Xcomponent() < 0) area_cut.Set_Xcomponent(0);
if (area_cut.Get_Ycomponent() < 0) area_cut.Set_Ycomponent(0);
if (area_cut.Get_Wcomponent() < 0) area_cut.Set_Wcomponent(input_surface.Get_W() - area_cut.Get_Xcomponent());
if (area_cut.Get_Hcomponent() < 0) area_cut.Set_Hcomponent(input_surface.Get_H() - area_cut.Get_Ycomponent());
if (area_cut.Get_Wcomponent() + (size_t)area_cut.Get_Xcomponent() > input_surface.Get_W())
area_cut.Set_Wcomponent(input_surface.Get_W() - area_cut.Get_Xcomponent());
if (area_cut.Get_Hcomponent() + (size_t)area_cut.Get_Ycomponent() > input_surface.Get_H())
area_cut.Set_Hcomponent(input_surface.Get_H() - area_cut.Get_Ycomponent());
this->m_texture = SDL_CreateTexture(m_render, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING,
area_cut.Get_Wcomponent(), area_cut.Get_Hcomponent());
if (this->m_texture == nullptr)
throw Error("Texture", "LoadTexture_fromSurface", "Impossibile creare una texture grafica!\n%s", SDL_GetError());
void* data_texture;
int pitch_texture;
if (SDL_LockTexture(m_texture, NULL, &data_texture, &pitch_texture) != 0)
throw Error("Texture", "LoadTexture_fromSurface", "Impossibile scrivere la texture grafica!\n%s", SDL_GetError());
if (SDL_LockSurface(input_surface.m_surface) != 0){
SDL_UnlockTexture(m_texture);
throw Error("Texture", "LoadTexture_fromSurface", "Impossibile leggere la surface grafica!\n%s", SDL_GetError());
}
try{
Uint8* texture_pixelb = static_cast<Uint8*>(data_texture);
const Uint8* surface_pixelb = static_cast<Uint8*>(input_surface.m_surface->pixels) +
area_cut.Get_Ycomponent() * input_surface.m_surface->pitch +
area_cut.Get_Xcomponent() * input_surface.m_surface->format->BytesPerPixel;
const int row_size = area_cut.Get_Wcomponent() * input_surface.m_surface->format->BytesPerPixel;
for (register int row = 0; row < area_cut.Get_Hcomponent(); ++row){
memcpy(texture_pixelb, surface_pixelb, row_size);
texture_pixelb += pitch_texture;
surface_pixelb += input_surface.m_surface->pitch;
}
}
catch (const std::exception& err){
SDL_UnlockTexture(m_texture);
SDL_UnlockSurface(input_surface.m_surface);
throw Error("Texture", "LoadTexture_fromSurface", "Impossibile copiare i dati nella destinazione!\n%s", err.what());
}
SDL_UnlockSurface(input_surface.m_surface);
SDL_UnlockTexture(m_texture);
data_texture = nullptr;
m_w_size = area_cut.Get_Wcomponent();
m_h_size = area_cut.Get_Hcomponent();
m_w_size_scaled = m_w_size;
m_h_size_scaled = m_h_size;
m_drawnable_area.Set_AllComponent(0, 0, m_w_size, m_h_size);
m_alpha_mod = SDL_ALPHA_OPAQUE;
SDL_SetTextureBlendMode(m_texture, SDL_BLENDMODE_BLEND);
}
static int display(struct vidisp_st *st, const char *title,
const struct vidframe *frame)
{
void *pixels;
uint8_t *p;
int pitch, ret;
unsigned i, h;
if (!vidsz_cmp(&st->size, &frame->size)) {
if (st->size.w && st->size.h) {
info("sdl: reset size: %u x %u ---> %u x %u\n",
st->size.w, st->size.h,
frame->size.w, frame->size.h);
}
sdl_reset(st);
}
if (!st->window) {
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_INPUT_FOCUS;
char capt[256];
if (st->fullscreen)
flags |= SDL_WINDOW_FULLSCREEN;
if (title) {
re_snprintf(capt, sizeof(capt), "%s - %u x %u",
title, frame->size.w, frame->size.h);
}
else {
re_snprintf(capt, sizeof(capt), "%u x %u",
frame->size.w, frame->size.h);
}
st->window = SDL_CreateWindow(capt,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
frame->size.w, frame->size.h,
flags);
if (!st->window) {
warning("sdl: unable to create sdl window: %s\n",
SDL_GetError());
return ENODEV;
}
st->size = frame->size;
SDL_RaiseWindow(st->window);
SDL_SetWindowBordered(st->window, true);
SDL_ShowWindow(st->window);
}
if (!st->renderer) {
Uint32 flags = 0;
flags |= SDL_RENDERER_ACCELERATED;
flags |= SDL_RENDERER_PRESENTVSYNC;
st->renderer = SDL_CreateRenderer(st->window, -1, flags);
if (!st->renderer) {
warning("sdl: unable to create renderer: %s\n",
SDL_GetError());
return ENOMEM;
}
}
if (!st->texture) {
st->texture = SDL_CreateTexture(st->renderer,
SDL_PIXELFORMAT_IYUV,
SDL_TEXTUREACCESS_STREAMING,
frame->size.w, frame->size.h);
if (!st->texture) {
warning("sdl: unable to create texture: %s\n",
SDL_GetError());
return ENODEV;
}
}
ret = SDL_LockTexture(st->texture, NULL, &pixels, &pitch);
if (ret != 0) {
warning("sdl: unable to lock texture (ret=%d)\n", ret);
return ENODEV;
}
p = pixels;
for (i=0; i<3; i++) {
const uint8_t *s = frame->data[i];
const unsigned stp = frame->linesize[0] / frame->linesize[i];
const unsigned sz = frame->size.w / stp;
for (h = 0; h < frame->size.h; h += stp) {
memcpy(p, s, sz);
s += frame->linesize[i];
p += (pitch / stp);
}
}
SDL_UnlockTexture(st->texture);
/* Blit the sprite onto the screen */
SDL_RenderCopy(st->renderer, st->texture, NULL, NULL);
/* Update the screen! */
SDL_RenderPresent(st->renderer);
return 0;
}
Texture::LockedPixels::LockedPixels(Texture* texture, int x, int y, int width, int height)
: m_texture(texture), m_x(x), m_y(y), m_width(width), m_height(height)
{
SDL_Rect rect{ x, y, width, height };
SDL_LockTexture(m_texture->m_texture.get(), &rect, &m_pixels, &m_pitch);
}
int main(int argc, char *argv[])
{
coordinates coord; // Coodinates Structure
depth depth;
color colorsIn[2048]; // Colors array
int numColors = 0; // Number of colors to use in color array
float colorPower = .3; // Power exponent to use for color selection
int colorStart = 0xFF0000, colorEnd = 0xFFFF00; // Default color gradient settings
char *filename = "mandelbrot.png"; // Default PNG output name
int i; // Misc variables
bool noWindow = false; // Default flag for no-window mode
// Set default coordinates before reading in args
coord.x = -2; // Default Start Coordinates
coord.y = 2;
coord.xR = 4; // Default Range Coordinates
coord.yR = 4;
coord.width = -1; // Invalid pixel size, to be set later
coord.height = -1;
depth.d = 100; // Default Depth level of Mandelbrot Calculation
depth.automatic = true;
// Generate default gradient first
genGradient(colorsIn, &numColors, colorStart, colorEnd);
// Parse Arguments
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "--width") == 0)
{
coord.width = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--height") == 0)
{
coord.height = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--depth") == 0)
{
depth.automatic = false;
depth.d = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--coords") == 0)
{
coord.x = arg_check_float(argc, argv, i, 1);
coord.y = arg_check_float(argc, argv, i, 2);
coord.xR = arg_check_float(argc, argv, i, 3);
coord.yR = arg_check_float(argc, argv, i, 4);
i+=4;
}
else if (strcmp(argv[i], "--spectrum") == 0)
{
genSpectrum(colorsIn, &numColors);
colorPower = .7;
}
else if (strcmp(argv[i], "--random") == 0)
{
genRandom(colorsIn, &numColors);
colorPower = 1;
}
else if (strcmp(argv[i], "--gradient") == 0)
{
colorStart = arg_check_int(argc, argv, i, 1, 16);
colorEnd = arg_check_int(argc, argv, i, 2, 16);
genGradient(colorsIn, &numColors, colorStart, colorEnd);
i+=2;
}
else if (strcmp(argv[i], "-o") == 0)
{
filename = argv[i+1];
i++;
}
else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 )
{
help();
}
else if (strcmp(argv[i], "-nw") == 0 )
{
noWindow = true;
}
else
{
errx(EXIT_FAILURE, "Unknown argument, \"%s\".", argv[i]);
}
}
// Make proportional image if only one dimension is specified
// Set to default width and height if not specified
if (coord.height < 0 && coord.width > 0) coord.height = coord.width / coord.xR * coord.yR;
else if (coord.height > 0 && coord.width < 0) coord.width = coord.height / coord.yR * coord.xR;
else if (coord.height < 0 && coord.width < 0) coord.width = coord.height = 1024;
coord.xS = coord.xR/coord.width; // X Step Value
coord.yS = coord.yR/coord.height; // Y Step Value
// Create final array of colors to use that is scaled to the depth that is selected
color colors[2048];
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
// If no window mode, just output file and exit
if (noWindow)
{
generate_png(coord, depth.d, filename, colors, numColors);
return 0;
}
// Set up SDL
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* Main_Window;
SDL_Renderer* Main_Renderer;
Main_Window = SDL_CreateWindow("Mandelbrot", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, coord.width, coord.height, SDL_WINDOW_RESIZABLE);
Main_Renderer = SDL_CreateRenderer(Main_Window, -1, SDL_RENDERER_ACCELERATED);
SDL_Texture *texture = SDL_CreateTexture(Main_Renderer, SDL_PIXELFORMAT_RGBX8888, SDL_TEXTUREACCESS_STREAMING, coord.width, coord.height);
int pitch;
void *pixels;
if (SDL_LockTexture(texture, NULL, &pixels, &pitch) != 0)
errx(EXIT_FAILURE, "SDL_LockTexture: %s", SDL_GetError());
//uint32_t (*pixel)[coord.height][pitch/sizeof(uint32_t)] = pixels;
// Set up struct for tracking mouse movement
mouse mouseTracker;
mouseTracker.down = false;
//Main Loop
int maxRender = 2;
int needsRender = maxRender;
while (1)
{
// Render Loop
if (needsRender > 0)
{
uint32_t (*pixel)[coord.height][pitch/sizeof(uint32_t)] = pixels;
//unsigned long long timer = utime(); //DEBUG - Start Timer
float pixelSize = pow(2, --needsRender);
//printf("%d %d\n", needsRender, pixelSize);
coordinates scaledCoord;
scaledCoord.width = coord.width / pixelSize;
scaledCoord.height = coord.height / pixelSize;
scaledCoord.x = coord.x;
scaledCoord.xR = coord.xR;
scaledCoord.xS = scaledCoord.xR/scaledCoord.width;
scaledCoord.y = coord.y;
scaledCoord.yR = coord.yR;
scaledCoord.yS = scaledCoord.yR/scaledCoord.height; // y step value
SDL_Rect srcrect = {0, 0, scaledCoord.width, scaledCoord.height};
for (int y=0; y<scaledCoord.height; y++)
for (int x=0; x<scaledCoord.width; x++)
{
double xValue = scaledCoord.x + (x * scaledCoord.xS);
double yValue = scaledCoord.y - (y * scaledCoord.yS);
int result = mandel(xValue, yValue, depth.d);
int finalColor = 0;
if (result != -1)
finalColor = colors[result].hex << 8;
(*pixel)[y][x] = finalColor;
}
SDL_UnlockTexture(texture);
SDL_RenderCopy(Main_Renderer, texture, &srcrect, NULL);
//printf("%llu - Finish Render\n", utime()-timer); //DEBUG - End Timer
SDL_RenderPresent(Main_Renderer);
}
SDL_Event e;
//SDL_WaitEvent(&e);
if (SDL_WaitEventTimeout(&e, 10) == 0) continue;
if (e.type == SDL_MOUSEWHEEL)
{
if (e.wheel.y > 0)
coord_zoom(&coord, 1);
else
coord_zoom(&coord, -1);
if (depth.automatic == true)
{
adjust_depth(&coord, &depth);
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
}
needsRender = maxRender;
}
if (e.type == SDL_WINDOWEVENT)
if (e.window.event == SDL_WINDOWEVENT_RESIZED)
{
// Adjust view to new size
coord.width = e.window.data1;
coord.height = e.window.data2;
coord.xR = coord.width * coord.xS;
coord.yR = coord.height * coord.yS;
// Destroy old texture
SDL_DestroyTexture(texture);
// Make New Texture
texture = SDL_CreateTexture(Main_Renderer, SDL_PIXELFORMAT_RGBX8888, SDL_TEXTUREACCESS_STREAMING, coord.width, coord.height);
// Lock with new texture
if (SDL_LockTexture(texture, NULL, &pixels, &pitch) != 0)
errx(EXIT_FAILURE, "SDL_LockTexture: %s", SDL_GetError());
// Rerender
needsRender = maxRender;
}
if (e.type == SDL_MOUSEBUTTONDOWN)
if (e.button.state == SDL_PRESSED)
{
mouseTracker.mouseX = e.motion.x;
mouseTracker.mouseY = e.motion.y;
mouseTracker.coordX = coord.x;
mouseTracker.coordY = coord.y;
mouseTracker.down = true;
}
if (e.type == SDL_MOUSEBUTTONUP)
if (e.button.state == SDL_RELEASED)
mouseTracker.down = false;
if (e.type == SDL_MOUSEMOTION && mouseTracker.down == true)
{
coord.x = mouseTracker.coordX + ((mouseTracker.mouseX - e.motion.x) * coord.xS);
coord.y = mouseTracker.coordY - ((mouseTracker.mouseY - e.motion.y) * coord.yS);
needsRender = maxRender;
}
if (e.type == SDL_KEYUP)
{
if (e.key.keysym.sym == SDLK_p)
print_coords(&coord, &depth);
if (e.key.keysym.sym == SDLK_s)
generate_png(coord, depth.d, filename, colors, numColors);
if (e.key.keysym.sym == SDLK_EQUALS || e.key.keysym.sym == SDLK_MINUS)
{
depth.automatic = false;
if (e.key.keysym.sym == SDLK_EQUALS)
depth.d += 5;
if (e.key.keysym.sym == SDLK_MINUS)
if (depth.d > 5) depth.d -= 5;
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
needsRender = maxRender;
}
}
if (e.type == SDL_QUIT)
{
SDL_Log("Program quit after %i ticks", e.quit.timestamp);
break;
}
}
return 0;
}
int
main(int argc, char *argv[])
{
ps3eye_context ctx(640, 480, 30);
if (!ctx.hasDevices()) {
printf("No PS3 Eye camera connected\n");
return EXIT_FAILURE;
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("Failed to initialize SDL: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
SDL_Window *window = SDL_CreateWindow(
"PS3 Eye - SDL 2", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, 0);
if (window == NULL) {
printf("Failed to create window: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1,
SDL_RENDERER_PRESENTVSYNC);
if (renderer == NULL) {
printf("Failed to create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return EXIT_FAILURE;
}
SDL_RenderSetLogicalSize(renderer, ctx.frame_width, ctx.frame_height);
print_renderer_info(renderer);
SDL_Texture *video_tex = SDL_CreateTexture(
renderer, SDL_PIXELFORMAT_YUY2, SDL_TEXTUREACCESS_STREAMING,
ctx.frame_width, ctx.frame_height);
if (video_tex == NULL) {
printf("Failed to create video texture: %s\n", SDL_GetError());
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_FAILURE;
}
ctx.eye = ps3eye_open(0, ctx.frame_width, ctx.frame_height, ctx.frame_rate);
if (ctx.eye == NULL)
{
printf("Failed to initialize camera: %s\n");
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_FAILURE;
}
ps3eye_set_flip(ctx.eye, true, false);
printf("Camera mode: %dx%d@%d\n", ctx.frame_width, ctx.frame_height, ctx.frame_rate);
SDL_Event e;
void *video_tex_pixels;
int pitch;
while (ctx.running) {
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
ctx.running = false;
}
}
// TODO: Proper thread signalling to wait for next available buffer
SDL_Delay(10);
int row_bytes = 0;
uint8_t *frame_data = ps3eye_grab_frame(ctx.eye, &row_bytes);
int frame_data_size = row_bytes * ctx.frame_height;
if (frame_data != NULL)
{
SDL_LockTexture(video_tex, NULL, &video_tex_pixels, &pitch);
memcpy(video_tex_pixels, frame_data, frame_data_size);
SDL_UnlockTexture(video_tex);
}
SDL_RenderCopy(renderer, video_tex, NULL, NULL);
SDL_RenderPresent(renderer);
}
ps3eye_close(ctx.eye);
SDL_DestroyTexture(video_tex);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
ps3eye_context ctx(320, 240, 187);
if (!ctx.hasDevices()) {
printf("No PS3 Eye camera connected\n");
return EXIT_FAILURE;
}
ctx.eye->setFlip(true); /* mirrored left-right */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("Failed to initialize SDL: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
SDL_Window *window = SDL_CreateWindow(
"PS3 Eye - SDL 2", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, 0);
if (window == NULL) {
printf("Failed to create window: %s\n", SDL_GetError());
return EXIT_FAILURE;
}
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1,
SDL_RENDERER_PRESENTVSYNC);
if (renderer == NULL) {
printf("Failed to create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return EXIT_FAILURE;
}
SDL_RenderSetLogicalSize(renderer, ctx.eye->getWidth(),
ctx.eye->getHeight());
print_renderer_info(renderer);
SDL_Texture *video_tex = SDL_CreateTexture(
renderer, SDL_PIXELFORMAT_YUY2, SDL_TEXTUREACCESS_STREAMING,
ctx.eye->getWidth(), ctx.eye->getHeight());
if (video_tex == NULL) {
printf("Failed to create video texture: %s\n", SDL_GetError());
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_FAILURE;
}
SDL_Thread *thread = SDL_CreateThread(ps3eye_cam_thread, "ps3eye_cam",
(void *)&ctx);
SDL_Event e;
yuv422_buffer_t *last;
void *video_tex_pixels;
int pitch;
while (ctx.running) {
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
ctx.running = false;
}
}
// TODO: Proper thread signalling to wait for next available buffer
SDL_Delay(10);
last = ctx.buffers.read();
SDL_LockTexture(video_tex, NULL, &video_tex_pixels, &pitch);
memcpy(video_tex_pixels, last->pixels, last->size);
SDL_UnlockTexture(video_tex);
SDL_RenderCopy(renderer, video_tex, NULL, NULL);
SDL_RenderPresent(renderer);
}
SDL_WaitThread(thread, NULL);
SDL_DestroyTexture(video_tex);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_SUCCESS;
}
static int display(struct vidisp_st *st, const char *title,
const struct vidframe *frame)
{
void *pixels;
uint8_t *d;
int dpitch, ret;
unsigned i, h;
uint32_t format;
if (!st || !frame)
return EINVAL;
format = match_fmt(frame->fmt);
if (format == SDL_PIXELFORMAT_UNKNOWN) {
warning("sdl2: pixel format not supported (%s)\n",
vidfmt_name(frame->fmt));
return ENOTSUP;
}
if (!vidsz_cmp(&st->size, &frame->size) || frame->fmt != st->fmt) {
if (st->size.w && st->size.h) {
info("sdl: reset size:"
" %s %u x %u ---> %s %u x %u\n",
vidfmt_name(st->fmt), st->size.w, st->size.h,
vidfmt_name(frame->fmt),
frame->size.w, frame->size.h);
}
sdl_reset(st);
}
if (!st->window) {
char capt[256];
st->flags = SDL_WINDOW_SHOWN | SDL_WINDOW_INPUT_FOCUS;
if (st->fullscreen)
st->flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
if (title) {
re_snprintf(capt, sizeof(capt), "%s - %u x %u",
title, frame->size.w, frame->size.h);
}
else {
re_snprintf(capt, sizeof(capt), "%u x %u",
frame->size.w, frame->size.h);
}
st->window = SDL_CreateWindow(capt,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
frame->size.w, frame->size.h,
st->flags);
if (!st->window) {
warning("sdl: unable to create sdl window: %s\n",
SDL_GetError());
return ENODEV;
}
st->size = frame->size;
st->fmt = frame->fmt;
SDL_RaiseWindow(st->window);
SDL_SetWindowBordered(st->window, true);
SDL_ShowWindow(st->window);
}
if (!st->renderer) {
Uint32 flags = 0;
flags |= SDL_RENDERER_ACCELERATED;
flags |= SDL_RENDERER_PRESENTVSYNC;
st->renderer = SDL_CreateRenderer(st->window, -1, flags);
if (!st->renderer) {
warning("sdl: unable to create renderer: %s\n",
SDL_GetError());
return ENOMEM;
}
}
if (!st->texture) {
st->texture = SDL_CreateTexture(st->renderer,
format,
SDL_TEXTUREACCESS_STREAMING,
frame->size.w, frame->size.h);
if (!st->texture) {
warning("sdl: unable to create texture: %s\n",
SDL_GetError());
return ENODEV;
}
}
ret = SDL_LockTexture(st->texture, NULL, &pixels, &dpitch);
if (ret != 0) {
warning("sdl: unable to lock texture (ret=%d)\n", ret);
return ENODEV;
}
d = pixels;
for (i=0; i<3; i++) {
const uint8_t *s = frame->data[i];
unsigned sz, dsz, hstep, wstep;
if (!frame->data[i] || !frame->linesize[i])
break;
hstep = i==0 ? 1 : 2;
wstep = i==0 ? 1 : chroma_step(frame->fmt);
dsz = dpitch / wstep;
sz = min(frame->linesize[i], dsz);
for (h = 0; h < frame->size.h; h += hstep) {
memcpy(d, s, sz);
s += frame->linesize[i];
d += dsz;
}
}
SDL_UnlockTexture(st->texture);
/* Blit the sprite onto the screen */
SDL_RenderCopy(st->renderer, st->texture, NULL, NULL);
/* Update the screen! */
SDL_RenderPresent(st->renderer);
return 0;
}
int main(int argc, char *argv[]) {
const unsigned int cameraIndex = 0u;
const unsigned int numImagesPerFPSMeasurement = 240u;
const int windowWidth = 1440;
const int windowHeight = 900;
const char cascadeFilename[] = "haarcascade_frontalface_alt.xml";
const double detectionScaleFactor = 1.25;
const int detectionMinNeighbours = 4;
const int detectionFlags = CV_HAAR_SCALE_IMAGE;
const cv::Size detectionMinSize(120, 120);
const cv::Size detectionMaxSize;
const cv::Scalar detectionDrawColor(255.0, 0.0, 255.0);
char strBuffer[256u];
const size_t strBufferSize = 256u;
int matType;
cv::Mat equalizedGrayMat;
#ifdef _WIN32
snprintf(strBuffer, strBufferSize, "%s/../%s", argv[0], cascadeFilename);
cv::CascadeClassifier detector(strBuffer);
#else
cv::CascadeClassifier detector(cascadeFilename);
#endif
if (detector.empty()) {
snprintf(strBuffer, strBufferSize, "%s could not be loaded.",
cascadeFilename);
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Failed to Load Cascade File", strBuffer, NULL);
return EXIT_FAILURE;
}
std::vector<cv::Rect> detectionRects;
fc2Error error;
fc2Image image;
error = fc2CreateImage(&image);
if (error != FC2_ERROR_OK) {
showFC2Error(error);
return EXIT_FAILURE;
}
fc2Context context;
error = fc2CreateContext(&context);
if (error != FC2_ERROR_OK) {
showFC2Error(error);
return EXIT_FAILURE;
}
fc2PGRGuid cameraGUID;
error = fc2GetCameraFromIndex(context, cameraIndex, &cameraGUID);
if (error != FC2_ERROR_OK) {
showFC2Error(error);
return EXIT_FAILURE;
}
error = fc2Connect(context, &cameraGUID);
if (error != FC2_ERROR_OK) {
showFC2Error(error);
return EXIT_FAILURE;
}
error = fc2StartCapture(context);
if (error != FC2_ERROR_OK) {
fc2Disconnect(context);
showFC2Error(error);
return EXIT_FAILURE;
}
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fc2StopCapture(context);
fc2Disconnect(context);
showSDLError();
return EXIT_FAILURE;
}
SDL_Window *window = SDL_CreateWindow(
"LookSpry", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
windowWidth, windowHeight, 0u);
if (window == NULL) {
fc2StopCapture(context);
fc2Disconnect(context);
showSDLError();
return EXIT_FAILURE;
}
SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0u);
if (renderer == NULL) {
fc2StopCapture(context);
fc2Disconnect(context);
SDL_DestroyWindow(window);
showSDLError();
return EXIT_FAILURE;
}
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
if (strcmp(rendererInfo.name, "direct3d") == 0) {
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
} else if (strcmp(rendererInfo.name, "opengl") == 0) {
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
}
snprintf(strBuffer, strBufferSize, "LookSpry | %s", rendererInfo.name);
SDL_SetWindowTitle(window, strBuffer);
SDL_Texture *videoTex = NULL;
void *videoTexPixels;
int pitch;
clock_t startTicks = clock();
clock_t endTicks;
unsigned int numImagesCaptured = 0u;
bool running = true;
bool detecting = true;
bool mirroring = true;
SDL_Event event;
while (running) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
break;
} else if (event.type == SDL_KEYUP) {
switch(event.key.keysym.sym) {
// When 'd' is pressed, start or stop [d]etection.
case SDLK_d:
detecting = !detecting;
break;
// When 'm' is pressed, [m]irror or un-mirror the video.
case SDLK_m:
mirroring = !mirroring;
break;
default:
break;
}
}
}
error = fc2RetrieveBuffer(context, &image);
if (error != FC2_ERROR_OK) {
fc2Disconnect(context);
SDL_DestroyTexture(videoTex);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
showFC2Error(error);
return EXIT_FAILURE;
}
if (videoTex == NULL) {
equalizedGrayMat.create(image.rows, image.cols, CV_8UC1);
SDL_RenderSetLogicalSize(renderer, image.cols, image.rows);
Uint32 videoTexPixelFormat;
switch (image.format) {
// For monochrome capture modes, plan to render captured data to the Y
// plane of a planar YUV texture.
case FC2_PIXEL_FORMAT_RAW8:
case FC2_PIXEL_FORMAT_MONO8:
videoTexPixelFormat = SDL_PIXELFORMAT_YV12;
matType = CV_8UC1;
break;
// For color capture modes, plan to render captured data to the entire
// space of a texture in a matching color format.
case FC2_PIXEL_FORMAT_422YUV8:
videoTexPixelFormat = SDL_PIXELFORMAT_UYVY;
matType = CV_8UC2;
break;
case FC2_PIXEL_FORMAT_RGB:
videoTexPixelFormat = SDL_PIXELFORMAT_RGB24;
matType = CV_8UC3;
break;
case FC2_PIXEL_FORMAT_BGR:
videoTexPixelFormat = SDL_PIXELFORMAT_BGR24;
matType = CV_8UC3;
break;
default:
fc2StopCapture(context);
fc2Disconnect(context);
SDL_DestroyTexture(videoTex);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Unsupported FlyCapture2 Pixel Format",
"LookSpry supports RAW8, MONO8, 422YUV8, RGB, and BGR.", NULL);
return EXIT_FAILURE;
}
videoTex = SDL_CreateTexture(
renderer, videoTexPixelFormat, SDL_TEXTUREACCESS_STREAMING,
image.cols, image.rows);
if (videoTex == NULL) {
fc2StopCapture(context);
fc2Disconnect(context);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
showSDLError();
return EXIT_FAILURE;
}
snprintf(
strBuffer, strBufferSize, "LookSpry | %s | %dx%d --> %dx%d",
rendererInfo.name, image.cols, image.rows, windowWidth,
windowHeight);
SDL_SetWindowTitle(window, strBuffer);
}
cv::Mat srcMat(image.rows, image.cols, matType, image.pData, image.stride);
if (detecting) {
switch (image.format) {
// For monochrome capture modes, just equalize.
case FC2_PIXEL_FORMAT_RAW8:
case FC2_PIXEL_FORMAT_MONO8:
cv::equalizeHist(srcMat, equalizedGrayMat);
break;
// For color capture modes, convert to gray and equalize.
case FC2_PIXEL_FORMAT_422YUV8:
cv::cvtColor(srcMat, equalizedGrayMat, cv::COLOR_YUV2GRAY_UYVY);
cv::equalizeHist(equalizedGrayMat, equalizedGrayMat);
break;
case FC2_PIXEL_FORMAT_RGB:
cv::cvtColor(srcMat, equalizedGrayMat, cv::COLOR_RGB2GRAY);
cv::equalizeHist(equalizedGrayMat, equalizedGrayMat);
break;
case FC2_PIXEL_FORMAT_BGR:
cv::cvtColor(srcMat, equalizedGrayMat, cv::COLOR_BGR2GRAY);
cv::equalizeHist(equalizedGrayMat, equalizedGrayMat);
break;
default:
break;
}
// Run the detector on the equalized image.
detector.detectMultiScale(
equalizedGrayMat, detectionRects, detectionScaleFactor,
detectionMinNeighbours, detectionFlags, detectionMinSize,
detectionMaxSize);
// Draw the resulting detection rectangles on the original image.
for (cv::Rect detectionRect : detectionRects) {
cv::rectangle(srcMat, detectionRect, detectionDrawColor);
}
}
SDL_LockTexture(videoTex, NULL, &videoTexPixels, &pitch);
switch (image.format) {
case FC2_PIXEL_FORMAT_RAW8:
case FC2_PIXEL_FORMAT_MONO8:
// Make the planar YUV video gray by setting all bytes in its U and V
// planes to 128 (the middle of the range).
memset(((unsigned char *)videoTexPixels + image.dataSize), 128,
image.dataSize / 2u);
break;
default:
break;
}
if (mirroring) {
// Flip the image data while copying it to the texture.
cv::Mat dstMat(image.rows, image.cols, matType, videoTexPixels,
image.stride);
cv::flip(srcMat, dstMat, 1);
} else {
// Copy the image data, as-is, to the texture.
// Note that the PointGrey image and srcMat have pointers to the same
// data, so the following code does reference the data that we modified
// earlier via srcMat.
memcpy(videoTexPixels, image.pData, image.dataSize);
}
SDL_UnlockTexture(videoTex);
SDL_RenderCopy(renderer, videoTex, NULL, NULL);
SDL_RenderPresent(renderer);
numImagesCaptured++;
if (numImagesCaptured >= numImagesPerFPSMeasurement) {
endTicks = clock();
snprintf(
strBuffer, strBufferSize, "LookSpry | %s | %dx%d --> %dx%d | %ld FPS",
rendererInfo.name, image.cols, image.rows, windowWidth,
windowHeight,
numImagesCaptured * CLOCKS_PER_SEC / (endTicks - startTicks));
SDL_SetWindowTitle(window, strBuffer);
startTicks = endTicks;
numImagesCaptured = 0u;
}
}
fc2StopCapture(context);
fc2Disconnect(context);
SDL_DestroyTexture(videoTex);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
return EXIT_SUCCESS;
}
void
Draw(const unsigned char* aImage, int size, int aWidth, int aHeight)
{
if (!sState) {
return;
}
if (!sState->window) {
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
return;
}
sState->window = SDL_CreateWindow("WebRTC Player",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
aWidth, aHeight,
0);
// SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
if (!sState->window) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create window: %s\n", SDL_GetError());
quit(3);
}
sState->renderer = SDL_CreateRenderer(sState->window, -1, 0);
if (!sState->renderer) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create renderer: %s\n", SDL_GetError());
quit(4);
}
sState->width = aWidth;
sState->height = aHeight;
}
if (!sState->texture) {
sState->texture = SDL_CreateTexture(sState->renderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING, aWidth, aHeight);
if (!sState->texture) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError());
quit(5);
}
}
if ((sState->width != aWidth) || (sState->height != aHeight)) {
if (sState->texture) {
SDL_DestroyTexture(sState->texture); sState->texture = 0;
}
sState->texture = SDL_CreateTexture(sState->renderer,
SDL_PIXELFORMAT_IYUV,
SDL_TEXTUREACCESS_STREAMING,
aWidth, aHeight);
SDL_SetWindowSize(sState->window, aWidth, aHeight);
sState->width = aWidth;
sState->height = aHeight;
}
Uint8* dst = nullptr;
void* pixels = nullptr;
int pitch = 0;
if (SDL_LockTexture(sState->texture, NULL, &pixels, &pitch) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't lock texture: %s\n", SDL_GetError());
quit(5);
}
dst = (Uint8*)pixels;
memcpy(dst, aImage, size);
SDL_UnlockTexture(sState->texture);
SDL_RenderClear(sState->renderer);
SDL_RenderCopy(sState->renderer, sState->texture, NULL, NULL);
SDL_RenderPresent(sState->renderer);
}
//-----------------------------------------------------------------------------
int SDL_main(int argc, char *argv[]) {
// NOTE: check for the correct number of arguements
if(argc<2) {
fprintf(stderr, "Error: need a level name.\n");
return -1;
}
// NOTE: add the sqlite db to the levels directory
char filename[0xFF];
sprintf(filename, "levels/%s.db", argv[1]);
// NOTE: open database connection
if(sqlite3_open_v2(filename, &db, SQLITE_OPEN_READONLY, NULL)) {
fprintf(stderr, "sqlite3_open: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
/* === */
start();
/* === */
int wallSprite00Inds[2*3] = {
03, 04,
35, 36,
67, 68
};
SDL_Color wall00Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite00 = buildSprite(2, 3, wall00Color, wallSprite00Inds);
int floorSprite00Inds[2*3] = {
17, 18,
49, 50,
81, 82
};
SDL_Color floorSprite00Color = {0x33,0x33,0x33,0xFF};
SDL_Surface *floorSprite00 = buildSprite(2, 3, floorSprite00Color, floorSprite00Inds);
int doorSprite00Inds[2*3] = {
29, 30,
61, 62,
93, 94
};
SDL_Color doorSprite00Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *doorSprite00 = buildSprite(2, 3, doorSprite00Color, doorSprite00Inds);
int wallSprite01Inds[2*3] = {
97, 98,
129, 130,
161, 162
};
SDL_Color wall01Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite01 = buildSprite(2, 3, wall01Color, wallSprite01Inds);
int wallSprite02Inds[2*3] = {
105, 106,
137, 138,
169, 170
};
SDL_Color wallSprite02Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite02 = buildSprite(2, 3, wallSprite02Color, wallSprite02Inds);
/* === */
while(running) {
/* === */
pollInput();
SDL_RenderClear(renderer);
SDL_FillRect(screen, 0, 0x00);
/* === */
loadTiles();
SDL_Rect tempRect = {
0, 0, SPRITE_W*2, SPRITE_H*3
};
int i, j;
for(j=0; j<12; j++) {
for(i=0; i<30; i++) {
tempRect.x = SPRITE_W*2*i;
tempRect.y = SPRITE_H*3*j;
switch(lvl.tiles[j][i]) {
case 0x01: {
SDL_BlitSurface(wallSprite00, NULL, screen, &tempRect);
} break;
case 0x02: {
SDL_BlitSurface(doorSprite00, NULL, screen, &tempRect);
} break;
case 0x03: {
SDL_BlitSurface(wallSprite01, NULL, screen, &tempRect);
} break;
case 0x04: {
SDL_BlitSurface(wallSprite02, NULL, screen, &tempRect);
} break;
default: {
SDL_BlitSurface(floorSprite00, NULL, screen, &tempRect);
} break;
}
}
}
/* === */
int pitch;
void *pixels;
// NOTE: get the pixels for the screen texture
SDL_LockTexture(texture, NULL, &pixels, &pitch);
// NOTE: set the pixels for the screen texture
SDL_ConvertPixels(
screen->w,
screen->h,
screen->format->format,
screen->pixels,
screen->pitch,
SDL_PIXELFORMAT_RGBA8888,
pixels, pitch
);
// NOTE: lock the texture so that it may be presented
SDL_UnlockTexture(texture);
// NOTE: present the texture
SDL_RenderCopy(renderer, texture, NULL, NULL);
SDL_RenderPresent(renderer);
SDL_Delay(10);
/* === */
}
/* === */
SDL_FreeSurface(wallSprite00);
wallSprite00 = NULL;
SDL_FreeSurface(floorSprite00);
floorSprite00 = NULL;
SDL_FreeSurface(doorSprite00);
doorSprite00 = NULL;
SDL_FreeSurface(wallSprite01);
wallSprite01 = NULL;
SDL_FreeSurface(wallSprite02);
wallSprite02 = NULL;
/* === */
quit();
/* === */
// NTOE: close the database connection
sqlite3_close(db);
db = NULL;
fclose(stderr);
return 0;
}
int main(void) {
#if SDL
SDL_Event event;
SDL_Rect rect;
SDL_Renderer *renderer;
SDL_Window *window;
# if STREAMING
SDL_Texture *texture = NULL;
void *pixels;
Uint8 *base;
/* TODO: is it mandatory to use this? Maybe SDL_LockTexture
* will make the array non continuous to improve alignment? */
int pitch;
# endif
#else
double sum;
#endif
const unsigned int WINDOW_WIDTH = 600;
const unsigned int WINDOW_HEIGHT = WINDOW_WIDTH;
const double SPEED = (WINDOW_WIDTH / 10.0);
const double CENTER_X = WINDOW_WIDTH / 2.0;
const double CENTER_Y = WINDOW_HEIGHT / 2.0;
const double PERIOD = (WINDOW_WIDTH / 10.0);
const double PI2 = 2.0 * acos(-1.0);
double dt;
double fps_dt;
double fps_last_time;
double initial_time;
double t;
int nframes;
float z;
unsigned int x;
unsigned int xc;
unsigned int y;
unsigned int yc;
#if SDL
SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
SDL_CreateWindowAndRenderer(WINDOW_WIDTH, WINDOW_WIDTH, 0, &window, &renderer);
# if STREAMING
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, WINDOW_WIDTH, WINDOW_HEIGHT);
# endif
#endif
initial_time = get_secs();
fps_last_time = initial_time;
nframes = 0;
while (1) {
t = get_secs();
dt = t - initial_time;
#if STREAMING
SDL_LockTexture(texture, NULL, &pixels, &pitch);
#endif
for (x = 0; x < WINDOW_WIDTH; x++) {
for (y = 0; y < WINDOW_HEIGHT; y++) {
xc = CENTER_X - x;
yc = CENTER_Y - y;
z = COLOR_MAX * 0.5 * (1.0 + (sin(PI2 * (sqrt(xc*xc + yc*yc) - SPEED * dt) / PERIOD)));
#if SDL
# if STREAMING
base = ((Uint8 *)pixels) + (4 * (x * WINDOW_WIDTH + y));
base[0] = 0;
base[1] = 0;
base[2] = z;
base[3] = COLOR_MAX;
# else
SDL_SetRenderDrawColor(renderer, z, 0, 0, COLOR_MAX);
SDL_RenderDrawPoint(renderer, x, y);
# endif
#else
sum += z;
#endif
}
}
#if SDL
# if STREAMING
SDL_UnlockTexture(texture);
SDL_RenderCopy(renderer, texture, NULL, NULL);
# endif
SDL_RenderPresent(renderer);
#endif
nframes++;
fps_dt = t - fps_last_time;
if (fps_dt > 0.25) {
/* Produce a side-effect for the non-SDL version so that
* it does not get optimized away. */
printf("FPS = %f\n", nframes / fps_dt);
fps_last_time = t;
nframes = 0;
#if !SDL
printf("%f\n", sum);
#endif
}
#if SDL
if (SDL_PollEvent(&event) && event.type == SDL_QUIT)
break;
#endif
}
#if SDL
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
#endif
return EXIT_SUCCESS;
}
void run() {
std::cout << "[DIS] Initializing Video Display System.\n";
pCodecCtx = media->decode->getpCodecCtx();
pFrame = media->decode->getpFrame();
pFrame_BGR24 = media->opencv->getpFrame_BGR24();
// 2.1.1. Prepare format conversion for diplaying with SDL
// Allocate an AVFrame structure
pFrame_YUV420P = avcodec_alloc_frame();
if (pFrame_YUV420P == NULL) {
std::cout << "[DIS] Could not allocate pFrame_YUV420P\n";
exit(1);
}
// Determine required buffer size and allocate buffer
buffer_YUV420P = (uint8_t *) malloc(avpicture_get_size(PIX_FMT_YUV420P,
pCodecCtx->width, pCodecCtx->height));
// Assign buffer to image planes
avpicture_fill((AVPicture *) pFrame_YUV420P, buffer_YUV420P,
PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
// format conversion context
pConvertCtx_YUV420P = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P,
SWS_SPLINE, NULL, NULL, NULL);
// 3.1.1 prepare SDL for YUV
// allocate window, renderer, texture
pWindow1 = SDL_CreateWindow("YUV", 0, 0, pCodecCtx->width, pCodecCtx->height, SDL_WINDOW_SHOWN);
pRenderer1 = SDL_CreateRenderer(pWindow1, -1, SDL_RENDERER_ACCELERATED);
bmpTex1 = SDL_CreateTexture(pRenderer1, SDL_PIXELFORMAT_YV12,
SDL_TEXTUREACCESS_STREAMING, pCodecCtx->width, pCodecCtx->height);
size1 = pCodecCtx->width * pCodecCtx->height;
if (pWindow1 == NULL | pRenderer1 == NULL | bmpTex1 == NULL) {
std::cout << "[DIS] Could not open window1: " << SDL_GetError() << std::endl;
exit(1);
}
// 3.2.1 prepare SDL for BGR
// allocate window, renderer, texture
pWindow2 = SDL_CreateWindow("BGR", pCodecCtx->width + 5, 0, pCodecCtx->width, pCodecCtx->height, SDL_WINDOW_SHOWN);
pRenderer2 = SDL_CreateRenderer(pWindow2, -1, SDL_RENDERER_ACCELERATED);
bmpTex2 = SDL_CreateTexture(pRenderer2, SDL_PIXELFORMAT_BGR24,
SDL_TEXTUREACCESS_STREAMING, pCodecCtx->width, pCodecCtx->height);
size2 = pCodecCtx->width * pCodecCtx->height * 3;
if (pWindow2 == NULL | pRenderer2 == NULL | bmpTex2 == NULL) {
std::cout << "[DIS] Could not open window2: " << SDL_GetError() << std::endl;
exit(1);
}
// 1.6. get video frames
while (!terminated) {
if (media->decode->frameDecoded) {
// 2.1.2. convert frame to YUV for Displaying
sws_scale(pConvertCtx_YUV420P, (const uint8_t * const*) pFrame->data, pFrame->linesize, 0,
pCodecCtx->height, pFrame_YUV420P->data, pFrame_YUV420P->linesize);
// 3.1.2. copy converted YUV to SDL 2.0 texture
SDL_LockTexture(bmpTex1, NULL, (void **) &pixels1, &pitch1);
memcpy(pixels1, pFrame_YUV420P->data[0], size1);
memcpy(pixels1 + size1, pFrame_YUV420P->data[2], size1 / 4);
memcpy(pixels1 + size1 * 5 / 4, pFrame_YUV420P->data[1], size1 / 4);
SDL_UnlockTexture(bmpTex1);
SDL_UpdateTexture(bmpTex1, NULL, pixels1, pitch1);
// refresh screen
SDL_RenderClear(pRenderer1);
SDL_RenderCopy(pRenderer1, bmpTex1, NULL, NULL);
SDL_RenderPresent(pRenderer1);
// 3.2.2. copy converted BGR to SDL 2.0 texture
SDL_LockTexture(bmpTex2, NULL, (void **) &pixels2, &pitch2);
memcpy(pixels2, pFrame_BGR24->data[0], size2);
SDL_UnlockTexture(bmpTex2);
SDL_UpdateTexture(bmpTex2, NULL, pixels2, pitch2);
// refresh screen
SDL_RenderClear(pRenderer2);
SDL_RenderCopy(pRenderer2, bmpTex2, NULL, NULL);
SDL_RenderPresent(pRenderer2);
}
// process user input
SDL_PollEvent(&event);
switch (event.type) {
case SDL_KEYDOWN:
// check for the keyboard state
switch (event.key.keysym.sym) {
// quit
case SDLK_ESCAPE:
media->display->terminated = true;
break;
// reset emergency
case SDLK_r:
media->command->flag_reset = true;
break;
// decode qr code from image
case SDLK_g:
media->opencv->save_image = true;
break;
case SDLK_h:
media->opencv->send_data = true;
break;
// trim sensors
case SDLK_BACKSPACE:
media->command->flag_trim = true;
break;
// land
case SDLK_SPACE:
media->command->flag_land = true;
break;
// toggle absolute control mode
case SDLK_t:
media->command->flag_absl = !(media->command->flag_absl);
break;
// toggle combined yaw mode
case SDLK_y:
media->command->flag_cYaw = !(media->command->flag_cYaw);
break;
// calibrate magnetometer
case SDLK_c:
media->command->flag_mgnt = true;
break;
// take off
case SDLK_RETURN:
media->command->flag_takeoff = true;
break;
default:
break;
}
break;
}
// check for the keyboard state for moving keys
Uint8 *state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_I] || state[SDL_SCANCODE_J] ||
state[SDL_SCANCODE_K] || state[SDL_SCANCODE_L] ||
state[SDL_SCANCODE_W] || state[SDL_SCANCODE_S] ||
state[SDL_SCANCODE_A] || state[SDL_SCANCODE_D] ||
state[SDL_SCANCODE_LSHIFT] || state[SDL_SCANCODE_RSHIFT]
) {
float mult;
float base = 0.015;
if (state[SDL_SCANCODE_LSHIFT] || state[SDL_SCANCODE_RSHIFT]) {
mult = 6;
} else {
mult = 1;
}
// W for ascend
if (state[SDL_SCANCODE_W]) {
if (media->command->arg3 < 0)
media->command->arg3 = 0;
media->command->arg3 += 2 * mult*base;
if (media->command->arg3 > 1)
media->command->arg3 = 1;
}
// S for descend
if (state[SDL_SCANCODE_S]) {
if (media->command->arg3 > 0)
media->command->arg3 = 0;
media->command->arg3 -= 2 * mult*base;
if (media->command->arg3 < -1)
media->command->arg3 = -1;
}
// D for move right
if (state[SDL_SCANCODE_D]) {
if (media->command->arg1 < 0)
media->command->arg1 = 0;
media->command->arg1 += mult*base;
if (media->command->arg1 > 1)
media->command->arg1 = 1;
}
// A for move left
if (state[SDL_SCANCODE_A]) {
if (media->command->arg1 > 0)
media->command->arg1 = 0;
media->command->arg1 -= mult*base;
if (media->command->arg1 < -1)
media->command->arg1 = -1;
}
// K for move backword
if (state[SDL_SCANCODE_K]) {
if (media->command->arg2 < 0)
media->command->arg2 = 0;
media->command->arg2 += mult*base;
if (media->command->arg2 > 1)
media->command->arg2 = 1;
}
// I for move forward
if (state[SDL_SCANCODE_I]) {
if (media->command->arg2 > 0)
media->command->arg2 = 0;
media->command->arg2 -= mult*base;
if (media->command->arg2 < -1)
media->command->arg2 = -1;
}
// L for turn right
if (state[SDL_SCANCODE_L]) {
if (media->command->arg4 < 0)
media->command->arg4 = 0;
media->command->arg4 += mult*base;
if (media->command->arg4 > 1)
media->command->arg4 = 1;
}
// J for turn left
if (state[SDL_SCANCODE_J]) {
if (media->command->arg4 > 0)
media->command->arg4 = 0;
media->command->arg4 -= mult*base;
if (media->command->arg4 < -1)
media->command->arg4 = -1;
}
media->command->flag_PCMD = true;
}
boost::this_thread::sleep(boost::posix_time::microseconds(300));
}
// release
// *note SDL objects have to be freed before closing avcodec.
// otherwise it causes segmentation fault for some reason.
SDL_DestroyTexture(bmpTex1);
SDL_DestroyTexture(bmpTex2);
SDL_DestroyRenderer(pRenderer1);
SDL_DestroyRenderer(pRenderer2);
SDL_DestroyWindow(pWindow1);
SDL_DestroyWindow(pWindow2);
free(pFrame_YUV420P);
free(buffer_YUV420P);
sws_freeContext(pConvertCtx_YUV420P);
}
bool mSDLSWInit(struct mSDLRenderer* renderer) {
#if !SDL_VERSION_ATLEAST(2, 0, 0)
#ifdef COLOR_16_BIT
SDL_SetVideoMode(renderer->viewportWidth, renderer->viewportHeight, 16, SDL_DOUBLEBUF | SDL_HWSURFACE);
#else
SDL_SetVideoMode(renderer->viewportWidth, renderer->viewportHeight, 32, SDL_DOUBLEBUF | SDL_HWSURFACE);
#endif
#endif
unsigned width, height;
renderer->core->desiredVideoDimensions(renderer->core, &width, &height);
#if SDL_VERSION_ATLEAST(2, 0, 0)
renderer->window = SDL_CreateWindow(projectName, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, renderer->viewportWidth, renderer->viewportHeight, SDL_WINDOW_OPENGL | (SDL_WINDOW_FULLSCREEN_DESKTOP * renderer->player.fullscreen));
SDL_GetWindowSize(renderer->window, &renderer->viewportWidth, &renderer->viewportHeight);
renderer->player.window = renderer->window;
renderer->sdlRenderer = SDL_CreateRenderer(renderer->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
#ifdef COLOR_16_BIT
#ifdef COLOR_5_6_5
renderer->sdlTex = SDL_CreateTexture(renderer->sdlRenderer, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STREAMING, width, height);
#else
renderer->sdlTex = SDL_CreateTexture(renderer->sdlRenderer, SDL_PIXELFORMAT_ABGR1555, SDL_TEXTUREACCESS_STREAMING, width, height);
#endif
#else
renderer->sdlTex = SDL_CreateTexture(renderer->sdlRenderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, width, height);
#endif
int stride;
SDL_LockTexture(renderer->sdlTex, 0, (void**) &renderer->outputBuffer, &stride);
renderer->core->setVideoBuffer(renderer->core, renderer->outputBuffer, stride / BYTES_PER_PIXEL);
#else
SDL_Surface* surface = SDL_GetVideoSurface();
SDL_LockSurface(surface);
if (renderer->ratio == 1) {
renderer->core->setVideoBuffer(renderer->core, surface->pixels, surface->pitch / BYTES_PER_PIXEL);
} else {
#ifdef USE_PIXMAN
renderer->outputBuffer = malloc(width * height * BYTES_PER_PIXEL);
renderer->core->setVideoBuffer(renderer->core, renderer->outputBuffer, width);
#ifdef COLOR_16_BIT
#ifdef COLOR_5_6_5
pixman_format_code_t format = PIXMAN_r5g6b5;
#else
pixman_format_code_t format = PIXMAN_x1b5g5r5;
#endif
#else
pixman_format_code_t format = PIXMAN_x8b8g8r8;
#endif
renderer->pix = pixman_image_create_bits(format, width, height,
renderer->outputBuffer, width * BYTES_PER_PIXEL);
renderer->screenpix = pixman_image_create_bits(format, renderer->viewportWidth, renderer->viewportHeight, surface->pixels, surface->pitch);
pixman_transform_t transform;
pixman_transform_init_identity(&transform);
pixman_transform_scale(0, &transform, pixman_int_to_fixed(renderer->ratio), pixman_int_to_fixed(renderer->ratio));
pixman_image_set_transform(renderer->pix, &transform);
pixman_image_set_filter(renderer->pix, PIXMAN_FILTER_NEAREST, 0, 0);
#else
return false;
#endif
}
#endif
return true;
}
int main(int argc, char* args[])
{
//The window we'll be rendering to
SDL_Window* window = NULL;
//The surface contained by the window
SDL_Surface* screenSurface = NULL;
//Initialize SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
}
else
{
//Create window
window = SDL_CreateWindow("ChiPP8", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL)
{
printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
}
else
{
//Get window surface
screenSurface = SDL_GetWindowSurface(window);
SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Texture * texture = SDL_CreateTexture(renderer,
SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, 64, 64);
uint32_t* pixels = new uint32_t[ 2048 ];
int pitch; // Pitch = 256 bytes (64 pixels * 4 bytes per pixel)
FILE* rom;
errno_t ferror;
chip8* chip;
if ((ferror = fopen_s(&rom, "pong2.c8", "rb")) != 0) {
printf("Unable to open ROM");
return 1;
}
else {
chip = new chip8(rom);
}
fclose(rom);
int returnStat;
while ((returnStat = chip->stepCycle()) != 99) {
SDL_LockTexture(texture, NULL, (void**)&pixels, &pitch);
//chip->debugRender();
for (int i = 0; i < 2048; i++)
{
if (!chip->getgfx()[i])
{
pixels[i] = 0000;
}
else
{
pixels[i] = 0b00101011;
}
}
SDL_UnlockTexture(texture);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, NULL, NULL);
SDL_RenderPresent(renderer);
}
delete[] pixels;
SDL_DestroyTexture(texture);
SDL_DestroyRenderer(renderer);
}
}
//Destroy window
SDL_DestroyWindow(window);
//Quit SDL subsystems
SDL_Quit();
return 0;
}
void Video::WriteNextFrame()
{
int frameFinished = 0;
AVPacket packet;
if (texturesRecreatedCount != gTexturesRecreatedCount)
{
texturesRecreatedCount = gTexturesRecreatedCount;
SDL_DestroyTexture(pTexture);
pTexture =
SDL_CreateTexture(
gpRenderer,
IsYUVFormat(pCodecContext->pix_fmt) ? SDL_PIXELFORMAT_YV12 : SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
width,
height);
SDL_SetTextureBlendMode(pTexture, SDL_BLENDMODE_BLEND);
unsigned char *pPixels = NULL;
int pitch = 0;
SDL_LockTexture(pTexture, NULL, reinterpret_cast<void **>(&pPixels), &pitch);
memcpy(pPixels, pCachedTexturePixels, pitch * height);
SDL_UnlockTexture(pTexture);
}
while (!frameFinished)
{
if (av_read_frame(pFormatContext, &packet) != 0)
{
break;
}
if (packet.stream_index == videoStream && avcodec_decode_video2(pCodecContext, pFrame, &frameFinished, &packet) >= 0)
{
if (frameFinished)
{
AVPicture picture;
unsigned char *pPixels = NULL;
int pitch = 0;
SDL_LockTexture(pTexture, NULL, reinterpret_cast<void **>(&pPixels), &pitch);
if (IsYUVFormat(pCodecContext->pix_fmt))
{
picture.data[0] = pFrame->data[0];
picture.data[1] = pFrame->data[1];
picture.data[2] = pFrame->data[2];
picture.linesize[0] = pFrame->linesize[0];
picture.linesize[1] = pFrame->linesize[1];
picture.linesize[2] = pFrame->linesize[2];
}
else
{
picture.data[0] = pPixels;
picture.linesize[0] = pitch;
}
sws_scale(pImageConvertContext, pFrame->data, pFrame->linesize, 0, pFrame->height, picture.data, picture.linesize);
if (IsYUVFormat(pCodecContext->pix_fmt))
{
if (pitch == picture.linesize[0])
{
int size = pitch * pFrame->height;
memcpy(pPixels, picture.data[0], size);
memcpy(pPixels + size, picture.data[2], size / 4);
memcpy(pPixels + size * 5 / 4, picture.data[1], size / 4);
}
else
{
unsigned char *y1, *y2, *y3, *i1, *i2, *i3;
y1 = pPixels;
y3 = pPixels + pitch * pFrame->height;
y2 = pPixels + pitch * pFrame->height * 5 / 4;
i1 = picture.data[0];
i2 = picture.data[1];
i3 = picture.data[2];
for (int i = 0; i < pFrame->height / 2; i++)
{
memcpy(y1, i1, pitch);
i1 += picture.linesize[0];
y1 += pitch;
memcpy(y1, i1, pitch);
memcpy(y2, i2, pitch / 2);
memcpy(y3, i3, pitch / 2);
y1 += pitch;
y2 += pitch / 2;
y3 += pitch / 2;
i1 += picture.linesize[0];
i2 += picture.linesize[1];
i3 += picture.linesize[2];
}
}
}
memcpy(pCachedTexturePixels, pPixels, pitch * height);
SDL_UnlockTexture(pTexture);
}
}
av_free_packet(&packet);
}
}
//------------------------------------------------------------------------
bool platform_support::init(unsigned width, unsigned height, unsigned flags)
{
ERROR_PRINT("platform_support::init %d,%d\n", width, height);
m_window_flags = flags;
int wflags = 0;
if(m_specific->m_texture) SDL_DestroyTexture(m_specific->m_texture);
if(m_specific->m_renderer) SDL_DestroyRenderer(m_specific->m_renderer);
if(m_specific->m_surface) SDL_FreeSurface(m_specific->m_surface);
//if(m_specific->m_mwindow) SDL_DestroyWindow(m_specific->m_mwindow);
m_specific->m_texture = 0;
m_specific->m_renderer = 0;
m_specific->m_surface = 0;
//m_specific->m_mwindow = 0;
if(m_window_flags & window_resize)
{
wflags |= SDL_WINDOW_RESIZABLE;
}
if(m_window_flags & window_fullscreen)
{
wflags |= SDL_WINDOW_FULLSCREEN;
#ifdef __ANDROID__DISABLED
width = Android_ScreenWidth;
height = Android_ScreenHeight;
#endif
#ifdef __ANDROID__
if (m_window_flags & window_keep_aspect_ratio)
{
width = (double)Android_ScreenWidth/Android_ScreenHeight*height;
width_factor = (double)width/Android_ScreenWidth;
hight_factor = (double)height/Android_ScreenHeight;
}
#endif
}
DEBUG_PRINT("platform_support::init %d,%d,%d", width, height, wflags);
int numRendDrv = SDL_GetNumRenderDrivers();
DEBUG_PRINT("num rend drv %d\n", numRendDrv);
for (int i = 0; i < numRendDrv; i++)
{
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(i, &info);
DEBUG_PRINT("index %i, %s, flags %x, texture formats %x\n", i, info.name, info.flags,
info.texture_formats[0]);
}
if (!m_specific->m_mwindow)
{
m_specific->m_mwindow = SDL_CreateWindow(m_caption,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
width, height,
wflags);
}
if (m_specific->m_mwindow == 0)
{
ERROR_PRINT(
"Unable to create %dx%d %d bpp window: %s\n",
width,
height,
m_bpp,
SDL_GetError());
return false;
}
m_specific->m_surface = SDL_CreateRGBSurface(0, width, height,
m_bpp,
m_specific->m_rmask,
m_specific->m_gmask,
m_specific->m_bmask,
m_specific->m_amask);
DEBUG_PRINT("surface at %p", m_specific->m_surface);
if(m_specific->m_surface == 0)
{
ERROR_PRINT(
"Unable to create image buffer %dx%d %d bpp: %s\n",
width,
height,
m_bpp,
SDL_GetError());
return false;
}
m_specific->m_renderer = SDL_CreateRenderer(m_specific->m_mwindow,
-1, 0);
if(m_specific->m_renderer == 0)
{
ERROR_PRINT(
"Unable to create renderer: %s\n",
SDL_GetError());
return false;
}
{
SDL_RendererInfo info;
SDL_GetRendererInfo(m_specific->m_renderer, &info);
DEBUG_PRINT("Current, %s, flags %x, texture formats %x, %x\n", info.name, info.flags,
SDL_PIXELFORMAT_ARGB8888, info.texture_formats[0]);
}
m_specific->m_texture = SDL_CreateTexture(
m_specific->m_renderer,
m_specific->m_pformat,
SDL_TEXTUREACCESS_STREAMING, width, height);
if(m_specific->m_renderer == 0)
{
ERROR_PRINT(
"Unable to create texture: %s\n",
SDL_GetError());
return false;
}
void* pixels;
int pitch;
if (SDL_LockTexture(m_specific->m_texture, NULL, &pixels, &pitch) < 0)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"Couldn't lock texture: %s\n",
SDL_GetError());
}
m_rbuf_window.attach((unsigned char*)pixels,
width, height,
m_flip_y ? -pitch : pitch);
if (!m_specific->m_initialized)
{
m_initial_width = width;
m_initial_height = height;
on_init();
m_specific->m_initialized = true;
}
on_resize(m_rbuf_window.width(), m_rbuf_window.height());
m_specific->m_update_flag = true;
return true;
}
bool LTexture::loadFromFile( std::string path )
{
//Get rid of preexisting texture
free();
//The final texture
SDL_Texture* newTexture = NULL;
//Load image at specified path
SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
if( loadedSurface == NULL )
{
printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
}
else
{
//Convert surface to display format
SDL_Surface* formattedSurface = SDL_ConvertSurfaceFormat( loadedSurface, SDL_PIXELFORMAT_RGBA8888, NULL );
if( formattedSurface == NULL )
{
printf( "Unable to convert loaded surface to display format! %s\n", SDL_GetError() );
}
else
{
//Create blank streamable texture
newTexture = SDL_CreateTexture( gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, formattedSurface->w, formattedSurface->h );
if( newTexture == NULL )
{
printf( "Unable to create blank texture! SDL Error: %s\n", SDL_GetError() );
}
else
{
//Enable blending on texture
SDL_SetTextureBlendMode( newTexture, SDL_BLENDMODE_BLEND );
//Lock texture for manipulation
SDL_LockTexture( newTexture, &formattedSurface->clip_rect, &mPixels, &mPitch );
//Copy loaded/formatted surface pixels
memcpy( mPixels, formattedSurface->pixels, formattedSurface->pitch * formattedSurface->h );
//Get image dimensions
mWidth = formattedSurface->w;
mHeight = formattedSurface->h;
//Get pixel data in editable format
Uint32* pixels = (Uint32*)mPixels;
int pixelCount = ( mPitch / 4 ) * mHeight;
//Map colors
Uint32 colorKey = SDL_MapRGB( formattedSurface->format, 0, 0xFF, 0xFF );
Uint32 transparent = SDL_MapRGBA( formattedSurface->format, 0x00, 0xFF, 0xFF, 0x00 );
//Color key pixels
for( int i = 0; i < pixelCount; ++i )
{
if( pixels[ i ] == colorKey )
{
pixels[ i ] = transparent;
}
}
//Unlock texture to update
SDL_UnlockTexture( newTexture );
mPixels = NULL;
}
//Get rid of old formatted surface
SDL_FreeSurface( formattedSurface );
}
//Get rid of old loaded surface
SDL_FreeSurface( loadedSurface );
}
//Return success
mTexture = newTexture;
return mTexture != NULL;
}
void ttexture_lock::lock()
{
if (SDL_LockTexture(texture_, NULL, &pixels, &pitch) != 0) {
throw texception("Could not lock a texture", true);
}
}