We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

Test program to testing OpenGL ES 2.0 YUV rendering

yuvtest.c (text/x-csrc), 19.59 KB, created by Alvin on 2014-06-23 14:38:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Alvin

Created: 2014-06-23 14:38:06 UTC

Size: 19.59 KB

patch

obsolete

>/**
> *******************************************************************************
> *  \file yuvtest.c
> *
> *  \brief Test Open GL ES 2.0 support for YUV textures
> *
> *  Tests YUV textures (opengles2) support
> *
> *  To compile:
> *     gcc -o yuvtest yuvtest.c $(sdl2-config --cflags) -std=c99 $(sdl2-config --libs) -lavcodec -lavformat -lavutil
> *
> *  Run:
> *     ./yuvtest --help
> ******************************************************************************/
>
>#include <SDL.h>
>#include <libavformat/avformat.h>
>#include <libswscale/swscale.h>
>#include <malloc.h>
>
>/// format context used for this reader
>static AVFormatContext *ffm_ctxt = NULL;
>
>/// Video stream
>static AVStream *ffm_vstream = NULL;
>
>/// The video channel
>int ffm_vid = -1;
>
>/// Codec used for current video
>static AVCodecContext *ffm_codec_ctxt = NULL;
>
>/// The codec
>static AVCodec *ffm_codec = NULL;
>
>/// A frame in native format of the media (e.g. YUV)
>static AVFrame *ffm_frame = NULL;
>
>/// A piece of an image. These are read from the video and added to frame
>static AVPacket packet;
>
>/// Main SDL window
>static SDL_Window *window = NULL;
>
>/// Main renderer for the SDL window
>static SDL_Renderer *renderer = NULL;
>
>/// Video texture
>static SDL_Texture *yuv_texture = NULL;
>
>/// Contiguous or Unpadded Non-Contiguous YUV. [0]=Contiguous or Y, [1] = 0|U, [2] = 0|V
>static Uint8* yuv_data[3];
>static int yuv_pitch[3];
>
>static SDL_Texture *rgb_texture = NULL;
>
>/// Most recent event
>static SDL_Event evt;
>
>/*****************************************************************************/
>// Open the video
>static int ffmpeg_open(const char *fpath)
>{
>	avcodec_register_all();
>	av_register_all();
>
>	if(avformat_open_input(&ffm_ctxt, fpath, NULL, NULL) < 0)
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to open %s\n", fpath);
>		return -1;
>	}
>
>	// force presentation timestamps (pts) to be generated
>	ffm_ctxt->flags |= AVFMT_FLAG_GENPTS;
>
>	// initialize the ffmpeg library
>	// read/analyse header and select the proper format and codec
>	if(avformat_find_stream_info(ffm_ctxt, 0) < 0)
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to find a stream info.\n");
>		return -1;
>	}
>
>	// Select the channel to use
>	for(unsigned int i = 0; i < ffm_ctxt->nb_streams; i++)
>	{
>		if(ffm_ctxt->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
>		{
>			// found the video channel
>			ffm_vstream = ffm_ctxt->streams[i];
>			ffm_vid     = i;
>			break;
>		}
>	}
>
>	if(ffm_vid < 0)
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to find the video channel.\n");
>		return -1;
>	}
>
>	ffm_codec_ctxt = ffm_vstream->codec;
>
>	// Get the decoder
>	if(!(ffm_codec = avcodec_find_decoder(ffm_codec_ctxt->codec_id)))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to find codec with ID: %d\n", ffm_codec_ctxt->codec_id);
>		return -1;
>	}
>
>	// open the codec
>	if(avcodec_open2(ffm_codec_ctxt, ffm_codec, 0))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to open codec %s\n", ffm_codec->name);
>		return -1;
>	}
>
>	// Allocate video frame (as decoded)
>	if(!(ffm_frame = av_frame_alloc()))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to allocate the FFMPEG frame\n");
>		return -1;
>	}
>
>	return 0;
>}
>
>/******************************************************************************/
>// Retrieve the next frame
>static int ffm_next_frame()
>{
>	int done = 0;
>	int err  = 0;
>
>	// Loop until the frame was been fully decoded or error or EOF occurs.
>	while(!done && !(err = av_read_frame(ffm_ctxt, &packet)))
>	{
>		if((packet.stream_index == ffm_vid))
>		{
>			if(avcodec_decode_video2(ffm_codec_ctxt, ffm_frame, &done, &packet) < 0)
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Error occurred decoding a video frame.\n");
>
>				av_free_packet(&packet);
>
>				return -1;
>			}
>		}
>
>		av_free_packet(&packet);
>	}
>
>	return err;
>}
>
>/******************************************************************************/
>// Clean up FFMPEG
>static void ffm_close()
>{
>	// Free the codec's frame
>	if(ffm_frame)
>	{
>		av_frame_free(&ffm_frame);
>		ffm_frame = NULL;
>	}
>
>	// Close the codec
>	if(ffm_codec_ctxt)
>	{
>		avcodec_close(ffm_codec_ctxt);
>		ffm_codec_ctxt = NULL;
>	}
>
>	if(ffm_ctxt)
>	{
>		avformat_close_input(&ffm_ctxt);
>		ffm_ctxt = NULL;
>	}
>
>	ffm_vstream = NULL;
>	ffm_vid     = -1;
>}
>
>/******************************************************************************/
>// Print platform info
>static void log_platform()
>{
>	SDL_Log("Platform: %s      Cores=%d   CacheL1=%d kb   System RAM=%d MB",
>		SDL_GetPlatform(),
>		SDL_GetCPUCount(),
>		SDL_GetCPUCacheLineSize(),
>		SDL_GetSystemRAM());
>}
>
>/******************************************************************************/
>// Print the Window and Renderer info
>static void log_display(SDL_Window *window, SDL_Renderer *renderer)
>{
>	// Output window info
>	int w   = -1;
>	int h   = -1;
>	int bpp = -1;
>	Uint32 masks[4];
>
>	Uint32 pxfmt = SDL_GetWindowPixelFormat(window);
>
>	SDL_GetWindowSize(window, &w, &h);
>
>	if(!SDL_PixelFormatEnumToMasks(pxfmt, &bpp, &masks[0], &masks[1], &masks[2], &masks[3]))
>		SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Failed to convert pixel format to masks. Reason: %s", SDL_GetError());
>
>	SDL_Log("Window:   %p  %dx%d@%dbpp %s Rmask=0x%x Gmask=0x%x Bmask=0x%x Amask=0x%x", window, w, h, bpp, SDL_GetPixelFormatName(pxfmt), masks[0], masks[1], masks[2], masks[3]);
>
>	// Ouput renderer info
>	SDL_RendererInfo info;
>
>	if(!SDL_GetRendererInfo(renderer, &info))
>	{
>		SDL_Log("Renderer: %p  %s SW=%s HWACCEL=%s VSYNC=%s TARGETTEXTURE=%s MaxTexure=%dx%d",
>			renderer,
>			info.name,
>			(info.flags & SDL_RENDERER_SOFTWARE) ? "YES" : "NO",
>			(info.flags & SDL_RENDERER_ACCELERATED) ? "YES" : "NO",
>			(info.flags & SDL_RENDERER_PRESENTVSYNC) ? "YES" : "NO",
>			(info.flags & SDL_RENDERER_TARGETTEXTURE) ? "YES" : "NO",
>			info.max_texture_width,
>			info.max_texture_height);
>
>		SDL_Log("Renderer: %p  %d Available Textures", renderer, info.num_texture_formats);
>
>		// Print the texture formats that the render supports
>		for(Uint32 i = 0; i <  info.num_texture_formats; i++)
>			SDL_Log("Renderer: %p    %s", renderer, SDL_GetPixelFormatName(info.texture_formats[i]));
>	}
>	else
>		SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Renderer: Query failed. Reason: %s", SDL_GetError());
>}
>
>/*****************************************************************************/
>// Print Texture info
>static void log_texture(SDL_Texture *t)
>{
>	Uint32 fmt    = 0;
>	int    access = 0;
>
>	int w = 0;
>	int h = 0;
>
>	SDL_QueryTexture(t, &fmt, &access, &w, &h);
>
>	const char *access_str = "<Unknown>";
>
>	if(access == SDL_TEXTUREACCESS_STATIC)
>		access_str = "SDL_TEXTUREACCESS_STATIC";
>	else if(access == SDL_TEXTUREACCESS_STREAMING)
>		access_str = "SDL_TEXTUREACCESS_STREAMING";
>	else if(access == SDL_TEXTUREACCESS_TARGET)
>		access_str = "SDL_TEXTUREACCESS_TARGET";
>
>	SDL_Log("Texture:   %p  %dx%d@%dbpp %s Access=%s", t, w, h, SDL_BITSPERPIXEL(fmt), SDL_GetPixelFormatName(fmt), access_str);
>}
>
>/*****************************************************************************/
>// Init SDL and create YUV texture
>static int sdl_init(int w, int h)
>{
>	SDL_version sdl_compiled;
>	SDL_version sdl_linked;
>
>	SDL_VERSION(&sdl_compiled);
>	SDL_GetVersion(&sdl_linked);
>
>	SDL_Log("libSDL: compiled with=%d.%d.%d linked against=%d.%d.%d",
>			sdl_compiled.major, sdl_compiled.minor, sdl_compiled.patch,
>			sdl_linked.major, sdl_linked.minor, sdl_linked.patch);
>
>	SDL_Log("Renderer Driver (default): %s", SDL_GetHint(SDL_HINT_RENDER_DRIVER));
>
>	// Force OpenGLES2 for desktop builds
>#ifndef __ANDROID__
>	SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengles2");
>	SDL_Log("Renderer Driver (set): %s", SDL_GetHint(SDL_HINT_RENDER_DRIVER));
>#endif // __ANDROID__
>
>	// Initialise SDL2
>	if(SDL_Init(SDL_INIT_EVERYTHING))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialise SDL. Aborting!");
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Reason: %s", SDL_GetError());
>		return -1;
>	}
>
>	// Create Window
>	if(!(window = SDL_CreateWindow("YUV Texture Test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, 0)))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to create SDL window. Aborting!");
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Reason: %s", SDL_GetError());
>		return -1;
>	}
>
>	// Create Renderer
>	if(!(renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE|SDL_RENDERER_PRESENTVSYNC)))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to create SDL renderer. Aborting!");
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Reason: %s", SDL_GetError());
>		return -1;
>	}
>
>	// Create the texture that will be our "display". Using STATIC access as not planning to mess with its pixels
>	// nor render other textures/draw on it
>	if(!(yuv_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STATIC, w, h)))
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to create the YUV texture: %s", SDL_GetError());
>		return -1;
>	}
>
>	// Print out some debug info
>	log_platform();
>	log_display(window, renderer);
>	log_texture(yuv_texture);
>
>	// Clear the window
>	SDL_SetRenderDrawColor(renderer, 0, 77, 0, 255);
>	SDL_RenderClear(renderer);
>	SDL_RenderPresent(renderer);
>
>	return 0;
>}
>
>/*****************************************************************************/
>// Clean up SDL2
>static void sdl_uninit()
>{
>	SDL_DestroyTexture(yuv_texture);
>	yuv_texture = NULL;
>
>	SDL_DestroyTexture(rgb_texture);
>	rgb_texture = NULL;
>
>
>	SDL_DestroyRenderer(renderer);
>	renderer = NULL;
>
>	SDL_DestroyWindow(window);
>	window = NULL;
>
>	for(int i = 0; i < 3; i++)
>	{
>		free(yuv_data[i]);
>		yuv_data[i] = NULL;
>	}
>
>	SDL_Quit();
>}
>
>/*****************************************************************************/
>// Copy a padded buffer into an unpadded buffer
>static int yuv_copy(Uint8 *dest, const Uint8 *src, int w, int h, int pitch)
>{
>	for(int r = 0; r < h; r++)
>		memcpy(dest+(r*w), src+(r*pitch), w);
>
>	return w*h;
>}
>
>/*****************************************************************************/
>// Pack unpadded, non-contiguous YUV buffers
>static int pack_unpadded()
>{
>	if(!yuv_data[0])
>	{
>		yuv_data[0]  = malloc(ffm_codec_ctxt->width * ffm_codec_ctxt->height);
>		yuv_data[1]  = malloc((ffm_codec_ctxt->width * ffm_codec_ctxt->height) / 4);
>		yuv_data[2]  = malloc((ffm_codec_ctxt->width * ffm_codec_ctxt->height) / 4);
>
>		yuv_pitch[0] = ffm_codec_ctxt->width;
>		yuv_pitch[1] = ffm_codec_ctxt->width/2;
>		yuv_pitch[2] = ffm_codec_ctxt->width/2;
>
>		memset(yuv_data[0], 0, ffm_codec_ctxt->width * ffm_codec_ctxt->height);
>		memset(yuv_data[1], 0, ffm_codec_ctxt->width * ffm_codec_ctxt->height / 4);
>		memset(yuv_data[2], 0, ffm_codec_ctxt->width * ffm_codec_ctxt->height / 4);
>	}
>
>	// Y
>	yuv_copy(yuv_data[0], ffm_frame->data[0], ffm_codec_ctxt->width,   ffm_codec_ctxt->height, ffm_frame->linesize[0]);
>
>	// U
>	yuv_copy(yuv_data[1], ffm_frame->data[1], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[1]);
>
>	// V
>	yuv_copy(yuv_data[2], ffm_frame->data[2], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[2]);
>
>	return 0;
>}
>
>/*****************************************************************************/
>// Pack unpadded, contiguous YUV buffer
>static int pack_unpadded_contiguous_yuv()
>{
>	if(!yuv_data[0])
>	{
>		yuv_data[0]  = malloc(3 * ffm_codec_ctxt->width * ffm_codec_ctxt->height / 2);
>		yuv_pitch[0] = ffm_codec_ctxt->width;
>
>		memset(yuv_data[0], 0, 3 * ffm_codec_ctxt->width * ffm_codec_ctxt->height / 2);
>	}
>
>	Uint8 *dest = yuv_data[0];
>	int sz      = 0;
>
>	Uint32 fmt = 0;
>
>	SDL_QueryTexture(yuv_texture, &fmt, 0, 0, 0);
>
>	switch(fmt)
>	{
>		case SDL_PIXELFORMAT_YV12:
>			// Y
>			sz = yuv_copy(dest, ffm_frame->data[0], ffm_codec_ctxt->width,   ffm_codec_ctxt->height, ffm_frame->linesize[0]);
>			dest += sz;
>
>			// V
>			sz = yuv_copy(dest, ffm_frame->data[2], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[2]);
>			dest += sz;
>
>			// U
>			sz = yuv_copy(dest, ffm_frame->data[1], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[1]);
>			break;
>
>		case SDL_PIXELFORMAT_IYUV:
>			// Y
>			sz = yuv_copy(dest, ffm_frame->data[0], ffm_codec_ctxt->width,   ffm_codec_ctxt->height, ffm_frame->linesize[0]);
>			dest += sz;
>
>			// U
>			sz = yuv_copy(dest, ffm_frame->data[1], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[1]);
>			dest += sz;
>
>			// V
>			sz = yuv_copy(dest, ffm_frame->data[2], ffm_codec_ctxt->width/2, ffm_codec_ctxt->height/2, ffm_frame->linesize[2]);
>			break;
>	}
>
>	return 0;
>}
>
>/*****************************************************************************/
>
>int main(int argc, char **argv)
>{
>	int cli_fid  = 0;
>	int cli_cont = 0;
>	int cli_rgb  = 0;
>	int cli_unpad = 0;
>
>	memset(yuv_data, 0, 3 *sizeof(Uint8));
>	memset(yuv_pitch, 0, 3 *sizeof(Uint8));
>
>#ifndef __ANDROID__
>	// Running on desktop, process CLI
>	for(int i = 1; i < argc; i++)
>	{
>		if(!strcmp(argv[i], "--help"))
>		{
>			SDL_Log("Usage: yuvtest [-cont|-unpad] [-rgb] FILE");
>			SDL_Log("       Click to cycle between rendering methods.");
>			SDL_Log("-cont  Force unpadded contiguous YUV buffer");
>			SDL_Log("-unpad Force unpadded, non-contiguous YUV buffers");
>			SDL_Log("-rgb   Copy YUV texture to RGB24 texture. Render the RGB24 texture.");
>			return 1;
>		}
>
>		if(!strcmp(argv[i], "-cont"))
>		{
>			if(cli_unpad)
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Cannot use -unpad with -cont");
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "See --help for more information.");
>				return 1;
>			}
>
>			SDL_Log("Forcing Contiguous YUV");
>			cli_cont = 1;
>		}
>		else if(!strcmp(argv[i], "-rgb"))
>		{
>			SDL_Log("Forcing RGB24");
>			cli_rgb = 1;
>		}
>		else if(!strcmp(argv[i], "-unpad"))
>		{
>			if(cli_cont)
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Cannot use -cont with -unpad");
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "See --help for more information.");
>				return 1;
>			}
>
>			SDL_Log("Forcing unpadding");
>			cli_unpad = 1;
>		}
>		else if((*argv[i] != '-') && (cli_fid == 0))
>		{
>			cli_fid = i;
>		}
>		else
>		{
>			SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Unknown switch: %s", argv[1]);
>			SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "See --help for more information.");
>			return 1;
>		}
>	}
>
>	if(cli_fid == 0)
>	{
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Missing video file");
>		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "See --help for more information.");
>		return 1;
>	}
>
>	// Open the video
>	if(ffmpeg_open(argv[cli_fid]))
>		return 1;
>
>#else
>	// Running on Android OS
>	if(ffmpeg_open("/mnt/sdcard/Videos/yuvtest.mp4"))
>		return 1;
>#endif // __ANDROID__
>
>	// Init SDL2
>	if(sdl_init(ffm_codec_ctxt->width, ffm_codec_ctxt->height))
>	{
>		ffm_close();
>		sdl_uninit();
>		return 1;
>	}
>
>	// Report the start up rendering method
>	if(cli_cont)
>	{
>		if(cli_rgb)
>			SDL_Log("Forcing unpadded, contiguous YUV to RGB");
>		else
>			SDL_Log("Forcing unpadded, contiguous YUV");
>	}
>	else
>	{
>		if(cli_rgb)
>		{
>			if(cli_unpad)
>				SDL_Log("Forcing unpadded, non-contiguous YUV to RGB");
>			else
>				SDL_Log("Forcing non-contiguous (may be padded) YUV to RGB");
>		}
>		else if(cli_unpad)
>			SDL_Log("Rendering unpadded, non-contiguous YUV");
>		else
>			SDL_Log("Rendering non-contiguous (may be padded) YUV");
>	}
>
>	// Flag to keep the program alive until ESCAPE or the 'x' is pressed.
>	int quit = 0;
>
>	// Flag indicating that at least one non-contiguous YUV frame was detected
>	int det_padded = 0;
>
>	// Counter used to switch between the various YUV rendering options
>	int yuv_opt = 0;
>
>	// Main loop.
>	// Get a frame, render it, check for events, repeat.
>	while(!quit)
>	{
>		// Get Frame
>		if(ffm_next_frame())
>			break; // error retrieving the next frame or EOF
>
>		if(cli_unpad)
>		{
>			if(pack_unpadded())
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to unpad the non-contiguous YUV data");
>				break;
>			}
>
>			// Update the non-contiguous YUV texture
>			if(SDL_UpdateYUVTexture(yuv_texture, NULL, yuv_data[0], yuv_pitch[0], yuv_data[1], yuv_pitch[1], yuv_data[2], yuv_pitch[2]))
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to update the non-contiguous YUV texture: %s", SDL_GetError());
>				break;
>			}
>		}
>		else if(cli_cont)
>		{
>			if(pack_unpadded_contiguous_yuv())
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to pack contiguous YUV data");
>				break;
>			}
>
>			// Update the contiguous YUV texture
>			if(SDL_UpdateTexture(yuv_texture, NULL, yuv_data[0], yuv_pitch[0]))
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to update the non-contiguous YUV texture: %s", SDL_GetError());
>				break;
>			}
>		}
>		else
>		{
>			if(!det_padded)
>			{
>				if((det_padded = ffm_frame->linesize[0] != ffm_codec_ctxt->width))
>					SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Detected Padded YUV (reported once)!");
>			}
>
>			// Update the non-contiguous YUV texture
>			if(SDL_UpdateYUVTexture(yuv_texture, NULL, ffm_frame->data[0], ffm_frame->linesize[0], ffm_frame->data[1], ffm_frame->linesize[1], ffm_frame->data[2], ffm_frame->linesize[2]))
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to update the non-contiguous YUV texture: %s", SDL_GetError());
>				break;
>			}
>		}
>
>		if(cli_rgb)
>		{
>			if(!rgb_texture)
>			{
>				rgb_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_TARGET, ffm_codec_ctxt->width, ffm_codec_ctxt->height);
>				SDL_SetTextureBlendMode(rgb_texture, SDL_BLENDMODE_NONE);
>			}
>
>			SDL_SetRenderTarget(renderer, rgb_texture);
>		}
>
>		// Render the YUV texture
>		if(SDL_RenderCopy(renderer, yuv_texture, NULL, NULL))
>		{
>			SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to copy YUV texture to the renderer: %s", SDL_GetError());
>			break;
>		}
>
>		if(cli_rgb)
>		{
>			// Restore the renderer's default target
>			SDL_SetRenderTarget(renderer, NULL);
>
>			// Render the RGB texture to the renderer
>			if(SDL_RenderCopy(renderer, rgb_texture, NULL, NULL))
>			{
>				SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Failed to copy RGB texture to the renderer: %s", SDL_GetError());
>				break;
>			}
>		}
>
>		// Check events
>		while(SDL_PollEvent(&evt))
>		{
>			switch(evt.type)
>			{
>				case SDL_QUIT:
>					quit = 1;
>					break;
>
>				case SDL_KEYDOWN:
>					if((evt.key.keysym.sym == SDLK_ESCAPE) || (evt.key.keysym.sym == SDLK_AC_BACK) || (evt.key.keysym.sym == SDLK_AC_HOME))
>						quit = 1;
>					break;
>
>#ifdef __ANDROID__
>				case SDL_FINGERUP:
>#else
>				case SDL_MOUSEBUTTONUP:
>#endif // __ANDROID__
>					yuv_opt = (yuv_opt+1) % 6;
>
>					// release the current YUV buffer(s)
>					for(int i = 0; i < 3; i++)
>					{
>						free(yuv_data[i]);
>						yuv_data[i] = NULL;
>					}
>
>					switch(yuv_opt)
>					{
>						// Non-contiguous YUV
>						case 0:
>							SDL_Log("Non-contiguous (may be padded) YUV");
>							cli_rgb   = 0;
>							cli_cont  = 0;
>							cli_unpad = 0;
>							break;
>
>						// YUV to RGB
>						case 1:
>							SDL_Log("Forcing non-contiguous (may be padded) YUV to RGB");
>							cli_rgb   = 1;
>							cli_cont  = 0;
>							cli_unpad = 0;
>							break;
>
>						// Contiguous YUV
>						case 2:
>							SDL_Log("Forcing unpadded, contiguous YUV");
>							cli_rgb   = 0;
>							cli_cont  = 1;
>							cli_unpad = 0;
>							break;
>
>						// Contiguous YUV to RGB
>						case 3:
>							SDL_Log("Forcing unpadded, contiguous YUV to RGB");
>							cli_rgb   = 1;
>							cli_cont  = 1;
>							cli_unpad = 0;
>							break;
>
>						// Unpadded non-contiguous YUV
>						case 4:
>							SDL_Log("Forcing unpadded, non-contiguous YUV");
>							cli_rgb   = 0;
>							cli_cont  = 0;
>							cli_unpad = 1;
>							break;
>
>						// Unpadded non-contiguous YUV to RGB
>						case 5:
>							SDL_Log("Forcing unpadded, non-contiguous YUV to RGB");
>							cli_rgb   = 1;
>							cli_cont  = 0;
>							cli_unpad = 1;
>							break;
>					}
>					break;
>
>				default:
>					; // ignore
>			}
>		}
>
>		// Using vsync to throttle the loop
>		SDL_RenderPresent(renderer);
>	}
>
>	SDL_Log("Exiting...");
>
>	ffm_close();
>
>	sdl_uninit();
>
>	return !quit;
>}
>
>/*****************************************************************************/
>

Actions: View

Attachments on bug 2595: 1703 | 1704 | 1705 | 1707 | 1708 | 1710 | 1711

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.