|
|
@@ -1,457 +0,0 @@
|
|
|
-#include"libvideorender.h"
|
|
|
-#include "../libvideoframework/videoutil.h"
|
|
|
-#include <string.h>
|
|
|
-
|
|
|
-//Refresh Event
|
|
|
-#ifndef REFRESH_EVENT
|
|
|
-#define REFRESH_EVENT (SDL_USEREVENT + 1)
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef RVC_DEFAULT_DELAY_TIME
|
|
|
-#define RVC_DEFAULT_DELAY_TIME 1
|
|
|
-#endif
|
|
|
-
|
|
|
-
|
|
|
-VideoRenderImpl::VideoRenderImpl(videorender_callback_t* pCallback)
|
|
|
-{
|
|
|
- m_sdl_window = NULL;
|
|
|
- m_rending_texture = NULL;
|
|
|
- m_renderer = NULL;
|
|
|
- memcpy(&m_callback, pCallback, sizeof(videorender_callback_t));
|
|
|
-
|
|
|
- m_refresh_flag = false;
|
|
|
- m_bmoveable = false;
|
|
|
- m_refresh_thread = NULL;
|
|
|
-
|
|
|
- m_cx = SDL_WINDOWPOS_UNDEFINED;
|
|
|
- m_cy = SDL_WINDOWPOS_UNDEFINED;
|
|
|
- m_width = 0;
|
|
|
- m_height = 0;
|
|
|
- m_videoformat = VIDEO_FORMAT_RGB24;
|
|
|
- m_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS | SDL_WINDOW_HIDDEN | SDL_WINDOW_ALWAYS_ON_TOP | SDL_WINDOW_SKIP_TASKBAR | SDL_WINDOW_POPUP_MENU;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-VideoRenderImpl::~VideoRenderImpl()
|
|
|
-{
|
|
|
- if (NULL != m_rending_texture) {
|
|
|
- SDL_DestroyTexture(m_rending_texture);
|
|
|
- m_rending_texture = NULL;
|
|
|
- //RenderLog("DestroyTexture.");
|
|
|
- }
|
|
|
-
|
|
|
- if (NULL != m_renderer) {
|
|
|
- SDL_DestroyRenderer(m_renderer);
|
|
|
- m_renderer = NULL;
|
|
|
- //RenderLog("DestroyRenderer.");
|
|
|
- }
|
|
|
-
|
|
|
- if (NULL != m_sdl_window) {
|
|
|
- SDL_DestroyWindow(m_sdl_window);
|
|
|
- m_sdl_window = NULL;
|
|
|
- //RenderLog("DestroyWindow.");
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-int VideoRenderImpl::SetWindowProperty(videorender_param_t* tparam)
|
|
|
-{
|
|
|
- int iRet = -1;
|
|
|
- if (NULL == tparam){
|
|
|
- return iRet;
|
|
|
- }
|
|
|
-
|
|
|
- m_cx = tparam->icx;
|
|
|
- m_cy = tparam->icy;
|
|
|
- m_width = tparam->uwidth;
|
|
|
- m_height = tparam->uheight;
|
|
|
- m_videowidth = m_width;
|
|
|
- m_videoheight = m_height;
|
|
|
- if (tparam->uvideowidth > 0){
|
|
|
- m_videowidth = tparam->uvideowidth;
|
|
|
- }
|
|
|
-
|
|
|
- if (tparam->uvideoheight > 0){
|
|
|
- m_videoheight = tparam->uvideoheight;
|
|
|
- }
|
|
|
-
|
|
|
- m_flags |= tparam->uwinflags;
|
|
|
-
|
|
|
- m_videoformat = tparam->ivideoformat;
|
|
|
-
|
|
|
- iRet = 0;
|
|
|
-
|
|
|
- return iRet;
|
|
|
-}
|
|
|
-
|
|
|
-SDL_PixelFormatEnum VideoRenderImpl::GetPixelFormat()
|
|
|
-{
|
|
|
- SDL_PixelFormatEnum eType = SDL_PIXELFORMAT_BGR24;
|
|
|
- //SDL_PixelFormatEnum eType = SDL_PIXELFORMAT_BGR888;
|
|
|
- if (VIDEO_FORMAT_I420 == m_videoformat){
|
|
|
- eType = SDL_PIXELFORMAT_IYUV;
|
|
|
- }
|
|
|
-
|
|
|
- return eType;
|
|
|
-}
|
|
|
-
|
|
|
-int VideoRenderImpl::VideoRenderSetParam(videorender_param_t* tparam)
|
|
|
-{
|
|
|
- if (SetWindowProperty(tparam)){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "SetWindowProperty failed for param error.");
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- if (NULL == m_sdl_window){
|
|
|
- //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0){
|
|
|
- // m_callback->Debug("RENDER: Couldn't initialize SDL2: %s", SDL_GetError());
|
|
|
- // return -1;
|
|
|
- //}
|
|
|
-
|
|
|
- SDL_SetHint("SDL_HINT_RENDER_SCALE_QUALITY", "1");
|
|
|
-
|
|
|
- m_sdl_window = SDL_CreateWindow(
|
|
|
- "rvc video", // window title
|
|
|
- m_cx, // initial x position
|
|
|
- m_cy, // initial y position
|
|
|
- m_width, // width, in pixels
|
|
|
- m_height, // height, in pixels
|
|
|
- m_flags
|
|
|
- );
|
|
|
-
|
|
|
- if (NULL == m_sdl_window){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: (SDL2) Couldn't open window: %s", SDL_GetError());
|
|
|
- VideoRenderDestroy();
|
|
|
- return -2;
|
|
|
- }
|
|
|
-
|
|
|
- int display_index = SDL_GetWindowDisplayIndex(m_sdl_window);
|
|
|
- SDL_DisplayMode display_mode;
|
|
|
- int err = SDL_GetDesktopDisplayMode(display_index, &display_mode);
|
|
|
- if (0 == err){
|
|
|
- RenderLog(RENDER_LOG_DEBUG, "RENDER: video display %i -> %dx%dpx @ %dhz",
|
|
|
- display_index,
|
|
|
- display_mode.w,
|
|
|
- display_mode.h,
|
|
|
- display_mode.refresh_rate);
|
|
|
- }
|
|
|
- else {
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: Couldn't determine display mode for video display %i", display_index);
|
|
|
- }
|
|
|
-
|
|
|
- if (m_width > display_mode.w) {
|
|
|
- m_width = display_mode.w;
|
|
|
- }
|
|
|
- if (m_height > display_mode.h) {
|
|
|
- m_height = display_mode.h;
|
|
|
- }
|
|
|
-
|
|
|
- SDL_SetWindowSize(m_sdl_window, m_width, m_height);
|
|
|
- }
|
|
|
-
|
|
|
- /* Allocate a renderer info struct*/
|
|
|
- SDL_RendererInfo* rend_info = (SDL_RendererInfo*)malloc(sizeof(SDL_RendererInfo));
|
|
|
- if (NULL == rend_info){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: Couldn't allocate memory for the renderer info data structure");
|
|
|
- VideoRenderDestroy();
|
|
|
- return -5;
|
|
|
- }
|
|
|
- static bool blog = true;
|
|
|
- /* Print the list of the available renderers*/
|
|
|
- if (blog) {
|
|
|
- RenderLog(RENDER_LOG_INFO, "RENDER: Available SDL2 rendering drivers:");
|
|
|
- }
|
|
|
-
|
|
|
- for (int i = 0; i < SDL_GetNumRenderDrivers(); i++){
|
|
|
- if (SDL_GetRenderDriverInfo(i, rend_info) < 0){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "Couldn't get SDL2 render driver information: %s", SDL_GetError());
|
|
|
- }
|
|
|
- else {
|
|
|
- if (blog) {
|
|
|
- RenderLog(RENDER_LOG_INFO, " %2d: %s", i, rend_info->name);
|
|
|
- }
|
|
|
- //m_callback->Debug(" SDL_RENDERER_TARGETTEXTURE [%c]", (rend_info->flags & SDL_RENDERER_TARGETTEXTURE) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_SOFTWARE [%c]", (rend_info->flags & SDL_RENDERER_SOFTWARE) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_ACCELERATED [%c]", (rend_info->flags & SDL_RENDERER_ACCELERATED) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_PRESENTVSYNC [%c]", (rend_info->flags & SDL_RENDERER_PRESENTVSYNC) ? 'X' : ' ');
|
|
|
- }
|
|
|
- }
|
|
|
- free(rend_info);
|
|
|
-
|
|
|
- m_renderer = SDL_CreateRenderer(m_sdl_window, -1,
|
|
|
- SDL_RENDERER_TARGETTEXTURE |
|
|
|
- SDL_RENDERER_PRESENTVSYNC |
|
|
|
- SDL_RENDERER_ACCELERATED);
|
|
|
-
|
|
|
- if (m_renderer == NULL)
|
|
|
- {
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: (SDL2) Couldn't get a accelerated renderer: %s", SDL_GetError());
|
|
|
- RenderLog(RENDER_LOG_INFO, "RENDER: (SDL2) trying with a software renderer");
|
|
|
-
|
|
|
- m_renderer = SDL_CreateRenderer(m_sdl_window, -1,
|
|
|
- SDL_RENDERER_TARGETTEXTURE |
|
|
|
- SDL_RENDERER_SOFTWARE);
|
|
|
-
|
|
|
- if (m_renderer == NULL)
|
|
|
- {
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: (SDL2) Couldn't get a software renderer: %s", SDL_GetError());
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: (SDL2) giving up...");
|
|
|
- VideoRenderDestroy();
|
|
|
- return -3;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* Allocate a renderer info struct*/
|
|
|
- SDL_RendererInfo* render_info = (SDL_RendererInfo*)malloc(sizeof(SDL_RendererInfo));
|
|
|
- if (NULL == render_info){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: Couldn't allocate memory for the renderer info data structure");
|
|
|
- VideoRenderDestroy();
|
|
|
- return -5;
|
|
|
- }
|
|
|
-
|
|
|
- /* Print the name of the current rendering driver */
|
|
|
- if (SDL_GetRendererInfo(m_renderer, render_info) < 0){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "Couldn't get SDL2 rendering driver information: %s", SDL_GetError());
|
|
|
- }
|
|
|
-
|
|
|
- if (blog) {
|
|
|
- RenderLog(RENDER_LOG_INFO, "RENDER: rendering driver in use: %s", render_info->name);
|
|
|
- }
|
|
|
- //m_callback->Debug(" SDL_RENDERER_TARGETTEXTURE [%c]", (render_info->flags & SDL_RENDERER_TARGETTEXTURE) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_SOFTWARE [%c]", (render_info->flags & SDL_RENDERER_SOFTWARE) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_ACCELERATED [%c]", (render_info->flags & SDL_RENDERER_ACCELERATED) ? 'X' : ' ');
|
|
|
- //m_callback->Debug(" SDL_RENDERER_PRESENTVSYNC [%c]", (render_info->flags & SDL_RENDERER_PRESENTVSYNC) ? 'X' : ' ');
|
|
|
-
|
|
|
- blog = false;
|
|
|
-
|
|
|
- free(render_info);
|
|
|
-
|
|
|
- SDL_RenderSetLogicalSize(m_renderer, m_videowidth, m_videoheight);
|
|
|
- SDL_SetRenderDrawBlendMode(m_renderer, SDL_BLENDMODE_NONE);
|
|
|
-
|
|
|
- m_rending_texture = SDL_CreateTexture(m_renderer,
|
|
|
- GetPixelFormat(),
|
|
|
- SDL_TEXTUREACCESS_STREAMING,
|
|
|
- m_videowidth,
|
|
|
- m_videoheight);
|
|
|
-
|
|
|
- if (m_rending_texture == NULL){
|
|
|
- RenderLog(RENDER_LOG_ERROR, "RENDER: (SDL2) Couldn't get a texture for rendering: %s", SDL_GetError());
|
|
|
- VideoRenderDestroy();
|
|
|
- return -4;
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-static int refresh_video(void *opaque)
|
|
|
-{
|
|
|
- VideoRenderImpl* pImpl = (VideoRenderImpl*)opaque;
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "function enter %s:%d", __FUNCTION__, __LINE__);
|
|
|
- while (pImpl->GetReFreshFlag()) {
|
|
|
- SDL_Event event;
|
|
|
- event.type = REFRESH_EVENT;
|
|
|
- SDL_PushEvent(&event);
|
|
|
- SDL_Delay(RVC_DEFAULT_DELAY_TIME);
|
|
|
- }
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "function leave %s:%d", __FUNCTION__, __LINE__);
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-static SDL_HitTestResult SDLCALL SDL_HitTestCallback(SDL_Window *win, const SDL_Point *area, void *data)
|
|
|
-{
|
|
|
- int w, h;
|
|
|
- const int RESIZE_BORDER = 8;
|
|
|
- const int DRAGGABLE_TITLE = 32;
|
|
|
-
|
|
|
- VideoRenderImpl* pImpl = (VideoRenderImpl*)data;
|
|
|
-
|
|
|
- SDL_GetWindowSize(win, &w, &h);
|
|
|
-
|
|
|
- if (area->x < RESIZE_BORDER) {
|
|
|
- if (area->y < RESIZE_BORDER) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_TOPLEFT");
|
|
|
- return SDL_HITTEST_RESIZE_TOPLEFT;
|
|
|
- } else if (area->y >= (h-RESIZE_BORDER)) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_BOTTOMLEFT");
|
|
|
- return SDL_HITTEST_RESIZE_BOTTOMLEFT;
|
|
|
- } else {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_LEFT");
|
|
|
- return SDL_HITTEST_RESIZE_LEFT;
|
|
|
- }
|
|
|
- } else if (area->x >= (w-RESIZE_BORDER)) {
|
|
|
- if (area->y < RESIZE_BORDER) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_TOPRIGHT");
|
|
|
- return SDL_HITTEST_RESIZE_TOPRIGHT;
|
|
|
- } else if (area->y >= (h-RESIZE_BORDER)) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_BOTTOMRIGHT");
|
|
|
- return SDL_HITTEST_RESIZE_BOTTOMRIGHT;
|
|
|
- } else {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_RIGHT");
|
|
|
- return SDL_HITTEST_RESIZE_RIGHT;
|
|
|
- }
|
|
|
- } else if (area->y >= (h-RESIZE_BORDER)) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_BOTTOM");
|
|
|
- return SDL_HITTEST_RESIZE_BOTTOM;
|
|
|
- } else if (area->y < RESIZE_BORDER) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_RESIZE_TOP");
|
|
|
- return SDL_HITTEST_RESIZE_TOP;
|
|
|
- } else if (area->y < DRAGGABLE_TITLE) {
|
|
|
- pImpl->RenderLog(RENDER_LOG_DEBUG, "SDL_HITTEST_DRAGGABLE");
|
|
|
- return SDL_HITTEST_DRAGGABLE;
|
|
|
- }
|
|
|
- return SDL_HITTEST_NORMAL;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-bool VideoRenderImpl::GetReFreshFlag()
|
|
|
-{
|
|
|
- return m_refresh_flag;
|
|
|
-}
|
|
|
-
|
|
|
-int VideoRenderImpl::StartVideoRender()
|
|
|
-{
|
|
|
- m_refresh_flag = true;
|
|
|
- m_refresh_thread = SDL_CreateThread(refresh_video,"refresh video thread", this);
|
|
|
- RenderLog(RENDER_LOG_DEBUG, "%s:%d m_refresh_thread is 0x%08x.",__FUNCTION__, __LINE__, m_refresh_thread);
|
|
|
- if (m_bmoveable){
|
|
|
- SDL_SetWindowHitTest(m_sdl_window, SDL_HitTestCallback, this);
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-int VideoRenderImpl::ShowVideoWindow()
|
|
|
-{
|
|
|
- int iret = -1;
|
|
|
-
|
|
|
- if (NULL != m_sdl_window){
|
|
|
- SDL_ShowWindow(m_sdl_window);
|
|
|
- iret = 0;
|
|
|
- }
|
|
|
- return iret;
|
|
|
-}
|
|
|
-
|
|
|
-int VideoRenderImpl::HideVideoWindow()
|
|
|
-{
|
|
|
- int iret = -1;
|
|
|
- if (NULL != m_sdl_window) {
|
|
|
- SDL_HideWindow(m_sdl_window);
|
|
|
- iret = 0;
|
|
|
- }
|
|
|
- return iret;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-int VideoRenderImpl::StopVideoRender()
|
|
|
-{
|
|
|
- HideVideoWindow();
|
|
|
-
|
|
|
- m_refresh_flag = false;
|
|
|
-
|
|
|
- RenderLog(RENDER_LOG_DEBUG, "%s:%d m_refresh_thread is 0x%08x.",__FUNCTION__, __LINE__, m_refresh_thread);
|
|
|
- if (NULL != m_refresh_thread){
|
|
|
- SDL_WaitThread(m_refresh_thread, NULL);
|
|
|
- m_refresh_thread = NULL;
|
|
|
- RenderLog(RENDER_LOG_DEBUG, "%s:%d video refresh thread exit.",__FUNCTION__, __LINE__);
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void VideoRenderImpl::VideoRenderDestroy()
|
|
|
-{
|
|
|
- delete this;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-int VideoRenderImpl::RenderVideoFrame(video_frame* pframe, RVC_RendererFlip eFlipType)
|
|
|
-{
|
|
|
- int iret = -1;
|
|
|
- if (NULL == m_sdl_window || NULL == pframe || NULL == m_renderer || NULL == m_rending_texture){
|
|
|
- return iret;
|
|
|
- }
|
|
|
-
|
|
|
- SDL_Event event;
|
|
|
- SDL_WaitEvent(&event);
|
|
|
-
|
|
|
- if(REFRESH_EVENT == event.type){
|
|
|
- SDL_SetRenderDrawColor(m_renderer, 0, 0, 0, 255); /*black*/
|
|
|
- SDL_RenderClear(m_renderer);
|
|
|
-
|
|
|
- /* since data is continuous we can use SDL_UpdateTexture
|
|
|
- * instead of SDL_UpdateYUVTexture.
|
|
|
- * no need to use SDL_Lock/UnlockTexture (it doesn't seem faster)
|
|
|
- */
|
|
|
- //SDL_QueryTexture()
|
|
|
-
|
|
|
- if (VIDEO_FORMAT_RGB24 == pframe->format || VIDEO_FORMAT_I420 == pframe->format){
|
|
|
- if (VIDEO_FORMAT_RGB24 == pframe->format){
|
|
|
- SDL_UpdateTexture(m_rending_texture, NULL, pframe->data[0], pframe->width*3);
|
|
|
- }
|
|
|
- else{
|
|
|
- SDL_UpdateTexture(m_rending_texture, NULL, pframe->data[0], pframe->width);
|
|
|
- }
|
|
|
-
|
|
|
- if (RVC_FLIP_NONE == eFlipType){
|
|
|
- SDL_RenderCopy(m_renderer, m_rending_texture, NULL, NULL);
|
|
|
- }
|
|
|
- else{
|
|
|
- SDL_Point point = {m_videowidth/2, m_videoheight/2};
|
|
|
- SDL_RenderCopyEx(m_renderer, m_rending_texture, NULL, NULL, 0, &point, (SDL_RendererFlip)eFlipType);
|
|
|
- }
|
|
|
- }
|
|
|
- else{
|
|
|
- RenderLog(RENDER_LOG_ERROR, "%s:%d not support format, return", __FUNCTION__, __LINE__);
|
|
|
- return iret;
|
|
|
- }
|
|
|
-
|
|
|
- SDL_RenderPresent(m_renderer);
|
|
|
-
|
|
|
- SDL_Delay(RVC_DEFAULT_DELAY_TIME);
|
|
|
- }
|
|
|
-
|
|
|
- iret = 0;
|
|
|
-
|
|
|
- return iret;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void VideoRenderImpl::RenderLog(render_loglevel elevel, const char* fmt, ...)
|
|
|
-{
|
|
|
- if (m_callback.debug) {
|
|
|
- va_list arg;
|
|
|
- va_start(arg, fmt);
|
|
|
- if (*m_callback.debug){
|
|
|
- (*m_callback.debug)(elevel, m_callback.user_data, fmt, arg);
|
|
|
- }
|
|
|
- va_end(arg);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void VideoRenderImpl::ConVert24to32(unsigned char* image_in, unsigned char* image_out, int w, int h)
|
|
|
-{
|
|
|
- for (int i = 0; i < h; i++)
|
|
|
- for (int j = 0; j < w; j++) {
|
|
|
- //Big Endian or Small Endian?
|
|
|
- //"ARGB" order:high bit -> low bit.
|
|
|
- //ARGB Format Big Endian (low address save high MSB, here is A) in memory : A|R|G|B
|
|
|
- //ARGB Format Little Endian (low address save low MSB, here is B) in memory : B|G|R|A
|
|
|
- if (SDL_BYTEORDER == SDL_LIL_ENDIAN) {
|
|
|
- //Little Endian (x86): R|G|B --> B|G|R|A
|
|
|
- image_out[(i * w + j) * 4 + 0] = image_in[(i * w + j) * 3 + 2];
|
|
|
- image_out[(i * w + j) * 4 + 1] = image_in[(i * w + j) * 3 + 1];
|
|
|
- image_out[(i * w + j) * 4 + 2] = image_in[(i * w + j) * 3];
|
|
|
- image_out[(i * w + j) * 4 + 3] = '0';
|
|
|
- }
|
|
|
- else {
|
|
|
- //Big Endian: R|G|B --> A|R|G|B
|
|
|
- image_out[(i * w + j) * 4] = '0';
|
|
|
- memcpy(image_out + (i * w + j) * 4 + 1, image_in + (i * w + j) * 3, 3);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|