#include "quakedef.h"
#include "cl_video.h"
+#include "image.h"
#include "jpeg.h"
#include "cl_collision.h"
-
-cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100"};
-cvar_t scr_fov = {CVAR_SAVE, "fov","90"}; // 1 - 170
-cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900"}; // LordHavoc: quake used 300
-cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1"};
-cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "0.2"};
-cvar_t scr_conforcewhiledisconnected = {CVAR_SAVE, "scr_conforcewhiledisconnected", "1"};
-cvar_t scr_centertime = {0, "scr_centertime","2"};
-cvar_t scr_showram = {CVAR_SAVE, "showram","1"};
-cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0"};
-cvar_t scr_showpause = {CVAR_SAVE, "showpause","1"};
-cvar_t scr_showbrand = {0, "showbrand","0"};
-cvar_t scr_printspeed = {0, "scr_printspeed","8"};
-cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640"};
-cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480"};
-cvar_t vid_pixelaspect = {CVAR_SAVE, "vid_pixelaspect", "1"};
-cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1"};
-cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9"};
-cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2"};
+#include "libcurl.h"
+#include "csprogs.h"
+
+// we have to include snd_main.h here only to get access to snd_renderbuffer->format.speed when writing the AVI headers
+#include "snd_main.h"
+
+cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"};
+cvar_t scr_fov = {CVAR_SAVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"};
+cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1", "opacity of console background"};
+cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "1", "brightness of console background (0 = black, 1 = image)"};
+cvar_t scr_conforcewhiledisconnected = {0, "scr_conforcewhiledisconnected", "1", "forces fullscreen console while disconnected"};
+cvar_t scr_menuforcewhiledisconnected = {0, "scr_menuforcewhiledisconnected", "0", "forces menu while disconnected"};
+cvar_t scr_centertime = {0, "scr_centertime","2", "how long centerprint messages show"};
+cvar_t scr_showram = {CVAR_SAVE, "showram","1", "show ram icon if low on surface cache memory (not used)"};
+cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0", "show turtle icon when framerate is too low"};
+cvar_t scr_showpause = {CVAR_SAVE, "showpause","1", "show pause icon when game is paused"};
+cvar_t scr_showbrand = {0, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"};
+cvar_t scr_printspeed = {0, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"};
+cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640", "virtual width of 2D graphics system"};
+cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480", "virtual height of 2D graphics system"};
+cvar_t vid_pixelheight = {CVAR_SAVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"};
+cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa"};
+cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"};
+cvar_t scr_screenshot_gammaboost = {CVAR_SAVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"};
// scr_screenshot_name is defined in fs.c
-cvar_t cl_capturevideo = {0, "cl_capturevideo", "0"};
-cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0"};
-cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30"};
-cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0"};
-cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0"};
-cvar_t r_textshadow = {0, "r_textshadow", "0"};
-cvar_t r_letterbox = {0, "r_letterbox", "0"};
+cvar_t cl_capturevideo = {0, "cl_capturevideo", "0", "enables saving of video to a .avi file using uncompressed I420 colorspace and PCM audio, note that scr_screenshot_gammaboost affects the brightness of the output)"};
+cvar_t cl_capturevideo_width = {0, "cl_capturevideo_width", "0", "scales all frames to this resolution before saving the video"};
+cvar_t cl_capturevideo_height = {0, "cl_capturevideo_height", "0", "scales all frames to this resolution before saving the video"};
+cvar_t cl_capturevideo_realtime = {0, "cl_capturevideo_realtime", "0", "causes video saving to operate in realtime (mostly useful while playing, not while capturing demos), this can produce a much lower quality video due to poor sound/video sync and will abort saving if your machine stalls for over 1 second"};
+cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30", "how many frames per second to save (29.97 for NTSC, 30 for typical PC video, 15 can be useful)"};
+cvar_t cl_capturevideo_number = {CVAR_SAVE, "cl_capturevideo_number", "1", "number to append to video filename, incremented each time a capture begins"};
+cvar_t r_letterbox = {0, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"};
+cvar_t r_stereo_separation = {0, "r_stereo_separation", "4", "separation distance of eyes in the world (negative values are only useful for cross-eyed viewing)"};
+cvar_t r_stereo_sidebyside = {0, "r_stereo_sidebyside", "0", "side by side views for those who can't afford glasses but can afford eye strain (note: use a negative r_stereo_separation if you want cross-eyed viewing)"};
+cvar_t r_stereo_redblue = {0, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"};
+cvar_t r_stereo_redcyan = {0, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"};
+cvar_t r_stereo_redgreen = {0, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"};
+cvar_t r_stereo_angle = {0, "r_stereo_angle", "0", "separation angle of eyes (makes the views look different directions, as an example, 90 gives a 90 degree separation where the views are 45 degrees left and 45 degrees right)"};
+cvar_t scr_zoomwindow = {CVAR_SAVE, "scr_zoomwindow", "0", "displays a zoomed in overlay window"};
+cvar_t scr_zoomwindow_viewsizex = {CVAR_SAVE, "scr_zoomwindow_viewsizex", "20", "horizontal viewsize of zoom window"};
+cvar_t scr_zoomwindow_viewsizey = {CVAR_SAVE, "scr_zoomwindow_viewsizey", "20", "vertical viewsize of zoom window"};
+cvar_t scr_zoomwindow_fov = {CVAR_SAVE, "scr_zoomwindow_fov", "20", "fov of zoom window"};
+cvar_t scr_stipple = {0, "scr_stipple", "0", "interlacing-like stippling of the display"};
+cvar_t scr_refresh = {0, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"};
+cvar_t shownetgraph = {CVAR_SAVE, "shownetgraph", "0", "shows a graph of packet sizes and other information, 0 = off, 1 = show client netgraph, 2 = show client and server netgraphs (when hosting a server)"};
+
int jpeg_supported = false;
extern int con_vislines;
-void DrawCrosshair(int num);
static void SCR_ScreenShot_f (void);
static void R_Envmap_f (void);
// backend
void R_ClearScreen(void);
-// color tag printing
-static vec4_t string_colors[] =
-{
- // Quake3 colors
- // LordHavoc: why on earth is cyan before magenta in Quake3?
- // LordHavoc: note: Doom3 uses white for [0] and [7]
- {0.0, 0.0, 0.0, 1.0}, // black
- {1.0, 0.0, 0.0, 1.0}, // red
- {0.0, 1.0, 0.0, 1.0}, // green
- {1.0, 1.0, 0.0, 1.0}, // yellow
- {0.0, 0.0, 1.0, 1.0}, // blue
- {0.0, 1.0, 1.0, 1.0}, // cyan
- {1.0, 0.0, 1.0, 1.0}, // magenta
- {1.0, 1.0, 1.0, 1.0}, // white
- // [515]'s BX_COLOREDTEXT extension
- {1.0, 1.0, 1.0, 0.5}, // half transparent
- {0.5, 0.5, 0.5, 1.0} // half brightness
- // Black's color table
- //{1.0, 1.0, 1.0, 1.0},
- //{1.0, 0.0, 0.0, 1.0},
- //{0.0, 1.0, 0.0, 1.0},
- //{0.0, 0.0, 1.0, 1.0},
- //{1.0, 1.0, 0.0, 1.0},
- //{0.0, 1.0, 1.0, 1.0},
- //{1.0, 0.0, 1.0, 1.0},
- //{0.1, 0.1, 0.1, 1.0}
-};
-
-#define STRING_COLORS_COUNT (sizeof(string_colors) / sizeof(vec4_t))
-
-// color is read and changed in the end
-void DrawQ_ColoredString( float x, float y, const char *text, int maxlen, float scalex, float scaley, float basered, float basegreen, float baseblue, float basealpha, int flags, int *outcolor )
-{
- vec_t *color;
- int len;
- int colorindex;
- const char *start, *current;
-
- if( !outcolor || *outcolor == -1 ) {
- colorindex = STRING_COLOR_DEFAULT;
- } else {
- colorindex = *outcolor;
- }
- color = string_colors[colorindex];
-
- if( maxlen < 1)
- len = (int)strlen( text );
- else
- len = min( maxlen, (int) strlen( text ) );
-
- start = current = text;
- while( len > 0 ) {
- // check for color control char
- if( *current == STRING_COLOR_TAG ) {
- // get next char
- current++;
- len--;
- if( len == 0 ) {
- break;
- }
- // display the tag char?
- if( *current == STRING_COLOR_TAG ) {
- // only display one of the two
- start = current;
- // get the next char
- current++;
- len--;
- } else if( '0' <= *current && *current <= '9' ) {
- colorindex = 0;
- do {
- colorindex = colorindex * 10 + (*current - '0');
- // only read as long as it makes a valid index
- if( colorindex >= (int)STRING_COLORS_COUNT ) {
- // undo the last operation
- colorindex /= 10;
- break;
- }
- current++;
- len--;
- } while( len > 0 && '0' <= *current && *current <= '9' );
- // set the color
- color = string_colors[colorindex];
- // we jump over the color tag
- start = current;
- }
- }
- // go on and read normal text in until the next control char
- while( len > 0 && *current != STRING_COLOR_TAG ) {
- current++;
- len--;
- }
- // display the text
- if( start != current ) {
- // draw the string
- DrawQ_String( x, y, start, current - start, scalex, scaley, basered * color[0], basegreen * color[1], baseblue * color[2], basealpha * color[3], flags );
- // update x to be at the new start position
- x += (current - start) * scalex;
- // set start accordingly
- start = current;
- }
- }
-
- // return the last colorindex
- if( outcolor ) {
- *outcolor = colorindex;
- }
-}
-
/*
===============================================================================
===============================================================================
*/
-char scr_centerstring[1024];
+char scr_centerstring[MAX_INPUTLINE];
float scr_centertime_start; // for slow victory printing
float scr_centertime_off;
int scr_center_lines;
void SCR_DrawCenterString (void)
{
char *start;
- int l;
int x, y;
int remaining;
int color;
-// the finale prints the characters one at a time
- if (cl.intermission)
- remaining = scr_printspeed.value * (cl.time - scr_centertime_start);
+ if(gamemode == GAME_NEXUIZ)
+ if(cl.intermission == 2) // in Nexuiz finale (voting screen),
+ if(sb_showscores) // make TAB hide vote messages
+ return;
+
+// the finale prints the characters one at a time, except if printspeed is an absurdly high value
+ if (cl.intermission && scr_printspeed.value > 0 && scr_printspeed.value < 1000000)
+ remaining = (int)(scr_printspeed.value * (cl.time - scr_centertime_start));
else
remaining = 9999;
scr_erase_center = 0;
start = scr_centerstring;
+ if (remaining < 1)
+ return;
+
if (scr_center_lines <= 4)
- y = vid_conheight.integer*0.35;
+ y = (int)(vid_conheight.integer*0.35);
else
y = 48;
color = -1;
do
{
- // scan the width of the line
- for (l=0 ; l<vid_conwidth.integer/8 ; l++)
- if (start[l] == '\n' || !start[l])
- break;
- x = (vid_conwidth.integer - l*8)/2;
+ // scan the number of characters on the line, not counting color codes
+ char *newline = strchr(start, '\n');
+ int l = newline ? (newline - start) : (int)strlen(start);
+ int chars = COM_StringLengthNoColors(start, l, NULL);
+
+ x = (vid_conwidth.integer - chars*8)/2;
if (l > 0)
{
if (remaining < l)
l = remaining;
- DrawQ_ColoredString(x, y, start, l, 8, 8, 1, 1, 1, 1, 0, &color);
+ DrawQ_String(x, y, start, l, 8, 8, 1, 1, 1, 1, 0, &color, false);
remaining -= l;
if (remaining <= 0)
return;
}
-
y += 8;
- while (*start && *start != '\n')
- start++;
-
- if (!*start)
+ if (!newline)
break;
- start++; // skip the \n
+ start = newline + 1; // skip the \n
} while (1);
}
if (scr_center_lines > scr_erase_lines)
scr_erase_lines = scr_center_lines;
- scr_centertime_off -= host_frametime;
+ if (cl.time > cl.oldtime)
+ scr_centertime_off -= cl.time - cl.oldtime;
// don't draw if this is a normal stats-screen intermission,
// only if it is not an intermission, or a finale intermission
SCR_DrawCenterString ();
}
+void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int barwidth, int barheight, int bardivide, const char *label, float textsize, int packetcounter, int numparameters, const int **parameters, const float parametercolors[][4])
+{
+ int j, k, x, y, index, offset, height;
+ // draw the bar graph itself
+ // advance the packet counter because it is the latest packet column being
+ // built up and should come last
+ packetcounter = (packetcounter + 1) % NETGRAPH_PACKETS;
+ for (j = 0;j < NETGRAPH_PACKETS;j++)
+ {
+ x = graphx + j * barwidth;
+ y = graphy + barheight;
+ index = (packetcounter + j) % NETGRAPH_PACKETS;
+ if (parameters[0][index] == NETGRAPH_LOSTPACKET)
+ DrawQ_Fill(x, y - barheight, barwidth, barheight, 1, 0, 0, 1, 0);
+ else if (parameters[0][index] == NETGRAPH_CHOKEDPACKET)
+ DrawQ_Fill(x, y - min(2, barheight), barwidth, min(2, barheight), 1, 1, 0, 1, 0);
+ else
+ {
+ offset = 0;
+ for (k = 0;k < numparameters;k++)
+ {
+ height = (parameters[k][index] + bardivide - 1) / bardivide;
+ height = min(height, barheight - offset);
+ offset += height;
+ if (height)
+ DrawQ_Fill(x, y - offset, barwidth, height, parametercolors[k][0], parametercolors[k][1], parametercolors[k][2], parametercolors[k][3], 0);
+ }
+ }
+ }
+}
+
+const float netgraphcolors[3][4] =
+{
+ {1 , 0.5, 0 , 1},
+ {1 , 1 , 1 , 1},
+ {0 , 1 , 0 , 1},
+};
+
+void SCR_DrawNetGraph_DrawConnection_Client (netconn_t *conn, int graphx, int graphy, int barwidth, int barheight, int bardivide, const char *labelincoming, int separator, const char *labeloutgoing, float textsize)
+{
+ int numparameters;
+ const int *parameters[3];
+ // dim background
+ DrawQ_Fill(graphx , graphy, barwidth * NETGRAPH_PACKETS, barheight + textsize, 0, 0, 0, 0.5, 0);
+ DrawQ_Fill(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy, barwidth * NETGRAPH_PACKETS, barheight + textsize, 0, 0, 0, 0.5, 0);
+ // draw the bar graphs
+ numparameters = 3;
+ parameters[0] = conn->incoming_unreliablesize;
+ parameters[1] = conn->incoming_reliablesize;
+ parameters[2] = conn->incoming_acksize;
+ SCR_DrawNetGraph_DrawGraph(graphx, graphy, barwidth, barheight, bardivide, labelincoming, textsize, conn->incoming_packetcounter, numparameters, parameters, netgraphcolors);
+ parameters[0] = conn->outgoing_unreliablesize;
+ parameters[1] = conn->outgoing_reliablesize;
+ parameters[2] = conn->outgoing_acksize;
+ SCR_DrawNetGraph_DrawGraph(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy, barwidth, barheight, bardivide, labeloutgoing, textsize, conn->outgoing_packetcounter, numparameters, parameters, netgraphcolors);
+ // draw labels
+ DrawQ_String(graphx , graphy + barheight, labelincoming, 0, textsize, textsize, 1, 1, 1, 1, 0, NULL, false);
+ DrawQ_String(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy + barheight, labeloutgoing, 0, textsize, textsize, 1, 1, 1, 1, 0, NULL, false);
+}
+
+void SCR_DrawNetGraph_DrawConnection_Server (netconn_t *conn, int graphx, int graphy, int barwidth, int barheight, int bardivide, const char *labeloutgoing, int separator, const char *labelincoming, float textsize)
+{
+ int numparameters;
+ const int *parameters[3];
+ // dim background
+ DrawQ_Fill(graphx , graphy, barwidth * NETGRAPH_PACKETS, barheight + textsize, 0, 0, 0, 0.5, 0);
+ DrawQ_Fill(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy, barwidth * NETGRAPH_PACKETS, barheight + textsize, 0, 0, 0, 0.5, 0);
+ // draw the bar graphs
+ numparameters = 3;
+ parameters[0] = conn->outgoing_unreliablesize;
+ parameters[1] = conn->outgoing_reliablesize;
+ parameters[2] = conn->outgoing_acksize;
+ SCR_DrawNetGraph_DrawGraph(graphx , graphy, barwidth, barheight, bardivide, labeloutgoing, textsize, conn->outgoing_packetcounter, numparameters, parameters, netgraphcolors);
+ parameters[0] = conn->incoming_unreliablesize;
+ parameters[1] = conn->incoming_reliablesize;
+ parameters[2] = conn->incoming_acksize;
+ SCR_DrawNetGraph_DrawGraph(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy, barwidth, barheight, bardivide, labelincoming, textsize, conn->incoming_packetcounter, numparameters, parameters, netgraphcolors);
+ // draw labels
+ DrawQ_String(graphx , graphy + barheight, labeloutgoing, 0, textsize, textsize, 1, 1, 1, 1, 0, NULL, false);
+ DrawQ_String(graphx + barwidth * NETGRAPH_PACKETS + separator, graphy + barheight, labelincoming, 0, textsize, textsize, 1, 1, 1, 1, 0, NULL, false);
+}
+
+/*
+==============
+SCR_DrawNetGraph
+==============
+*/
+void SCR_DrawNetGraph (void)
+{
+ int i, separator1, separator2, barwidth, barheight, bardivide, netgraph_x, netgraph_y, textsize, index, netgraphsperrow;
+
+ if (cls.state != ca_connected)
+ return;
+ if (!cls.netcon)
+ return;
+ if (!shownetgraph.integer)
+ return;
+
+ separator1 = 2;
+ separator2 = 4;
+ textsize = 8;
+ barwidth = 1;
+ barheight = 50;
+ bardivide = 20;
+
+ netgraphsperrow = (vid_conwidth.integer + separator2) / (barwidth * NETGRAPH_PACKETS * 2 + separator1 + separator2);
+ netgraphsperrow = max(netgraphsperrow, 1);
+
+ index = 0;
+ netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (barwidth * NETGRAPH_PACKETS * 2 + separator1 + separator2);
+ netgraph_y = (vid_conheight.integer - 48 + separator2) - (1 + (index / netgraphsperrow)) * (barheight + textsize + separator2);
+ SCR_DrawNetGraph_DrawConnection_Client(cls.netcon, netgraph_x, netgraph_y, barwidth, barheight, bardivide, "incoming", separator1, "outgoing", textsize);
+ index++;
+
+ if (sv.active && shownetgraph.integer >= 2)
+ {
+ for (i = 0;i < svs.maxclients;i++)
+ {
+ if (!svs.clients[i].netconnection)
+ continue;
+ netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (barwidth * NETGRAPH_PACKETS * 2 + separator1 + separator2);
+ netgraph_y = (vid_conheight.integer - 48 + separator2) - (1 + (index / netgraphsperrow)) * (barheight + textsize + separator2);
+ SCR_DrawNetGraph_DrawConnection_Server(svs.clients[i].netconnection, netgraph_x, netgraph_y, barwidth, barheight, bardivide, va("%s", svs.clients[i].name), separator1, "", textsize);
+ index++;
+ }
+ }
+}
+
/*
==============
SCR_DrawTurtle
if (!scr_showturtle.integer)
return;
- if (host_frametime < 0.1)
+ if (cl.realframetime < 0.1)
{
count = 0;
return;
if (count < 3)
return;
- DrawQ_Pic (0, 0, "gfx/turtle", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (0, 0, Draw_CachePic("gfx/turtle", true), 0, 0, 1, 1, 1, 1, 0);
}
/*
if (cls.demoplayback)
return;
- DrawQ_Pic (64, 0, "gfx/net", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (64, 0, Draw_CachePic("gfx/net", true), 0, 0, 1, 1, 1, 1, 0);
}
/*
return;
pic = Draw_CachePic ("gfx/pause", true);
- DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, "gfx/pause", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, pic, 0, 0, 1, 1, 1, 1, 0);
}
/*
return;
}
- DrawQ_Pic (x, y, "gfx/brand", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (x, y, pic, 0, 0, 1, 1, 1, 1, 0);
}
-//=============================================================================
+/*
+==============
+SCR_DrawQWDownload
+==============
+*/
+static int SCR_DrawQWDownload(int offset)
+{
+ int len;
+ float x, y;
+ float size = 8;
+ char temp[256];
+ if (!cls.qw_downloadname[0])
+ {
+ cls.qw_downloadspeedrate = 0;
+ cls.qw_downloadspeedtime = realtime;
+ cls.qw_downloadspeedcount = 0;
+ return 0;
+ }
+ if (realtime >= cls.qw_downloadspeedtime + 1)
+ {
+ cls.qw_downloadspeedrate = cls.qw_downloadspeedcount;
+ cls.qw_downloadspeedtime = realtime;
+ cls.qw_downloadspeedcount = 0;
+ }
+ if (cls.protocol == PROTOCOL_QUAKEWORLD)
+ dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i) at %i bytes/s\n", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadspeedrate);
+ else
+ dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i/%i) at %i bytes/s\n", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadmemorymaxsize, cls.qw_downloadspeedrate);
+ len = (int)strlen(temp);
+ x = (vid_conwidth.integer - len*size) / 2;
+ y = vid_conheight.integer - size - offset;
+ DrawQ_Fill(0, y, vid_conwidth.integer, size, 0, 0, 0, 0.5, 0);
+ DrawQ_String(x, y, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true);
+ return 8;
+}
+
+/*
+==============
+SCR_DrawCurlDownload
+==============
+*/
+static int SCR_DrawCurlDownload(int offset)
+{
+ int len;
+ int nDownloads;
+ int i;
+ float x, y;
+ float size = 8;
+ Curl_downloadinfo_t *downinfo;
+ char temp[256];
+ const char *addinfo;
+
+ downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo);
+ if(!downinfo)
+ return 0;
+
+ y = vid_conheight.integer - size * nDownloads - offset;
+
+ if(addinfo)
+ {
+ len = (int)strlen(addinfo);
+ x = (vid_conwidth.integer - len*size) / 2;
+ DrawQ_Fill(0, y - size, vid_conwidth.integer, size, 1, 1, 1, 0.8, 0);
+ DrawQ_String(x, y - size, addinfo, len, size, size, 0, 0, 0, 1, 0, NULL, true);
+ }
+
+ for(i = 0; i != nDownloads; ++i)
+ {
+ if(downinfo[i].queued)
+ dpsnprintf(temp, sizeof(temp), "Still in queue: %s\n", downinfo[i].filename);
+ else if(downinfo[i].progress <= 0)
+ dpsnprintf(temp, sizeof(temp), "Downloading %s ... ???.?%% @ %.1f KiB/s\n", downinfo[i].filename, downinfo[i].speed / 1024.0);
+ else
+ dpsnprintf(temp, sizeof(temp), "Downloading %s ... %5.1f%% @ %.1f KiB/s\n", downinfo[i].filename, 100.0 * downinfo[i].progress, downinfo[i].speed / 1024.0);
+ len = (int)strlen(temp);
+ x = (vid_conwidth.integer - len*size) / 2;
+ DrawQ_Fill(0, y + i * size, vid_conwidth.integer, size, 0, 0, 0, 0.8, 0);
+ DrawQ_String(x, y + i * size, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true);
+ }
+
+ Z_Free(downinfo);
+
+ return 8 * (nDownloads + (addinfo ? 1 : 0));
+}
+/*
+==============
+SCR_DrawDownload
+==============
+*/
+static void SCR_DrawDownload()
+{
+ int offset = 0;
+ offset += SCR_DrawQWDownload(offset);
+ offset += SCR_DrawCurlDownload(offset);
+}
+
+//=============================================================================
/*
==================
{
// lines of console to display
float conlines;
+ static int framecounter = 0;
Con_CheckResize ();
- if (key_dest == key_game && cls.signon != SIGNONS && scr_conforcewhiledisconnected.integer)
+ if (scr_menuforcewhiledisconnected.integer && key_dest == key_game && cls.state == ca_disconnected)
+ {
+ if (framecounter >= 2)
+ MR_ToggleMenu_f();
+ else
+ framecounter++;
+ }
+ else
+ framecounter = 0;
+
+ if (scr_conforcewhiledisconnected.integer && key_dest == key_game && cls.signon != SIGNONS)
key_consoleactive |= KEY_CONSOLEACTIVE_FORCED;
else
key_consoleactive &= ~KEY_CONSOLEACTIVE_FORCED;
else
conlines = 0; // none visible
- if (scr_conspeed.value)
- {
- if (scr_con_current > conlines)
- {
- scr_con_current -= scr_conspeed.value*host_realframetime;
- if (scr_con_current < conlines)
- scr_con_current = conlines;
-
- }
- else if (scr_con_current < conlines)
- {
- scr_con_current += scr_conspeed.value*host_realframetime;
- if (scr_con_current > conlines)
- scr_con_current = conlines;
- }
- }
- else
- scr_con_current = conlines;
+ scr_con_current = conlines;
}
/*
Con_DrawConsole (vid_conheight.integer);
}
else if (scr_con_current)
- Con_DrawConsole (scr_con_current);
+ Con_DrawConsole ((int)scr_con_current);
else
{
con_vislines = 0;
- if (key_dest == key_game || key_dest == key_message)
+ if ((key_dest == key_game || key_dest == key_message) && !r_letterbox.value)
Con_DrawNotify (); // only draw notify in game
}
}
*/
void SCR_BeginLoadingPlaque (void)
{
+ // save console log up to this point to log_file if it was set by configs
+ Log_Start();
+
Host_StartVideo();
S_StopAllSounds();
- SCR_UpdateLoadingScreen();
+ SCR_UpdateLoadingScreen(false);
}
//=============================================================================
int length;
int t;
- if (!r_timereport_active || r_showtrispass)
+ if (r_speeds.integer < 2 || !r_timereport_active)
return;
- qglFinish();
+ CHECKGLERROR
+ qglFinish();CHECKGLERROR
r_timereport_temp = r_timereport_current;
r_timereport_current = Sys_DoubleTime();
- t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0);
+ t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0 + 0.5);
- dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
+ dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %-11s", t, desc);
length = (int)strlen(tempbuf);
- while (length < 20)
- tempbuf[length++] = ' ';
- tempbuf[length] = 0;
if (speedstringcount + length > (vid_conwidth.integer / 8))
{
strlcat(r_speeds_string, "\n", sizeof(r_speeds_string));
speedstringcount = 0;
}
- // skip the space at the beginning if it's the first on the line
- if (speedstringcount == 0)
- {
- strlcat(r_speeds_string, tempbuf + 1, sizeof(r_speeds_string));
- speedstringcount = length - 1;
- }
- else
- {
- strlcat(r_speeds_string, tempbuf, sizeof(r_speeds_string));
- speedstringcount += length;
- }
-}
-
-void R_TimeReport_Start(void)
-{
- r_timereport_active = r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected;
- r_speeds_string[0] = 0;
- if (r_timereport_active)
- {
- speedstringcount = 0;
- sprintf(r_speeds_string + strlen(r_speeds_string), "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n", r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], r_viewforward[0], r_viewforward[1], r_viewforward[2]);
- sprintf(r_speeds_string + strlen(r_speeds_string), "%5i entities%6i surfaces%6i triangles%5i leafs%5i portals%6i particles\n", renderstats.entities, renderstats.entities_surfaces, renderstats.entities_triangles, renderstats.world_leafs, renderstats.world_portals, renderstats.particles);
- sprintf(r_speeds_string + strlen(r_speeds_string), "%4i lights%4i clears%4i scissored%7i light%7i shadow%i7 dynamic\n", renderstats.lights, renderstats.lights_clears, renderstats.lights_scissored, renderstats.lights_lighttriangles, renderstats.lights_shadowtriangles, renderstats.lights_dynamicshadowtriangles);
- if (renderstats.bloom)
- sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles bloompixels%8i copied%8i drawn\n", renderstats.meshes, renderstats.meshes_elements / 3, renderstats.bloom_copypixels, renderstats.bloom_drawpixels);
- else
- sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles\n", renderstats.meshes, renderstats.meshes_elements / 3);
-
- r_timereport_start = Sys_DoubleTime();
- }
-
- memset(&renderstats, 0, sizeof(renderstats));
+ strlcat(r_speeds_string, tempbuf, sizeof(r_speeds_string));
+ speedstringcount += length;
}
-void R_TimeReport_End(void)
+void R_TimeReport_Frame(void)
{
- r_timereport_current = r_timereport_start;
- R_TimeReport("total");
+ int i, j, lines, y;
+ cl_locnode_t *loc;
- if (r_timereport_active)
+ if (r_speeds_string[0])
{
- int i, j, lines, y;
+ if (r_timereport_active)
+ {
+ r_timereport_current = r_timereport_start;
+ R_TimeReport("total");
+ }
+
+ if (r_speeds_string[strlen(r_speeds_string)-1] == '\n')
+ r_speeds_string[strlen(r_speeds_string)-1] = 0;
lines = 1;
for (i = 0;r_speeds_string[i];i++)
if (r_speeds_string[i] == '\n')
while (r_speeds_string[i] && r_speeds_string[i] != '\n')
i++;
if (i - j > 0)
- DrawQ_String(0, y, r_speeds_string + j, i - j, 8, 8, 1, 1, 1, 1, 0);
+ DrawQ_String(0, y, r_speeds_string + j, i - j, 8, 8, 1, 1, 1, 1, 0, NULL, true);
if (r_speeds_string[i] == '\n')
i++;
y += 8;
}
+ r_speeds_string[0] = 0;
+ r_timereport_active = false;
+ }
+ if (r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected)
+ {
+ speedstringcount = 0;
+ r_speeds_string[0] = 0;
+ r_timereport_active = false;
+ // put the location name in the r_speeds display as it greatly helps
+ // when creating loc files
+ loc = CL_Locs_FindNearest(cl.movement_origin);
+ if (loc)
+ sprintf(r_speeds_string + strlen(r_speeds_string), "Location: %s\n", loc->name);
+ sprintf(r_speeds_string + strlen(r_speeds_string), "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n", r_view.origin[0], r_view.origin[1], r_view.origin[2], r_view.forward[0], r_view.forward[1], r_view.forward[2]);
+ sprintf(r_speeds_string + strlen(r_speeds_string), "%5i entities%6i surfaces%6i triangles%5i leafs%5i portals%6i particles\n", r_refdef.stats.entities, r_refdef.stats.entities_surfaces, r_refdef.stats.entities_triangles, r_refdef.stats.world_leafs, r_refdef.stats.world_portals, r_refdef.stats.particles);
+ sprintf(r_speeds_string + strlen(r_speeds_string), "%4i lights%4i clears%4i scissored%7i light%7i shadow%7i dynamic\n", r_refdef.stats.lights, r_refdef.stats.lights_clears, r_refdef.stats.lights_scissored, r_refdef.stats.lights_lighttriangles, r_refdef.stats.lights_shadowtriangles, r_refdef.stats.lights_dynamicshadowtriangles);
+ if (r_refdef.stats.bloom)
+ sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles bloompixels%8i copied%8i drawn\n", r_refdef.stats.meshes, r_refdef.stats.meshes_elements / 3, r_refdef.stats.bloom_copypixels, r_refdef.stats.bloom_drawpixels);
+ else
+ sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles\n", r_refdef.stats.meshes, r_refdef.stats.meshes_elements / 3);
+
+ memset(&r_refdef.stats, 0, sizeof(r_refdef.stats));
+
+ if (r_speeds.integer >= 2)
+ {
+ r_timereport_active = true;
+ r_timereport_start = r_timereport_current = Sys_DoubleTime();
+ }
}
}
Cvar_SetValue ("viewsize",scr_viewsize.value-10);
}
+void SCR_CaptureVideo_EndVideo(void);
+void CL_Screen_Shutdown(void)
+{
+ SCR_CaptureVideo_EndVideo();
+}
+
void CL_Screen_Init(void)
{
Cvar_RegisterVariable (&scr_fov);
Cvar_RegisterVariable (&scr_viewsize);
- Cvar_RegisterVariable (&scr_conspeed);
Cvar_RegisterVariable (&scr_conalpha);
Cvar_RegisterVariable (&scr_conbrightness);
Cvar_RegisterVariable (&scr_conforcewhiledisconnected);
+ Cvar_RegisterVariable (&scr_menuforcewhiledisconnected);
Cvar_RegisterVariable (&scr_showram);
Cvar_RegisterVariable (&scr_showturtle);
Cvar_RegisterVariable (&scr_showpause);
Cvar_RegisterVariable (&scr_printspeed);
Cvar_RegisterVariable (&vid_conwidth);
Cvar_RegisterVariable (&vid_conheight);
- Cvar_RegisterVariable (&vid_pixelaspect);
+ Cvar_RegisterVariable (&vid_pixelheight);
Cvar_RegisterVariable (&scr_screenshot_jpeg);
Cvar_RegisterVariable (&scr_screenshot_jpeg_quality);
- Cvar_RegisterVariable (&scr_screenshot_gamma);
+ Cvar_RegisterVariable (&scr_screenshot_gammaboost);
Cvar_RegisterVariable (&cl_capturevideo);
- Cvar_RegisterVariable (&cl_capturevideo_sound);
+ Cvar_RegisterVariable (&cl_capturevideo_width);
+ Cvar_RegisterVariable (&cl_capturevideo_height);
+ Cvar_RegisterVariable (&cl_capturevideo_realtime);
Cvar_RegisterVariable (&cl_capturevideo_fps);
- Cvar_RegisterVariable (&cl_capturevideo_rawrgb);
- Cvar_RegisterVariable (&cl_capturevideo_rawyv12);
- Cvar_RegisterVariable (&r_textshadow);
+ Cvar_RegisterVariable (&cl_capturevideo_number);
Cvar_RegisterVariable (&r_letterbox);
-
- Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
- Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
- Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
- Cmd_AddCommand ("envmap", R_Envmap_f);
+ Cvar_RegisterVariable(&r_stereo_separation);
+ Cvar_RegisterVariable(&r_stereo_sidebyside);
+ Cvar_RegisterVariable(&r_stereo_redblue);
+ Cvar_RegisterVariable(&r_stereo_redcyan);
+ Cvar_RegisterVariable(&r_stereo_redgreen);
+ Cvar_RegisterVariable(&r_stereo_angle);
+ Cvar_RegisterVariable(&scr_zoomwindow);
+ Cvar_RegisterVariable(&scr_zoomwindow_viewsizex);
+ Cvar_RegisterVariable(&scr_zoomwindow_viewsizey);
+ Cvar_RegisterVariable(&scr_zoomwindow_fov);
+ Cvar_RegisterVariable(&scr_stipple);
+ Cvar_RegisterVariable(&scr_refresh);
+ Cvar_RegisterVariable(&shownetgraph);
+
+ Cmd_AddCommand ("sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)");
+ Cmd_AddCommand ("sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)");
+ Cmd_AddCommand ("screenshot",SCR_ScreenShot_f, "takes a screenshot of the next rendered frame");
+ Cmd_AddCommand ("envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene");
scr_initialized = true;
}
-void DrawQ_Clear(void)
-{
- r_refdef.drawqueuesize = 0;
-}
-
-static int picelements[6] = {0, 1, 2, 0, 2, 3};
-void DrawQ_Pic(float x, float y, const char *picname, float width, float height, float red, float green, float blue, float alpha, int flags)
-{
- DrawQ_SuperPic(x,y,picname,width,height,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
-}
-
-void DrawQ_String_Real(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
-{
- int size, len;
- drawqueue_t *dq;
- char *out;
- if (alpha < (1.0f / 255.0f))
- return;
- if (maxlen < 1)
- len = (int)strlen(string);
- else
- for (len = 0;len < maxlen && string[len];len++);
- for (;len > 0 && string[0] == ' ';string++, x += scalex, len--);
- for (;len > 0 && string[len - 1] == ' ';len--);
- if (len < 1)
- return;
- if (x >= vid_conwidth.integer || y >= vid_conheight.integer || x < (-scalex * len) || y < (-scaley))
- return;
- size = sizeof(*dq) + ((len + 1 + 3) & ~3);
- if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
- return;
- red = bound(0, red, 1);
- green = bound(0, green, 1);
- blue = bound(0, blue, 1);
- alpha = bound(0, alpha, 1);
- dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
- dq->size = size;
- dq->command = DRAWQUEUE_STRING;
- dq->flags = flags;
- dq->color = ((unsigned int) (red * 255.0f) << 24) | ((unsigned int) (green * 255.0f) << 16) | ((unsigned int) (blue * 255.0f) << 8) | ((unsigned int) (alpha * 255.0f));
- dq->x = x;
- dq->y = y;
- dq->scalex = scalex;
- dq->scaley = scaley;
- out = (char *)(dq + 1);
- memcpy(out, string, len);
- out[len] = 0;
- r_refdef.drawqueuesize += dq->size;
-}
-
-void DrawQ_String(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
-{
- if (r_textshadow.integer)
- DrawQ_String_Real(x+scalex*0.25,y+scaley*0.25,string,maxlen,scalex,scaley,0,0,0,alpha*0.8,flags);
-
- DrawQ_String_Real(x,y,string,maxlen,scalex,scaley,red,green,blue,alpha,flags);
-}
-
-
-
-void DrawQ_Fill (float x, float y, float w, float h, float red, float green, float blue, float alpha, int flags)
-{
- DrawQ_SuperPic(x,y,NULL,w,h,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
-}
-
-void DrawQ_SuperPic(float x, float y, const char *picname, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
-{
- float floats[36];
- cachepic_t *pic;
- drawqueuemesh_t mesh;
- memset(&mesh, 0, sizeof(mesh));
- if (picname && picname[0])
- {
- pic = Draw_CachePic(picname, false);
- if (width == 0)
- width = pic->width;
- if (height == 0)
- height = pic->height;
- mesh.texture = pic->tex;
- }
- mesh.num_triangles = 2;
- mesh.num_vertices = 4;
- mesh.data_element3i = picelements;
- mesh.data_vertex3f = floats;
- mesh.data_texcoord2f = floats + 12;
- mesh.data_color4f = floats + 20;
- memset(floats, 0, sizeof(floats));
- mesh.data_vertex3f[0] = mesh.data_vertex3f[9] = x;
- mesh.data_vertex3f[1] = mesh.data_vertex3f[4] = y;
- mesh.data_vertex3f[3] = mesh.data_vertex3f[6] = x + width;
- mesh.data_vertex3f[7] = mesh.data_vertex3f[10] = y + height;
- mesh.data_texcoord2f[0] = s1;mesh.data_texcoord2f[1] = t1;mesh.data_color4f[ 0] = r1;mesh.data_color4f[ 1] = g1;mesh.data_color4f[ 2] = b1;mesh.data_color4f[ 3] = a1;
- mesh.data_texcoord2f[2] = s2;mesh.data_texcoord2f[3] = t2;mesh.data_color4f[ 4] = r2;mesh.data_color4f[ 5] = g2;mesh.data_color4f[ 6] = b2;mesh.data_color4f[ 7] = a2;
- mesh.data_texcoord2f[4] = s4;mesh.data_texcoord2f[5] = t4;mesh.data_color4f[ 8] = r4;mesh.data_color4f[ 9] = g4;mesh.data_color4f[10] = b4;mesh.data_color4f[11] = a4;
- mesh.data_texcoord2f[6] = s3;mesh.data_texcoord2f[7] = t3;mesh.data_color4f[12] = r3;mesh.data_color4f[13] = g3;mesh.data_color4f[14] = b3;mesh.data_color4f[15] = a3;
- DrawQ_Mesh (&mesh, flags);
-}
-
-void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
-{
- int size;
- void *p;
- drawqueue_t *dq;
- drawqueuemesh_t *m;
- size = sizeof(*dq);
- size += sizeof(drawqueuemesh_t);
- size += sizeof(int[3]) * mesh->num_triangles;
- size += sizeof(float[3]) * mesh->num_vertices;
- size += sizeof(float[2]) * mesh->num_vertices;
- size += sizeof(float[4]) * mesh->num_vertices;
- if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
- return;
- dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
- dq->size = size;
- dq->command = DRAWQUEUE_MESH;
- dq->flags = flags;
- dq->color = 0;
- dq->x = 0;
- dq->y = 0;
- dq->scalex = 0;
- dq->scaley = 0;
- p = (void *)(dq + 1);
- m = (drawqueuemesh_t *)p;p = (unsigned char*)p + sizeof(drawqueuemesh_t);
- m->num_triangles = mesh->num_triangles;
- m->num_vertices = mesh->num_vertices;
- m->texture = mesh->texture;
- m->data_element3i = (int *)p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));p = (unsigned char*)p + m->num_triangles * sizeof(int[3]);
- m->data_vertex3f = (float *)p;memcpy(m->data_vertex3f , mesh->data_vertex3f , m->num_vertices * sizeof(float[3]));p = (unsigned char*)p + m->num_vertices * sizeof(float[3]);
- m->data_texcoord2f = (float *)p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));p = (unsigned char*)p + m->num_vertices * sizeof(float[2]);
- m->data_color4f = (float *)p;memcpy(m->data_color4f , mesh->data_color4f , m->num_vertices * sizeof(float[4]));p = (unsigned char*)p + m->num_vertices * sizeof(float[4]);
- r_refdef.drawqueuesize += dq->size;
-}
-
-void DrawQ_SetClipArea(float x, float y, float width, float height)
-{
- drawqueue_t * dq;
- if(r_refdef.drawqueuesize + (int)sizeof(*dq) > r_refdef.maxdrawqueuesize)
- {
- Con_DPrint("DrawQueue full !\n");
- return;
- }
- dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
- dq->size = sizeof(*dq);
- dq->command = DRAWQUEUE_SETCLIP;
- dq->x = x;
- dq->y = y;
- dq->scalex = width;
- dq->scaley = height;
- dq->flags = 0;
- dq->color = 0;
-
- r_refdef.drawqueuesize += dq->size;
-}
-
-void DrawQ_ResetClipArea(void)
-{
- drawqueue_t *dq;
- if(r_refdef.drawqueuesize + (int)sizeof(*dq) > r_refdef.maxdrawqueuesize)
- {
- Con_DPrint("DrawQueue full !\n");
- return;
- }
- dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
- dq->size = sizeof(*dq);
- dq->command = DRAWQUEUE_RESETCLIP;
- dq->x = 0;
- dq->y = 0;
- dq->scalex = 0;
- dq->scaley = 0;
- dq->flags = 0;
- dq->color = 0;
-
- r_refdef.drawqueuesize += dq->size;
-}
-
/*
==================
SCR_ScreenShot_f
shotnumber++;
}
-typedef enum capturevideoformat_e
+static void SCR_CaptureVideo_RIFF_Start(void)
+{
+ memset(&cls.capturevideo.riffbuffer, 0, sizeof(sizebuf_t));
+ cls.capturevideo.riffbuffer.maxsize = sizeof(cls.capturevideo.riffbufferdata);
+ cls.capturevideo.riffbuffer.data = cls.capturevideo.riffbufferdata;
+}
+
+static void SCR_CaptureVideo_RIFF_Flush(void)
+{
+ if (cls.capturevideo.riffbuffer.cursize > 0)
+ {
+ if (!FS_Write(cls.capturevideo.videofile, cls.capturevideo.riffbuffer.data, cls.capturevideo.riffbuffer.cursize))
+ cls.capturevideo.error = true;
+ cls.capturevideo.riffbuffer.cursize = 0;
+ cls.capturevideo.riffbuffer.overflowed = false;
+ }
+}
+
+static void SCR_CaptureVideo_RIFF_WriteBytes(const unsigned char *data, size_t size)
+{
+ SCR_CaptureVideo_RIFF_Flush();
+ if (!FS_Write(cls.capturevideo.videofile, data, size))
+ cls.capturevideo.error = true;
+}
+
+static void SCR_CaptureVideo_RIFF_Write32(int n)
+{
+ if (cls.capturevideo.riffbuffer.cursize + 4 > cls.capturevideo.riffbuffer.maxsize)
+ SCR_CaptureVideo_RIFF_Flush();
+ MSG_WriteLong(&cls.capturevideo.riffbuffer, n);
+}
+
+static void SCR_CaptureVideo_RIFF_Write16(int n)
+{
+ if (cls.capturevideo.riffbuffer.cursize + 2 > cls.capturevideo.riffbuffer.maxsize)
+ SCR_CaptureVideo_RIFF_Flush();
+ MSG_WriteShort(&cls.capturevideo.riffbuffer, n);
+}
+
+static void SCR_CaptureVideo_RIFF_WriteFourCC(const char *chunkfourcc)
+{
+ if (cls.capturevideo.riffbuffer.cursize + (int)strlen(chunkfourcc) > cls.capturevideo.riffbuffer.maxsize)
+ SCR_CaptureVideo_RIFF_Flush();
+ MSG_WriteUnterminatedString(&cls.capturevideo.riffbuffer, chunkfourcc);
+}
+
+static void SCR_CaptureVideo_RIFF_WriteTerminatedString(const char *string)
+{
+ if (cls.capturevideo.riffbuffer.cursize + (int)strlen(string) > cls.capturevideo.riffbuffer.maxsize)
+ SCR_CaptureVideo_RIFF_Flush();
+ MSG_WriteString(&cls.capturevideo.riffbuffer, string);
+}
+
+static fs_offset_t SCR_CaptureVideo_RIFF_GetPosition(void)
+{
+ SCR_CaptureVideo_RIFF_Flush();
+ return FS_Tell(cls.capturevideo.videofile);
+}
+
+static void SCR_CaptureVideo_RIFF_Push(const char *chunkfourcc, const char *listtypefourcc)
+{
+ SCR_CaptureVideo_RIFF_WriteFourCC(chunkfourcc);
+ SCR_CaptureVideo_RIFF_Write32(0);
+ SCR_CaptureVideo_RIFF_Flush();
+ cls.capturevideo.riffstackstartoffset[cls.capturevideo.riffstacklevel++] = SCR_CaptureVideo_RIFF_GetPosition();
+ if (listtypefourcc)
+ SCR_CaptureVideo_RIFF_WriteFourCC(listtypefourcc);
+}
+
+static void SCR_CaptureVideo_RIFF_Pop(void)
+{
+ fs_offset_t offset;
+ int x;
+ unsigned char sizebytes[4];
+ // write out the chunk size and then return to the current file position
+ cls.capturevideo.riffstacklevel--;
+ offset = SCR_CaptureVideo_RIFF_GetPosition();
+ x = (int)(offset - (cls.capturevideo.riffstackstartoffset[cls.capturevideo.riffstacklevel]));
+ sizebytes[0] = (x) & 0xff;sizebytes[1] = (x >> 8) & 0xff;sizebytes[2] = (x >> 16) & 0xff;sizebytes[3] = (x >> 24) & 0xff;
+ FS_Seek(cls.capturevideo.videofile, -(x + 4), SEEK_END);
+ FS_Write(cls.capturevideo.videofile, sizebytes, 4);
+ FS_Seek(cls.capturevideo.videofile, 0, SEEK_END);
+ if (offset & 1)
+ {
+ unsigned char c = 0;
+ FS_Write(cls.capturevideo.videofile, &c, 1);
+ }
+}
+
+static void SCR_CaptureVideo_RIFF_IndexEntry(const char *chunkfourcc, int chunksize, int flags)
+{
+ if (cls.capturevideo.riffstacklevel != 2)
+ Sys_Error("SCR_Capturevideo_RIFF_IndexEntry: RIFF stack level is %i (should be 2)\n", cls.capturevideo.riffstacklevel);
+ if (cls.capturevideo.riffindexbuffer.cursize + 16 > cls.capturevideo.riffindexbuffer.maxsize)
+ {
+ int oldsize = cls.capturevideo.riffindexbuffer.maxsize;
+ unsigned char *olddata;
+ olddata = cls.capturevideo.riffindexbuffer.data;
+ cls.capturevideo.riffindexbuffer.maxsize = max(cls.capturevideo.riffindexbuffer.maxsize * 2, 4096);
+ cls.capturevideo.riffindexbuffer.data = Mem_Alloc(tempmempool, cls.capturevideo.riffindexbuffer.maxsize);
+ if (olddata)
+ {
+ memcpy(cls.capturevideo.riffindexbuffer.data, olddata, oldsize);
+ Mem_Free(olddata);
+ }
+ }
+ MSG_WriteUnterminatedString(&cls.capturevideo.riffindexbuffer, chunkfourcc);
+ MSG_WriteLong(&cls.capturevideo.riffindexbuffer, flags);
+ MSG_WriteLong(&cls.capturevideo.riffindexbuffer, (int)FS_Tell(cls.capturevideo.videofile) - cls.capturevideo.riffstackstartoffset[1]);
+ MSG_WriteLong(&cls.capturevideo.riffindexbuffer, chunksize);
+}
+
+static void SCR_CaptureVideo_RIFF_Finish(qboolean final)
+{
+ // close the "movi" list
+ SCR_CaptureVideo_RIFF_Pop();
+ // write the idx1 chunk that we've been building while saving the frames
+ if(final && cls.capturevideo.videofile_firstchunkframes_offset)
+ // TODO replace index creating by OpenDML ix##/##ix/indx chunk so it works for more than one AVI part too
+ {
+ SCR_CaptureVideo_RIFF_Push("idx1", NULL);
+ SCR_CaptureVideo_RIFF_WriteBytes(cls.capturevideo.riffindexbuffer.data, cls.capturevideo.riffindexbuffer.cursize);
+ SCR_CaptureVideo_RIFF_Pop();
+ }
+ cls.capturevideo.riffindexbuffer.cursize = 0;
+ // pop the RIFF chunk itself
+ while (cls.capturevideo.riffstacklevel > 0)
+ SCR_CaptureVideo_RIFF_Pop();
+ SCR_CaptureVideo_RIFF_Flush();
+ if(cls.capturevideo.videofile_firstchunkframes_offset)
+ {
+ Con_DPrintf("Finishing first chunk (%d frames)\n", cls.capturevideo.frame);
+ FS_Seek(cls.capturevideo.videofile, cls.capturevideo.videofile_firstchunkframes_offset, SEEK_SET);
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.frame);
+ SCR_CaptureVideo_RIFF_Flush();
+ FS_Seek(cls.capturevideo.videofile, 0, SEEK_END);
+ cls.capturevideo.videofile_firstchunkframes_offset = 0;
+ }
+ else
+ Con_DPrintf("Finishing another chunk (%d frames)\n", cls.capturevideo.frame);
+}
+
+static void SCR_CaptureVideo_RIFF_OverflowCheck(int framesize)
+{
+ fs_offset_t cursize, curfilesize;
+ if (cls.capturevideo.riffstacklevel != 2)
+ Sys_Error("SCR_CaptureVideo_RIFF_OverflowCheck: chunk stack leakage!\n");
+ // check where we are in the file
+ SCR_CaptureVideo_RIFF_Flush();
+ cursize = SCR_CaptureVideo_RIFF_GetPosition() - cls.capturevideo.riffstackstartoffset[0];
+ curfilesize = SCR_CaptureVideo_RIFF_GetPosition();
+
+ // if this would overflow the windows limit of 1GB per RIFF chunk, we need
+ // to close the current RIFF chunk and open another for future frames
+ if (8 + cursize + framesize + cls.capturevideo.riffindexbuffer.cursize + 8 > 1<<30)
+ {
+ SCR_CaptureVideo_RIFF_Finish(false);
+ // begin a new 1GB extended section of the AVI
+ SCR_CaptureVideo_RIFF_Push("RIFF", "AVIX");
+ SCR_CaptureVideo_RIFF_Push("LIST", "movi");
+ }
+}
+
+static void FindFraction(double val, int *num, int *denom, int denomMax)
{
- CAPTUREVIDEOFORMAT_TARGA,
- CAPTUREVIDEOFORMAT_JPEG,
- CAPTUREVIDEOFORMAT_RAWRGB,
- CAPTUREVIDEOFORMAT_RAWYV12
+ int i;
+ double bestdiff;
+ // initialize
+ bestdiff = fabs(val);
+ *num = 0;
+ *denom = 1;
+
+ for(i = 1; i <= denomMax; ++i)
+ {
+ int inum = floor(0.5 + val * i);
+ double diff = fabs(val - inum / (double)i);
+ if(diff < bestdiff)
+ {
+ bestdiff = diff;
+ *num = inum;
+ *denom = i;
+ }
+ }
}
-capturevideoformat_t;
-
-qboolean cl_capturevideo_active = false;
-capturevideoformat_t cl_capturevideo_format;
-static double cl_capturevideo_starttime = 0;
-double cl_capturevideo_framerate = 0;
-static int cl_capturevideo_soundrate = 0;
-static int cl_capturevideo_frame = 0;
-static unsigned char *cl_capturevideo_buffer = NULL;
-static qfile_t *cl_capturevideo_videofile = NULL;
-qfile_t *cl_capturevideo_soundfile = NULL;
-static short cl_capturevideo_rgbtoyuvscaletable[3][3][256];
-static unsigned char cl_capturevideo_yuvnormalizetable[3][256];
-//static unsigned char cl_capturevideo_rgbgammatable[3][256];
void SCR_CaptureVideo_BeginVideo(void)
{
- double gamma, g;
+ double gamma, g, aspect;
+ int width = cl_capturevideo_width.integer, height = cl_capturevideo_height.integer;
+ int n, d;
unsigned int i;
- unsigned char out[44];
- if (cl_capturevideo_active)
+ if (cls.capturevideo.active)
return;
+ memset(&cls.capturevideo, 0, sizeof(cls.capturevideo));
// soundrate is figured out on the first SoundFrame
- cl_capturevideo_active = true;
- cl_capturevideo_starttime = Sys_DoubleTime();
- cl_capturevideo_framerate = bound(1, cl_capturevideo_fps.value, 1000);
- cl_capturevideo_soundrate = 0;
- cl_capturevideo_frame = 0;
- cl_capturevideo_buffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * (3+3+3) + 18);
- gamma = 1.0/scr_screenshot_gamma.value;
+
+ if(width == 0 && height != 0)
+ width = (int) (height * (double)vid.width / ((double)vid.height * vid_pixelheight.value)); // keep aspect
+ if(width != 0 && height == 0)
+ height = (int) (width * ((double)vid.height * vid_pixelheight.value) / (double)vid.width); // keep aspect
+
+ if(width < 2 || width > vid.width) // can't scale up
+ width = vid.width;
+ if(height < 2 || height > vid.height) // can't scale up
+ height = vid.height;
+
+ aspect = vid.width / (vid.height * vid_pixelheight.value);
+
+ // ensure it's all even; if not, scale down a little
+ if(width % 1)
+ --width;
+ if(height % 1)
+ --height;
+
+ cls.capturevideo.width = width;
+ cls.capturevideo.height = height;
+ cls.capturevideo.active = true;
+ cls.capturevideo.starttime = realtime;
+ cls.capturevideo.framerate = bound(1, cl_capturevideo_fps.value, 1000);
+ cls.capturevideo.soundrate = S_GetSoundRate();
+ cls.capturevideo.frame = 0;
+ cls.capturevideo.soundsampleframe = 0;
+ cls.capturevideo.realtime = cl_capturevideo_realtime.integer != 0;
+ cls.capturevideo.screenbuffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3);
+ cls.capturevideo.outbuffer = (unsigned char *)Mem_Alloc(tempmempool, width * height * (3+3+3) + 18);
+ gamma = 1.0/scr_screenshot_gammaboost.value;
+ dpsnprintf(cls.capturevideo.basename, sizeof(cls.capturevideo.basename), "video/dpvideo%03i", cl_capturevideo_number.integer);
+ Cvar_SetValueQuick(&cl_capturevideo_number, cl_capturevideo_number.integer + 1);
/*
for (i = 0;i < 256;i++)
{
unsigned char j = (unsigned char)bound(0, 255*pow(i/255.0, gamma), 255);
- cl_capturevideo_rgbgammatable[0][i] = j;
- cl_capturevideo_rgbgammatable[1][i] = j;
- cl_capturevideo_rgbgammatable[2][i] = j;
+ cls.capturevideo.rgbgammatable[0][i] = j;
+ cls.capturevideo.rgbgammatable[1][i] = j;
+ cls.capturevideo.rgbgammatable[2][i] = j;
}
*/
/*
{
g = 255*pow(i/255.0, gamma);
// Y weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[0][0][i] = (short)(g * 0.299);
- cl_capturevideo_rgbtoyuvscaletable[0][1][i] = (short)(g * 0.587);
- cl_capturevideo_rgbtoyuvscaletable[0][2][i] = (short)(g * 0.114);
+ cls.capturevideo.rgbtoyuvscaletable[0][0][i] = (short)(g * 0.299);
+ cls.capturevideo.rgbtoyuvscaletable[0][1][i] = (short)(g * 0.587);
+ cls.capturevideo.rgbtoyuvscaletable[0][2][i] = (short)(g * 0.114);
// Cb weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[1][0][i] = (short)(g * -0.169);
- cl_capturevideo_rgbtoyuvscaletable[1][1][i] = (short)(g * -0.332);
- cl_capturevideo_rgbtoyuvscaletable[1][2][i] = (short)(g * 0.500);
+ cls.capturevideo.rgbtoyuvscaletable[1][0][i] = (short)(g * -0.169);
+ cls.capturevideo.rgbtoyuvscaletable[1][1][i] = (short)(g * -0.332);
+ cls.capturevideo.rgbtoyuvscaletable[1][2][i] = (short)(g * 0.500);
// Cr weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[2][0][i] = (short)(g * 0.500);
- cl_capturevideo_rgbtoyuvscaletable[2][1][i] = (short)(g * -0.419);
- cl_capturevideo_rgbtoyuvscaletable[2][2][i] = (short)(g * -0.0813);
+ cls.capturevideo.rgbtoyuvscaletable[2][0][i] = (short)(g * 0.500);
+ cls.capturevideo.rgbtoyuvscaletable[2][1][i] = (short)(g * -0.419);
+ cls.capturevideo.rgbtoyuvscaletable[2][2][i] = (short)(g * -0.0813);
// range reduction of YCbCr to valid signal range
- cl_capturevideo_yuvnormalizetable[0][i] = 16 + i * (236-16) / 256;
- cl_capturevideo_yuvnormalizetable[1][i] = 16 + i * (240-16) / 256;
- cl_capturevideo_yuvnormalizetable[2][i] = 16 + i * (240-16) / 256;
+ cls.capturevideo.yuvnormalizetable[0][i] = 16 + i * (236-16) / 256;
+ cls.capturevideo.yuvnormalizetable[1][i] = 16 + i * (240-16) / 256;
+ cls.capturevideo.yuvnormalizetable[2][i] = 16 + i * (240-16) / 256;
}
- if (cl_capturevideo_rawrgb.integer)
+ //if (cl_capturevideo_)
+ //{
+ //}
+ //else
{
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWRGB;
- cl_capturevideo_videofile = FS_Open ("video/dpvideo.rgb", "wb", false, true);
- }
- else if (cl_capturevideo_rawyv12.integer)
- {
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWYV12;
- cl_capturevideo_videofile = FS_Open ("video/dpvideo.yv12", "wb", false, true);
- }
- else if (scr_screenshot_jpeg.integer)
- {
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_JPEG;
- cl_capturevideo_videofile = NULL;
- }
- else
- {
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_TARGA;
- cl_capturevideo_videofile = NULL;
+ cls.capturevideo.format = CAPTUREVIDEOFORMAT_AVI_I420;
+ cls.capturevideo.videofile = FS_Open (va("%s.avi", cls.capturevideo.basename), "wb", false, true);
+ SCR_CaptureVideo_RIFF_Start();
+ // enclosing RIFF chunk (there can be multiple of these in >1GB files, the later ones are "AVIX" instead of "AVI " and have no header/stream info)
+ SCR_CaptureVideo_RIFF_Push("RIFF", "AVI ");
+ // AVI main header
+ SCR_CaptureVideo_RIFF_Push("LIST", "hdrl");
+ SCR_CaptureVideo_RIFF_Push("avih", NULL);
+ SCR_CaptureVideo_RIFF_Write32((int)(1000000.0 / cls.capturevideo.framerate)); // microseconds per frame
+ SCR_CaptureVideo_RIFF_Write32(0); // max bytes per second
+ SCR_CaptureVideo_RIFF_Write32(0); // padding granularity
+ SCR_CaptureVideo_RIFF_Write32(0x910); // flags (AVIF_HASINDEX | AVIF_ISINTERLEAVED | AVIF_TRUSTCKTYPE)
+ cls.capturevideo.videofile_firstchunkframes_offset = SCR_CaptureVideo_RIFF_GetPosition();
+ SCR_CaptureVideo_RIFF_Write32(0); // total frames
+ SCR_CaptureVideo_RIFF_Write32(0); // initial frames
+ if (cls.capturevideo.soundrate)
+ SCR_CaptureVideo_RIFF_Write32(2); // number of streams
+ else
+ SCR_CaptureVideo_RIFF_Write32(1); // number of streams
+ SCR_CaptureVideo_RIFF_Write32(0); // suggested buffer size
+ SCR_CaptureVideo_RIFF_Write32(width); // width
+ SCR_CaptureVideo_RIFF_Write32(height); // height
+ SCR_CaptureVideo_RIFF_Write32(0); // reserved[0]
+ SCR_CaptureVideo_RIFF_Write32(0); // reserved[1]
+ SCR_CaptureVideo_RIFF_Write32(0); // reserved[2]
+ SCR_CaptureVideo_RIFF_Write32(0); // reserved[3]
+ SCR_CaptureVideo_RIFF_Pop();
+ // video stream info
+ SCR_CaptureVideo_RIFF_Push("LIST", "strl");
+ SCR_CaptureVideo_RIFF_Push("strh", "vids");
+ SCR_CaptureVideo_RIFF_WriteFourCC("I420"); // stream fourcc (I420 colorspace, uncompressed)
+ SCR_CaptureVideo_RIFF_Write32(0); // flags
+ SCR_CaptureVideo_RIFF_Write16(0); // priority
+ SCR_CaptureVideo_RIFF_Write16(0); // language
+ SCR_CaptureVideo_RIFF_Write32(0); // initial frames
+ // find an ideal divisor for the framerate
+ FindFraction(cls.capturevideo.framerate, &n, &d, 1000);
+ SCR_CaptureVideo_RIFF_Write32(d); // samples/second divisor
+ SCR_CaptureVideo_RIFF_Write32(n); // samples/second multiplied by divisor
+ SCR_CaptureVideo_RIFF_Write32(0); // start
+ cls.capturevideo.videofile_totalframes_offset1 = SCR_CaptureVideo_RIFF_GetPosition();
+ SCR_CaptureVideo_RIFF_Write32(0); // length
+ SCR_CaptureVideo_RIFF_Write32(width*height+(width/2)*(height/2)*2); // suggested buffer size
+ SCR_CaptureVideo_RIFF_Write32(0); // quality
+ SCR_CaptureVideo_RIFF_Write32(0); // sample size
+ SCR_CaptureVideo_RIFF_Write16(0); // frame left
+ SCR_CaptureVideo_RIFF_Write16(0); // frame top
+ SCR_CaptureVideo_RIFF_Write16(width); // frame right
+ SCR_CaptureVideo_RIFF_Write16(height); // frame bottom
+ SCR_CaptureVideo_RIFF_Pop();
+ // video stream format
+ SCR_CaptureVideo_RIFF_Push("strf", NULL);
+ SCR_CaptureVideo_RIFF_Write32(40); // BITMAPINFO struct size
+ SCR_CaptureVideo_RIFF_Write32(width); // width
+ SCR_CaptureVideo_RIFF_Write32(height); // height
+ SCR_CaptureVideo_RIFF_Write16(3); // planes
+ SCR_CaptureVideo_RIFF_Write16(12); // bitcount
+ SCR_CaptureVideo_RIFF_WriteFourCC("I420"); // compression
+ SCR_CaptureVideo_RIFF_Write32(width*height+(width/2)*(height/2)*2); // size of image
+ SCR_CaptureVideo_RIFF_Write32(0); // x pixels per meter
+ SCR_CaptureVideo_RIFF_Write32(0); // y pixels per meter
+ SCR_CaptureVideo_RIFF_Write32(0); // color used
+ SCR_CaptureVideo_RIFF_Write32(0); // color important
+ SCR_CaptureVideo_RIFF_Pop();
+ // extended format (aspect!)
+ SCR_CaptureVideo_RIFF_Push("vprp", NULL);
+ SCR_CaptureVideo_RIFF_Write32(0); // VideoFormatToken
+ SCR_CaptureVideo_RIFF_Write32(0); // VideoStandard
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.framerate); // dwVerticalRefreshRate (bogus)
+ SCR_CaptureVideo_RIFF_Write32(width); // dwHTotalInT
+ SCR_CaptureVideo_RIFF_Write32(height); // dwVTotalInLines
+ FindFraction(aspect, &n, &d, 1000);
+ SCR_CaptureVideo_RIFF_Write32((n << 16) | d); // dwFrameAspectRatio // TODO a word
+ SCR_CaptureVideo_RIFF_Write32(width); // dwFrameWidthInPixels
+ SCR_CaptureVideo_RIFF_Write32(height); // dwFrameHeightInLines
+ SCR_CaptureVideo_RIFF_Write32(1); // nFieldPerFrame
+ SCR_CaptureVideo_RIFF_Write32(width); // CompressedBMWidth
+ SCR_CaptureVideo_RIFF_Write32(height); // CompressedBMHeight
+ SCR_CaptureVideo_RIFF_Write32(width); // ValidBMHeight
+ SCR_CaptureVideo_RIFF_Write32(height); // ValidBMWidth
+ SCR_CaptureVideo_RIFF_Write32(0); // ValidBMXOffset
+ SCR_CaptureVideo_RIFF_Write32(0); // ValidBMYOffset
+ SCR_CaptureVideo_RIFF_Write32(0); // ValidBMXOffsetInT
+ SCR_CaptureVideo_RIFF_Write32(0); // ValidBMYValidStartLine
+ SCR_CaptureVideo_RIFF_Pop();
+ SCR_CaptureVideo_RIFF_Pop();
+ if (cls.capturevideo.soundrate)
+ {
+ // audio stream info
+ SCR_CaptureVideo_RIFF_Push("LIST", "strl");
+ SCR_CaptureVideo_RIFF_Push("strh", "auds");
+ SCR_CaptureVideo_RIFF_Write32(1); // stream fourcc (PCM audio, uncompressed)
+ SCR_CaptureVideo_RIFF_Write32(0); // flags
+ SCR_CaptureVideo_RIFF_Write16(0); // priority
+ SCR_CaptureVideo_RIFF_Write16(0); // language
+ SCR_CaptureVideo_RIFF_Write32(0); // initial frames
+ SCR_CaptureVideo_RIFF_Write32(1); // samples/second divisor
+ SCR_CaptureVideo_RIFF_Write32((int)(cls.capturevideo.soundrate)); // samples/second multiplied by divisor
+ SCR_CaptureVideo_RIFF_Write32(0); // start
+ cls.capturevideo.videofile_totalsampleframes_offset = SCR_CaptureVideo_RIFF_GetPosition();
+ SCR_CaptureVideo_RIFF_Write32(0); // length
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.soundrate * 2); // suggested buffer size (this is a half second)
+ SCR_CaptureVideo_RIFF_Write32(0); // quality
+ SCR_CaptureVideo_RIFF_Write32(4); // sample size
+ SCR_CaptureVideo_RIFF_Write16(0); // frame left
+ SCR_CaptureVideo_RIFF_Write16(0); // frame top
+ SCR_CaptureVideo_RIFF_Write16(0); // frame right
+ SCR_CaptureVideo_RIFF_Write16(0); // frame bottom
+ SCR_CaptureVideo_RIFF_Pop();
+ // audio stream format
+ SCR_CaptureVideo_RIFF_Push("strf", NULL);
+ SCR_CaptureVideo_RIFF_Write16(1); // format (uncompressed PCM?)
+ SCR_CaptureVideo_RIFF_Write16(2); // channels (stereo)
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.soundrate); // sampleframes per second
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.soundrate * 4); // average bytes per second
+ SCR_CaptureVideo_RIFF_Write16(4); // block align
+ SCR_CaptureVideo_RIFF_Write16(16); // bits per sample
+ SCR_CaptureVideo_RIFF_Write16(0); // size
+ SCR_CaptureVideo_RIFF_Pop();
+ SCR_CaptureVideo_RIFF_Pop();
+ }
+
+ // extended header (for total #frames)
+ SCR_CaptureVideo_RIFF_Push("LIST", "odml");
+ SCR_CaptureVideo_RIFF_Push("dmlh", NULL);
+ cls.capturevideo.videofile_totalframes_offset2 = SCR_CaptureVideo_RIFF_GetPosition();
+ SCR_CaptureVideo_RIFF_Write32(0);
+ SCR_CaptureVideo_RIFF_Pop();
+ SCR_CaptureVideo_RIFF_Pop();
+
+ // close the AVI header list
+ SCR_CaptureVideo_RIFF_Pop();
+ // software that produced this AVI video file
+ SCR_CaptureVideo_RIFF_Push("LIST", "INFO");
+ SCR_CaptureVideo_RIFF_Push("ISFT", NULL);
+ SCR_CaptureVideo_RIFF_WriteTerminatedString(engineversion);
+ SCR_CaptureVideo_RIFF_Pop();
+ // enable this junk filler if you like the LIST movi to always begin at 4KB in the file (why?)
+#if 0
+ SCR_CaptureVideo_RIFF_Push("JUNK", NULL);
+ x = 4096 - SCR_CaptureVideo_RIFF_GetPosition();
+ while (x > 0)
+ {
+ const char *junkfiller = "[ DarkPlaces junk data ]";
+ int i = min(x, (int)strlen(junkfiller));
+ SCR_CaptureVideo_RIFF_WriteBytes((const unsigned char *)junkfiller, i);
+ x -= i;
+ }
+ SCR_CaptureVideo_RIFF_Pop();
+#endif
+ SCR_CaptureVideo_RIFF_Pop();
+ // begin the actual video section now
+ SCR_CaptureVideo_RIFF_Push("LIST", "movi");
+ // we're done with the headers now...
+ SCR_CaptureVideo_RIFF_Flush();
+ if (cls.capturevideo.riffstacklevel != 2)
+ Sys_Error("SCR_CaptureVideo_BeginVideo: broken AVI writing code (stack level is %i (should be 2) at end of headers)\n", cls.capturevideo.riffstacklevel);
}
- if (cl_capturevideo_sound.integer)
+ switch(cls.capturevideo.format)
{
- cl_capturevideo_soundfile = FS_Open ("video/dpvideo.wav", "wb", false, true);
- // wave header will be filled out when video ends
- memset(out, 0, 44);
- FS_Write (cl_capturevideo_soundfile, out, 44);
+ case CAPTUREVIDEOFORMAT_AVI_I420:
+ break;
+ default:
+ break;
}
- else
- cl_capturevideo_soundfile = NULL;
}
void SCR_CaptureVideo_EndVideo(void)
{
- int i, n;
- unsigned char out[44];
- if (!cl_capturevideo_active)
+ if (!cls.capturevideo.active)
return;
- cl_capturevideo_active = false;
+ cls.capturevideo.active = false;
+ if (cls.capturevideo.videofile)
+ {
+ switch(cls.capturevideo.format)
+ {
+ case CAPTUREVIDEOFORMAT_AVI_I420:
+ // close any open chunks
+ SCR_CaptureVideo_RIFF_Finish(true);
+ // go back and fix the video frames and audio samples fields
+ Con_DPrintf("Finishing capture (%d frames, %d audio frames)\n", cls.capturevideo.frame, cls.capturevideo.soundsampleframe);
+ FS_Seek(cls.capturevideo.videofile, cls.capturevideo.videofile_totalframes_offset1, SEEK_SET);
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.frame);
+ SCR_CaptureVideo_RIFF_Flush();
+ FS_Seek(cls.capturevideo.videofile, cls.capturevideo.videofile_totalframes_offset2, SEEK_SET);
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.frame);
+ SCR_CaptureVideo_RIFF_Flush();
+ if (cls.capturevideo.soundrate)
+ {
+ FS_Seek(cls.capturevideo.videofile, cls.capturevideo.videofile_totalsampleframes_offset, SEEK_SET);
+ SCR_CaptureVideo_RIFF_Write32(cls.capturevideo.soundsampleframe);
+ SCR_CaptureVideo_RIFF_Flush();
+ }
+ break;
+ default:
+ break;
+ }
+ FS_Close(cls.capturevideo.videofile);
+ cls.capturevideo.videofile = NULL;
+ }
- if (cl_capturevideo_videofile)
+ if (cls.capturevideo.screenbuffer)
{
- FS_Close(cl_capturevideo_videofile);
- cl_capturevideo_videofile = NULL;
+ Mem_Free (cls.capturevideo.screenbuffer);
+ cls.capturevideo.screenbuffer = NULL;
}
- // finish the wave file
- if (cl_capturevideo_soundfile)
+ if (cls.capturevideo.outbuffer)
{
- i = (int)FS_Tell (cl_capturevideo_soundfile);
- //"RIFF", (int) unknown (chunk size), "WAVE",
- //"fmt ", (int) 16 (chunk size), (short) format 1 (uncompressed PCM), (short) 2 channels, (int) unknown rate, (int) unknown bytes per second, (short) 4 bytes per sample (channels * bytes per channel), (short) 16 bits per channel
- //"data", (int) unknown (chunk size)
- memcpy (out, "RIFF****WAVEfmt \x10\x00\x00\x00\x01\x00\x02\x00********\x04\x00\x10\0data****", 44);
- // the length of the whole RIFF chunk
- n = i - 8;
- out[4] = (n) & 0xFF;
- out[5] = (n >> 8) & 0xFF;
- out[6] = (n >> 16) & 0xFF;
- out[7] = (n >> 24) & 0xFF;
- // rate
- n = cl_capturevideo_soundrate;
- out[24] = (n) & 0xFF;
- out[25] = (n >> 8) & 0xFF;
- out[26] = (n >> 16) & 0xFF;
- out[27] = (n >> 24) & 0xFF;
- // bytes per second (rate * channels * bytes per channel)
- n = cl_capturevideo_soundrate * 2 * 2;
- out[28] = (n) & 0xFF;
- out[29] = (n >> 8) & 0xFF;
- out[30] = (n >> 16) & 0xFF;
- out[31] = (n >> 24) & 0xFF;
- // the length of the data chunk
- n = i - 44;
- out[40] = (n) & 0xFF;
- out[41] = (n >> 8) & 0xFF;
- out[42] = (n >> 16) & 0xFF;
- out[43] = (n >> 24) & 0xFF;
- FS_Seek (cl_capturevideo_soundfile, 0, SEEK_SET);
- FS_Write (cl_capturevideo_soundfile, out, 44);
- FS_Close (cl_capturevideo_soundfile);
- cl_capturevideo_soundfile = NULL;
+ Mem_Free (cls.capturevideo.outbuffer);
+ cls.capturevideo.outbuffer = NULL;
}
- if (cl_capturevideo_buffer)
+ if (cls.capturevideo.riffindexbuffer.data)
{
- Mem_Free (cl_capturevideo_buffer);
- cl_capturevideo_buffer = NULL;
+ Mem_Free(cls.capturevideo.riffindexbuffer.data);
+ cls.capturevideo.riffindexbuffer.data = NULL;
}
- cl_capturevideo_starttime = 0;
- cl_capturevideo_framerate = 0;
- cl_capturevideo_frame = 0;
+ memset(&cls.capturevideo, 0, sizeof(cls.capturevideo));
}
-qboolean SCR_CaptureVideo_VideoFrame(int newframenum)
+// converts from RGB24 to I420 colorspace (identical to YV12 except chroma plane order is reversed), this colorspace is handled by the Intel(r) 4:2:0 codec on Windows
+void SCR_CaptureVideo_ConvertFrame_RGB_to_I420_flip(int width, int height, unsigned char *instart, unsigned char *outstart)
{
- int x = 0, y = 0, width = vid.width, height = vid.height;
- unsigned char *b, *out;
- char filename[32];
+ int x, y;
int outoffset = (width/2)*(height/2);
- //return SCR_ScreenShot(filename, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, cl_capturevideo_buffer + vid.width * vid.height * 6, 0, 0, vid.width, vid.height, false, false, false, jpeg, true);
- // speed is critical here, so do saving as directly as possible
- switch (cl_capturevideo_format)
+ unsigned char *b, *out;
+ // process one line at a time, and CbCr every other line at 2 pixel intervals
+ for (y = 0;y < height;y++)
{
- case CAPTUREVIDEOFORMAT_RAWYV12:
- // FIXME: width/height must be multiple of 2, enforce this?
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
- CHECKGLERROR
- // process one line at a time, and CbCr every other line at 2 pixel intervals
- for (y = 0;y < height;y++)
+ // 1x1 Y
+ for (b = instart + (height-1-y)*width*3, out = outstart + y*width, x = 0;x < width;x++, b += 3, out++)
+ *out = cls.capturevideo.yuvnormalizetable[0][cls.capturevideo.rgbtoyuvscaletable[0][0][b[0]] + cls.capturevideo.rgbtoyuvscaletable[0][1][b[1]] + cls.capturevideo.rgbtoyuvscaletable[0][2][b[2]]];
+ if ((y & 1) == 0)
{
- // 1x1 Y
- for (b = cl_capturevideo_buffer + (height-1-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + y*width, x = 0;x < width;x++, b += 3, out++)
- *out = cl_capturevideo_yuvnormalizetable[0][cl_capturevideo_rgbtoyuvscaletable[0][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[0][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[0][2][b[2]]];
- if ((y & 1) == 0)
+ // 2x2 Cr and Cb planes
+#if 0
+ // low quality, no averaging
+ for (b = instart + (height-2-y)*width*3, out = outstart + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
{
- // 2x2 Cb and Cr planes
-#if 1
- // low quality, no averaging
- for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
- {
- // Cr
- out[0 ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[2][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[2][2][b[2]] + 128];
- // Cb
- out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[1][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[1][2][b[2]] + 128];
- }
+ // Cr
+ out[0 ] = cls.capturevideo.yuvnormalizetable[1][cls.capturevideo.rgbtoyuvscaletable[1][0][b[0]] + cls.capturevideo.rgbtoyuvscaletable[1][1][b[1]] + cls.capturevideo.rgbtoyuvscaletable[1][2][b[2]] + 128];
+ // Cb
+ out[outoffset] = cls.capturevideo.yuvnormalizetable[2][cls.capturevideo.rgbtoyuvscaletable[2][0][b[0]] + cls.capturevideo.rgbtoyuvscaletable[2][1][b[1]] + cls.capturevideo.rgbtoyuvscaletable[2][2][b[2]] + 128];
+ }
#else
- // high quality, averaging
- int inpitch = width*3;
- for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
- {
- int blockr, blockg, blockb;
- blockr = (b[0] + b[3] + b[inpitch+0] + b[inpitch+3]) >> 2;
- blockg = (b[1] + b[4] + b[inpitch+1] + b[inpitch+4]) >> 2;
- blockb = (b[2] + b[5] + b[inpitch+2] + b[inpitch+5]) >> 2;
- // Cr
- out[0 ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[2][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[2][2][blockb] + 128];
- // Cb
- out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[1][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[1][2][blockb] + 128];
- }
-#endif
+ // high quality, averaging
+ int inpitch = width*3;
+ for (b = instart + (height-2-y)*width*3, out = outstart + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
+ {
+ int blockr, blockg, blockb;
+ blockr = (b[0] + b[3] + b[inpitch+0] + b[inpitch+3]) >> 2;
+ blockg = (b[1] + b[4] + b[inpitch+1] + b[inpitch+4]) >> 2;
+ blockb = (b[2] + b[5] + b[inpitch+2] + b[inpitch+5]) >> 2;
+ // Cr
+ out[0 ] = cls.capturevideo.yuvnormalizetable[1][cls.capturevideo.rgbtoyuvscaletable[1][0][blockr] + cls.capturevideo.rgbtoyuvscaletable[1][1][blockg] + cls.capturevideo.rgbtoyuvscaletable[1][2][blockb] + 128];
+ // Cb
+ out[outoffset] = cls.capturevideo.yuvnormalizetable[2][cls.capturevideo.rgbtoyuvscaletable[2][0][blockr] + cls.capturevideo.rgbtoyuvscaletable[2][1][blockg] + cls.capturevideo.rgbtoyuvscaletable[2][2][blockb] + 128];
}
+#endif
}
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
- if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer + width*height*3, width*height+(width/2)*(height/2)*2))
- return false;
- return true;
- case CAPTUREVIDEOFORMAT_RAWRGB:
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
- CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
- if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer, width*height*3))
- return false;
- return true;
- case CAPTUREVIDEOFORMAT_JPEG:
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
- CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+ }
+}
+
+static void SCR_ScaleDown(unsigned char *in, int inw, int inh, unsigned char *out, int outw, int outh)
+{
+ // TODO optimize this function
+
+ int x, y;
+ float area;
+
+ // memcpy is faster than me
+ if(inw == outw && inh == outh)
+ {
+ memcpy(out, in, 3 * inw * inh);
+ return;
+ }
+
+ // otherwise: a box filter
+ area = (float)outw * (float)outh / (float)inw / (float)inh;
+ for(y = 0; y < outh; ++y)
+ {
+ float iny0 = y / (float)outh * inh; int iny0_i = floor(iny0);
+ float iny1 = (y+1) / (float)outh * inh; int iny1_i = ceil(iny1);
+ for(x = 0; x < outw; ++x)
{
- sprintf(filename, "video/dp%06d.jpg", cl_capturevideo_frame);
- if (!JPEG_SaveImage_preflipped (filename, width, height, cl_capturevideo_buffer))
- return false;
+ float inx0 = x / (float)outw * inw; int inx0_i = floor(inx0);
+ float inx1 = (x+1) / (float)outw * inw; int inx1_i = ceil(inx1);
+ float r = 0, g = 0, b = 0;
+ int xx, yy;
+
+ for(yy = iny0_i; yy < iny1_i; ++yy)
+ {
+ float ya = min(yy+1, iny1) - max(iny0, yy);
+ for(xx = inx0_i; xx < inx1_i; ++xx)
+ {
+ float a = ya * (min(xx+1, inx1) - max(inx0, xx));
+ r += a * in[3*(xx + inw * yy)+0];
+ g += a * in[3*(xx + inw * yy)+1];
+ b += a * in[3*(xx + inw * yy)+2];
+ }
+ }
+
+ out[3*(x + outw * y)+0] = r * area;
+ out[3*(x + outw * y)+1] = g * area;
+ out[3*(x + outw * y)+2] = b * area;
}
- return true;
- case CAPTUREVIDEOFORMAT_TARGA:
- //return Image_WriteTGARGB_preflipped (filename, width, height, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, );
- memset (cl_capturevideo_buffer, 0, 18);
- cl_capturevideo_buffer[2] = 2; // uncompressed type
- cl_capturevideo_buffer[12] = (width >> 0) & 0xFF;
- cl_capturevideo_buffer[13] = (width >> 8) & 0xFF;
- cl_capturevideo_buffer[14] = (height >> 0) & 0xFF;
- cl_capturevideo_buffer[15] = (height >> 8) & 0xFF;
- cl_capturevideo_buffer[16] = 24; // pixel size
- qglReadPixels (x, y, width, height, GL_BGR, GL_UNSIGNED_BYTE, cl_capturevideo_buffer + 18);
- CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+ }
+}
+
+qboolean SCR_CaptureVideo_VideoFrame(int newframenum)
+{
+ int x = 0, y = 0, width = cls.capturevideo.width, height = cls.capturevideo.height;
+ unsigned char *in, *out;
+ CHECKGLERROR
+ //return SCR_ScreenShot(filename, cls.capturevideo.buffer, cls.capturevideo.buffer + vid.width * vid.height * 3, cls.capturevideo.buffer + vid.width * vid.height * 6, 0, 0, vid.width, vid.height, false, false, false, jpeg, true);
+ // speed is critical here, so do saving as directly as possible
+ switch (cls.capturevideo.format)
+ {
+ case CAPTUREVIDEOFORMAT_AVI_I420:
+ // if there's no videofile we have to just give up, and abort saving
+ if (!cls.capturevideo.videofile)
+ return false;
+ // FIXME: width/height must be multiple of 2, enforce this?
+ qglReadPixels (x, y, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, cls.capturevideo.screenbuffer);CHECKGLERROR
+ SCR_ScaleDown (cls.capturevideo.screenbuffer, vid.width, vid.height, cls.capturevideo.outbuffer, width, height);
+ in = cls.capturevideo.outbuffer;
+ out = cls.capturevideo.outbuffer + width*height*3;
+ SCR_CaptureVideo_ConvertFrame_RGB_to_I420_flip(width, height, in, out);
+ x = width*height+(width/2)*(height/2)*2;
+ SCR_CaptureVideo_RIFF_OverflowCheck(8 + x);
+ for (;cls.capturevideo.frame < newframenum;cls.capturevideo.frame++)
{
- sprintf(filename, "video/dp%06d.tga", cl_capturevideo_frame);
- if (!FS_WriteFile (filename, cl_capturevideo_buffer, width*height*3 + 18))
- return false;
+ SCR_CaptureVideo_RIFF_IndexEntry("00dc", x, 0x10); // AVIIF_KEYFRAME
+ SCR_CaptureVideo_RIFF_Push("00dc", NULL);
+ SCR_CaptureVideo_RIFF_WriteBytes(out, x);
+ SCR_CaptureVideo_RIFF_Pop();
}
return true;
default:
void SCR_CaptureVideo_SoundFrame(unsigned char *bufstereo16le, size_t length, int rate)
{
- if (!cl_capturevideo_soundfile)
- return;
- cl_capturevideo_soundrate = rate;
- if (FS_Write (cl_capturevideo_soundfile, bufstereo16le, 4 * length) < (fs_offset_t)(4 * length))
+ int x;
+ cls.capturevideo.soundrate = rate;
+ cls.capturevideo.soundsampleframe += length;
+ switch (cls.capturevideo.format)
{
- Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video sound saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
- SCR_CaptureVideo_EndVideo();
+ case CAPTUREVIDEOFORMAT_AVI_I420:
+ x = length*4;
+ SCR_CaptureVideo_RIFF_OverflowCheck(8 + x);
+ SCR_CaptureVideo_RIFF_IndexEntry("01wb", x, 0x10); // AVIIF_KEYFRAME
+ SCR_CaptureVideo_RIFF_Push("01wb", NULL);
+ SCR_CaptureVideo_RIFF_WriteBytes(bufstereo16le, x);
+ SCR_CaptureVideo_RIFF_Pop();
+ break;
+ default:
+ break;
}
}
int newframenum;
if (cl_capturevideo.integer && r_render.integer)
{
- if (!cl_capturevideo_active)
+ if (!cls.capturevideo.active)
SCR_CaptureVideo_BeginVideo();
- if (cl_capturevideo_framerate != cl_capturevideo_fps.value)
+ if (cls.capturevideo.framerate != cl_capturevideo_fps.value)
{
Con_Printf("You can not change the video framerate while recording a video.\n");
- Cvar_SetValueQuick(&cl_capturevideo_fps, cl_capturevideo_framerate);
+ Cvar_SetValueQuick(&cl_capturevideo_fps, cls.capturevideo.framerate);
}
- if (cl_capturevideo_soundfile)
+ // for AVI saving we have to make sure that sound is saved before video
+ if (cls.capturevideo.soundrate && !cls.capturevideo.soundsampleframe)
+ return;
+ if (cls.capturevideo.realtime)
{
// preserve sound sync by duplicating frames when running slow
- newframenum = (Sys_DoubleTime() - cl_capturevideo_starttime) * cl_capturevideo_framerate;
+ newframenum = (int)((realtime - cls.capturevideo.starttime) * cls.capturevideo.framerate);
}
else
- newframenum = cl_capturevideo_frame + 1;
+ newframenum = cls.capturevideo.frame + 1;
// if falling behind more than one second, stop
- if (newframenum - cl_capturevideo_frame > (int)ceil(cl_capturevideo_framerate))
+ if (newframenum - cls.capturevideo.frame > (int)ceil(cls.capturevideo.framerate))
{
Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video saving failed on frame %i, your machine is too slow for this capture speed.\n", cl_capturevideo_frame);
+ Con_Printf("video saving failed on frame %i, your machine is too slow for this capture speed.\n", cls.capturevideo.frame);
SCR_CaptureVideo_EndVideo();
return;
}
// write frames
- if (!SCR_CaptureVideo_VideoFrame(newframenum))
+ SCR_CaptureVideo_VideoFrame(newframenum);
+ if (cls.capturevideo.error)
{
Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
+ Con_Printf("video saving failed on frame %i, out of disk space? stopping video capture.\n", cls.capturevideo.frame);
SCR_CaptureVideo_EndVideo();
}
}
- else if (cl_capturevideo_active)
+ else if (cls.capturevideo.active)
SCR_CaptureVideo_EndVideo();
}
static void R_Envmap_f (void)
{
int j, size;
- char filename[256], basename[256];
+ char filename[MAX_QPATH], basename[MAX_QPATH];
unsigned char *buffer1;
unsigned char *buffer2;
unsigned char *buffer3;
return;
}
- envmap = true;
+ r_refdef.envmap = true;
+
+ R_UpdateVariables();
- r_refdef.x = 0;
- r_refdef.y = 0;
- r_refdef.width = size;
- r_refdef.height = size;
+ r_view.x = 0;
+ r_view.y = 0;
+ r_view.z = 0;
+ r_view.width = size;
+ r_view.height = size;
+ r_view.depth = 1;
- r_refdef.fov_x = 90;
- r_refdef.fov_y = 90;
+ r_view.frustum_x = tan(90 * M_PI / 360.0);
+ r_view.frustum_y = tan(90 * M_PI / 360.0);
buffer1 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
buffer2 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
for (j = 0;j < 12;j++)
{
sprintf(filename, "env/%s%s.tga", basename, envmapinfo[j].name);
- Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], envmapinfo[j].angles[0], envmapinfo[j].angles[1], envmapinfo[j].angles[2], 1);
+ Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, r_view.origin[0], r_view.origin[1], r_view.origin[2], envmapinfo[j].angles[0], envmapinfo[j].angles[1], envmapinfo[j].angles[2], 1);
R_ClearScreen();
R_Mesh_Start();
R_RenderView();
R_Mesh_Finish();
- SCR_ScreenShot(filename, buffer1, buffer2, buffer3, 0, vid.height - (r_refdef.y + r_refdef.height), size, size, envmapinfo[j].flipx, envmapinfo[j].flipy, envmapinfo[j].flipdiagonaly, false, false);
+ SCR_ScreenShot(filename, buffer1, buffer2, buffer3, 0, vid.height - (r_view.y + r_view.height), size, size, envmapinfo[j].flipx, envmapinfo[j].flipy, envmapinfo[j].flipdiagonaly, false, false);
}
Mem_Free (buffer1);
Mem_Free (buffer2);
Mem_Free (buffer3);
- envmap = false;
+ r_refdef.envmap = false;
}
//=============================================================================
int i;
for (i = 0;i < SHOWLMP_MAXLABELS;i++)
if (showlmp[i].isactive)
- DrawQ_Pic(showlmp[i].x, showlmp[i].y, showlmp[i].pic, 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic(showlmp[i].x, showlmp[i].y, Draw_CachePic(showlmp[i].pic, true), 0, 0, 1, 1, 1, 1, 0);
}
void SHOWLMP_clear(void)
showlmp[i].isactive = false;
}
-void CL_SetupScreenSize(void)
+/*
+==============================================================================
+
+ SCREEN SHOTS
+
+==============================================================================
+*/
+
+qboolean SCR_ScreenShot(char *filename, unsigned char *buffer1, unsigned char *buffer2, unsigned char *buffer3, int x, int y, int width, int height, qboolean flipx, qboolean flipy, qboolean flipdiagonal, qboolean jpeg, qboolean gammacorrect)
{
- float conwidth, conheight;
+ int indices[3] = {0,1,2};
+ qboolean ret;
- VID_UpdateGamma(false);
+ if (!r_render.integer)
+ return false;
- conwidth = bound(320, vid_conwidth.value, 2048);
- conheight = bound(200, vid_conheight.value, 1536);
- if (vid_conwidth.value != conwidth)
- Cvar_SetValue("vid_conwidth", conwidth);
- if (vid_conheight.value != conheight)
- Cvar_SetValue("vid_conheight", conheight);
+ CHECKGLERROR
+ qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer1);CHECKGLERROR
+
+ if (scr_screenshot_gammaboost.value != 1 && gammacorrect)
+ {
+ int i;
+ double igamma = 1.0 / scr_screenshot_gammaboost.value;
+ unsigned char ramp[256];
+ for (i = 0;i < 256;i++)
+ ramp[i] = (unsigned char) (pow(i * (1.0 / 255.0), igamma) * 255.0);
+ for (i = 0;i < width*height*3;i++)
+ buffer1[i] = ramp[buffer1[i]];
+ }
- vid_conwidth.integer = vid_conwidth.integer;
- vid_conheight.integer = vid_conheight.integer;
+ Image_CopyMux (buffer2, buffer1, width, height, flipx, flipy, flipdiagonal, 3, 3, indices);
- SCR_SetUpToDrawConsole();
+ if (jpeg)
+ ret = JPEG_SaveImage_preflipped (filename, width, height, buffer2);
+ else
+ ret = Image_WriteTGARGB_preflipped (filename, width, height, buffer2, buffer3);
+
+ return ret;
}
-extern void R_Shadow_EditLights_DrawSelectedLightProperties(void);
-void CL_UpdateScreen(void)
+//=============================================================================
+
+void R_ClearScreen(void)
{
- if (!scr_initialized || !con_initialized || vid_hidden)
- return; // not initialized yet
+ // clear to black
+ CHECKGLERROR
+ if (r_refdef.fogenabled)
+ {
+ qglClearColor(r_refdef.fogcolor[0],r_refdef.fogcolor[1],r_refdef.fogcolor[2],0);CHECKGLERROR
+ }
+ else
+ {
+ qglClearColor(0,0,0,0);CHECKGLERROR
+ }
+ qglClearDepth(1);CHECKGLERROR
+ if (gl_stencil)
+ {
+ // LordHavoc: we use a stencil centered around 128 instead of 0,
+ // to avoid clamping interfering with strange shadow volume
+ // drawing orders
+ qglClearStencil(128);CHECKGLERROR
+ }
+ // clear the screen
+ if (r_render.integer)
+ GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | (gl_stencil ? GL_STENCIL_BUFFER_BIT : 0));
+ // set dithering mode
+ if (gl_dither.integer)
+ {
+ qglEnable(GL_DITHER);CHECKGLERROR
+ }
+ else
+ {
+ qglDisable(GL_DITHER);CHECKGLERROR
+ }
+}
+
+qboolean CL_VM_UpdateView (void);
+void SCR_DrawConsole (void);
+void R_Shadow_EditLights_DrawSelectedLightProperties(void);
+
+int r_stereo_side;
+
+void SCR_DrawScreen (void)
+{
+ R_Mesh_Start();
+
+ if (r_timereport_active)
+ R_TimeReport("setup");
+
+ R_UpdateVariables();
+
+ if (cls.signon == SIGNONS)
+ {
+ float size;
+
+ size = scr_viewsize.value * (1.0 / 100.0);
+ size = min(size, 1);
+
+ if (r_stereo_sidebyside.integer)
+ {
+ r_view.width = (int)(vid.width * size / 2.5);
+ r_view.height = (int)(vid.height * size / 2.5 * (1 - bound(0, r_letterbox.value, 100) / 100));
+ r_view.depth = 1;
+ r_view.x = (int)((vid.width - r_view.width * 2.5) * 0.5);
+ r_view.y = (int)((vid.height - r_view.height)/2);
+ r_view.z = 0;
+ if (r_stereo_side)
+ r_view.x += (int)(r_view.width * 1.5);
+ }
+ else
+ {
+ r_view.width = (int)(vid.width * size);
+ r_view.height = (int)(vid.height * size * (1 - bound(0, r_letterbox.value, 100) / 100));
+ r_view.depth = 1;
+ r_view.x = (int)((vid.width - r_view.width)/2);
+ r_view.y = (int)((vid.height - r_view.height)/2);
+ r_view.z = 0;
+ }
+
+ // LordHavoc: viewzoom (zoom in for sniper rifles, etc)
+ // LordHavoc: this is designed to produce widescreen fov values
+ // when the screen is wider than 4/3 width/height aspect, to do
+ // this it simply assumes the requested fov is the vertical fov
+ // for a 4x3 display, if the ratio is not 4x3 this makes the fov
+ // higher/lower according to the ratio
+ r_view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom;
+ r_view.frustum_x = r_view.frustum_y * (float)r_view.width / (float)r_view.height / vid_pixelheight.value;
+
+ r_view.frustum_x *= r_refdef.frustumscale_x;
+ r_view.frustum_y *= r_refdef.frustumscale_y;
+
+ if(!CL_VM_UpdateView())
+ R_RenderView();
+
+ if (scr_zoomwindow.integer)
+ {
+ float sizex = bound(10, scr_zoomwindow_viewsizex.value, 100) / 100.0;
+ float sizey = bound(10, scr_zoomwindow_viewsizey.value, 100) / 100.0;
+ r_view.width = (int)(vid.width * sizex);
+ r_view.height = (int)(vid.height * sizey);
+ r_view.depth = 1;
+ r_view.x = (int)((vid.width - r_view.width)/2);
+ r_view.y = 0;
+ r_view.z = 0;
+
+ r_view.frustum_y = tan(scr_zoomwindow_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom;
+ r_view.frustum_x = r_view.frustum_y * vid_pixelheight.value * (float)r_view.width / (float)r_view.height;
+
+ r_view.frustum_x *= r_refdef.frustumscale_x;
+ r_view.frustum_y *= r_refdef.frustumscale_y;
+
+ if(!CL_VM_UpdateView())
+ R_RenderView();
+ }
+ }
+
+ if (!r_stereo_sidebyside.integer)
+ {
+ r_view.width = vid.width;
+ r_view.height = vid.height;
+ r_view.depth = 1;
+ r_view.x = 0;
+ r_view.y = 0;
+ r_view.z = 0;
+ }
+
+ // draw 2D stuff
+
+ if (cls.signon == SIGNONS)
+ {
+ SCR_DrawNet ();
+ SCR_DrawTurtle ();
+ SCR_DrawPause ();
+ if (!r_letterbox.value)
+ Sbar_Draw();
+ SHOWLMP_drawall();
+ SCR_CheckDrawCenterString();
+ }
+ SCR_DrawNetGraph ();
+ MR_Draw();
+ CL_DrawVideo();
+ R_Shadow_EditLights_DrawSelectedLightProperties();
+
+ SCR_DrawConsole();
+
+ SCR_DrawBrand();
+
+ SCR_DrawDownload();
+
+ if (r_timereport_active)
+ R_TimeReport("2d");
+
+ if (cls.signon == SIGNONS)
+ R_TimeReport_Frame();
+
+ DrawQ_Finish();
+
+ R_DrawGamma();
+
+ R_Mesh_Finish();
+
+ if (r_timereport_active)
+ R_TimeReport("meshfinish");
+}
- // don't allow cheats in multiplayer
- if (!cl.islocalgame && cl.worldmodel)
+void SCR_UpdateLoadingScreen (qboolean clear)
+{
+ float x, y;
+ cachepic_t *pic;
+ float vertex3f[12];
+ float texcoord2f[8];
+ // don't do anything if not initialized yet
+ if (vid_hidden || !scr_refresh.integer)
+ return;
+ CHECKGLERROR
+ qglViewport(0, 0, vid.width, vid.height);CHECKGLERROR
+ //qglDisable(GL_SCISSOR_TEST);CHECKGLERROR
+ //qglDepthMask(1);CHECKGLERROR
+ qglColorMask(1,1,1,1);CHECKGLERROR
+ qglClearColor(0,0,0,0);CHECKGLERROR
+ // when starting up a new video mode, make sure the screen is cleared to black
+ if (clear)
+ {
+ qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
+ }
+ //qglDisable(GL_CULL_FACE);CHECKGLERROR
+ //R_ClearScreen();
+ R_Textures_Frame();
+ GL_SetupView_Mode_Ortho(0, 0, vid_conwidth.integer, vid_conheight.integer, -10, 100);
+ R_Mesh_Start();
+ R_Mesh_Matrix(&identitymatrix);
+ // draw the loading plaque
+ pic = Draw_CachePic("gfx/loading", true);
+ x = (vid_conwidth.integer - pic->width)/2;
+ y = (vid_conheight.integer - pic->height)/2;
+ GL_Color(1,1,1,1);
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthRange(0, 1);
+ GL_PolygonOffset(0, 0);
+ GL_DepthTest(false);
+ R_Mesh_VertexPointer(vertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_ResetTextureState();
+ R_Mesh_TexBind(0, R_GetTexture(pic->tex));
+ R_Mesh_TexCoordPointer(0, 2, texcoord2f, 0, 0);
+ vertex3f[2] = vertex3f[5] = vertex3f[8] = vertex3f[11] = 0;
+ vertex3f[0] = vertex3f[9] = x;
+ vertex3f[1] = vertex3f[4] = y;
+ vertex3f[3] = vertex3f[6] = x + pic->width;
+ vertex3f[7] = vertex3f[10] = y + pic->height;
+ texcoord2f[0] = 0;texcoord2f[1] = 0;
+ texcoord2f[2] = 1;texcoord2f[3] = 0;
+ texcoord2f[4] = 1;texcoord2f[5] = 1;
+ texcoord2f[6] = 0;texcoord2f[7] = 1;
+ if (vid.stereobuffer)
+ {
+ qglDrawBuffer(GL_FRONT_LEFT);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ qglDrawBuffer(GL_FRONT_RIGHT);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ }
+ else
{
- if (r_fullbright.integer != 0)
- Cvar_Set ("r_fullbright", "0");
- if (r_ambient.value != 0)
- Cvar_Set ("r_ambient", "0");
+ qglDrawBuffer(GL_FRONT);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
}
+ R_Mesh_Finish();
+ // refresh
+ // not necessary when rendering to GL_FRONT buffers
+ //VID_Finish(false);
+ // however this IS necessary on Windows Vista
+ qglFinish();
+}
+
+void CL_UpdateScreen(void)
+{
+ float conwidth, conheight;
+
+ if (vid_hidden || !scr_refresh.integer)
+ return;
+
+ if (!scr_initialized || !con_initialized)
+ return; // not initialized yet
+
+ conwidth = bound(320, vid_conwidth.value, 2048);
+ conheight = bound(200, vid_conheight.value, 1536);
+ if (vid_conwidth.value != conwidth)
+ Cvar_SetValue("vid_conwidth", conwidth);
+ if (vid_conheight.value != conheight)
+ Cvar_SetValue("vid_conheight", conheight);
// bound viewsize
if (scr_viewsize.value < 30)
if (scr_fov.value > 170)
Cvar_Set ("fov","170");
+ // validate r_textureunits cvar
+ if (r_textureunits.integer > gl_textureunits)
+ Cvar_SetValueQuick(&r_textureunits, gl_textureunits);
+ if (r_textureunits.integer < 1)
+ Cvar_SetValueQuick(&r_textureunits, 1);
+
+ // validate gl_combine cvar
+ if (gl_combine.integer && !gl_combine_extension)
+ Cvar_SetValueQuick(&gl_combine, 0);
+
// intermission is always full screen
if (cl.intermission)
sb_lines = 0;
sb_lines = 24+16+8;
}
- r_refdef.colormask[0] = 1;
- r_refdef.colormask[1] = 1;
- r_refdef.colormask[2] = 1;
-
- SCR_CaptureVideo();
+ r_view.colormask[0] = 1;
+ r_view.colormask[1] = 1;
+ r_view.colormask[2] = 1;
- if (cls.signon == SIGNONS)
+ if (r_timereport_active)
R_TimeReport("other");
- CL_SetupScreenSize();
-
- DrawQ_Clear();
+ SCR_SetUpToDrawConsole();
- if (cls.signon == SIGNONS)
- R_TimeReport("setup");
+ if (r_timereport_active)
+ R_TimeReport("start");
- //FIXME: force menu if nothing else to look at?
- //if (key_dest == key_game && cls.signon != SIGNONS && cls.state == ca_disconnected)
+ CHECKGLERROR
+ qglViewport(0, 0, vid.width, vid.height);CHECKGLERROR
+ qglDisable(GL_SCISSOR_TEST);CHECKGLERROR
+ qglDepthMask(1);CHECKGLERROR
+ qglColorMask(1,1,1,1);CHECKGLERROR
+ qglClearColor(0,0,0,0);CHECKGLERROR
+ qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
- if (cls.signon == SIGNONS)
+ if(scr_stipple.integer)
{
- SCR_DrawNet ();
- SCR_DrawTurtle ();
- SCR_DrawPause ();
- if (!r_letterbox.value)
- Sbar_Draw();
- SHOWLMP_drawall();
- SCR_CheckDrawCenterString();
+ GLubyte stipple[128];
+ int i, s, width, parts;
+ static int frame = 0;
+ ++frame;
+
+ s = scr_stipple.integer;
+ parts = (s & 007);
+ width = (s & 070) >> 3;
+
+ qglEnable(GL_POLYGON_STIPPLE); // 0x0B42
+ for(i = 0; i < 128; ++i)
+ {
+ int line = i/4;
+ stipple[i] = (((line >> width) + frame) & ((1 << parts) - 1)) ? 0x00 : 0xFF;
+ }
+ qglPolygonStipple(stipple);
}
- MR_Draw();
- UI_Callback_Draw();
- CL_DrawVideo();
- //ui_draw();
- if (cls.signon == SIGNONS)
+ else
+ qglDisable(GL_POLYGON_STIPPLE);
+
+ if (r_timereport_active)
+ R_TimeReport("clear");
+
+ qglDrawBuffer(GL_BACK);
+
+ if (vid.stereobuffer || r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer || r_stereo_sidebyside.integer)
{
- R_TimeReport("2d");
- R_TimeReport_End();
- R_TimeReport_Start();
- }
- R_Shadow_EditLights_DrawSelectedLightProperties();
+ matrix4x4_t originalmatrix = r_view.matrix;
+ matrix4x4_t offsetmatrix;
+ Matrix4x4_CreateFromQuakeEntity(&offsetmatrix, 0, r_stereo_separation.value * 0.5f, 0, 0, r_stereo_angle.value * 0.5f, 0, 1);
+ Matrix4x4_Concat(&r_view.matrix, &originalmatrix, &offsetmatrix);
- SCR_DrawConsole();
+ if (r_stereo_sidebyside.integer)
+ r_stereo_side = 0;
- SCR_DrawBrand();
+ if (r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer)
+ {
+ r_view.colormask[0] = 1;
+ r_view.colormask[1] = 0;
+ r_view.colormask[2] = 0;
+ }
+
+ if (vid.stereobuffer)
+ qglDrawBuffer(GL_BACK_RIGHT);
+
+ SCR_DrawScreen();
+
+ Matrix4x4_CreateFromQuakeEntity(&offsetmatrix, 0, r_stereo_separation.value * -0.5f, 0, 0, r_stereo_angle.value * -0.5f, 0, 1);
+ Matrix4x4_Concat(&r_view.matrix, &originalmatrix, &offsetmatrix);
+
+ if (r_stereo_sidebyside.integer)
+ r_stereo_side = 1;
+
+ if (r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer)
+ {
+ r_view.colormask[0] = 0;
+ r_view.colormask[1] = r_stereo_redcyan.integer || r_stereo_redgreen.integer;
+ r_view.colormask[2] = r_stereo_redcyan.integer || r_stereo_redblue.integer;
+ }
- SCR_UpdateScreen();
+ if (vid.stereobuffer)
+ qglDrawBuffer(GL_BACK_LEFT);
+
+ SCR_DrawScreen();
+
+ r_view.matrix = originalmatrix;
+ }
+ else
+ SCR_DrawScreen();
+
+ SCR_CaptureVideo();
+
+ VID_Finish(true);
+ if (r_timereport_active)
+ R_TimeReport("finish");
}
void CL_Screen_NewMap(void)
projects / xonotic / darkplaces.git / blobdiff