source/grabber.cpp

   1 #include <algorithm>
   2 #include <stdexcept>
   3 #include <png.h>
   4 #include "arraysize.h"
   5 #include "breakpoint.h"
   6 #include "functions.h"
   7 #include "gldbg.h"
   8 #include "grabber.h"
   9 #include "strformat.h"
  10
  11 using namespace std;
  12
  13 Grabber::Grabber(GlDbg &g):
  14         gldbg(g),
  15         decoder(gldecoder_new(this, NULL)),
  16         frame_num(1),
  17         grab_num(1),
  18         pending_grab(0),
  19         autograb(false)
  20 {
  21         fill(viewport, viewport+4, 0);
  22
  23         gldbg.get_command_interpreter().register_command("grab", this, &Grabber::cmd_grab)
  24                 .set_help("Grab framebuffer contents");
  25         gldbg.get_command_interpreter().register_command("autograb", this, &Grabber::cmd_autograb)
  26                 .set_help("Automatically grab framebuffer contents",
  27                         "autograb frame\n"
  28                         "  Grab at the end of every frame\n\n"
  29                         "autograb draw\n"
  30                         "  Grab after every draw call\n\n"
  31                         "autograb off\n"
  32                         "  Turn off automatic grabbing\n");
  33
  34         decoder->glViewport = glViewport;
  35         decoder->glGetIntegerv = glGetIntegerv;
  36         decoder->glReadPixels = glReadPixels;
  37         decoder->gldBreak = gldBreak;
  38
  39         flavor_init();
  40 }
  41
  42 void Grabber::decode(const char *data, unsigned len)
  43 {
  44         gldecoder_decode(decoder, data, len);
  45 }
  46
  47 void Grabber::process_started()
  48 {
  49         if(autograb)
  50         {
  51                 gldbg.set_breakpoint(break_funcs[0], BREAK_CALL, this);
  52                 if(autograb==2)
  53                 {
  54                         for(unsigned i=1; break_funcs[i]; ++i)
  55                                 gldbg.set_breakpoint(break_funcs[i], BREAK_RETURN, this);
  56                 }
  57         }
  58
  59         frame_num = 1;
  60         grab_num = 1;
  61 }
  62
  63 void Grabber::process_stopped(int reason)
  64 {
  65         if((reason>>8)==3 && pending_grab)
  66         {
  67                 grab();
  68                 if(pending_grab==2)
  69                 {
  70                         gldbg.hold();
  71                         gldbg.get_process().resume();
  72                 }
  73                 else
  74                         gldbg.resume_from_break(this);
  75                 pending_grab = 0;
  76         }
  77 }
  78
  79 void Grabber::cmd_grab(const string &)
  80 {
  81         grab();
  82         if(pending_grab)
  83                 ++pending_grab;
  84         else
  85         {
  86                 gldbg.hold();
  87                 gldbg.get_process().resume();
  88         }
  89 }
  90
  91 void Grabber::cmd_autograb(const string &args)
  92 {
  93         if(args=="off")
  94         {
  95                 autograb = 0;
  96                 if(gldbg.get_process().get_state()!=Process::INACTIVE)
  97                 {
  98                         gldbg.clear_breakpoint(break_funcs[0], BREAK_CALL, this);
  99                         for(unsigned i=1; break_funcs[i]; ++i)
 100                                 gldbg.clear_breakpoint(break_funcs[i], BREAK_RETURN, this);
 101                 }
 102         }
 103         else if(args=="frame")
 104         {
 105                 autograb = 1;
 106                 if(gldbg.get_process().get_state()!=Process::INACTIVE)
 107                         gldbg.set_breakpoint(break_funcs[0], BREAK_CALL, this);
 108         }
 109         else if(args=="draw")
 110         {
 111                 autograb = 2;
 112                 if(gldbg.get_process().get_state()!=Process::INACTIVE)
 113                 {
 114                         gldbg.set_breakpoint(break_funcs[0], BREAK_CALL, this);
 115                         for(unsigned i=1; break_funcs[i]; ++i)
 116                                 gldbg.set_breakpoint(break_funcs[i], BREAK_RETURN, this);
 117                 }
 118         }
 119         else
 120                 throw runtime_error("Invalid autograb mode");
 121 }
 122
 123 void Grabber::grab()
 124 {
 125         if(!viewport[2] || !viewport[3])
 126         {
 127                 GlPacket *pkt = packet_begin(FUNC_GLDQUERYVIEWPORT);
 128                 gldbg.send(pkt);
 129
 130                 gldbg.hold();
 131                 gldbg.get_process().resume();
 132
 133                 pending_grab = 1;
 134                 return;
 135         }
 136
 137         GlPacket *pkt = packet_begin(FUNC_GLDREADPIXELS);
 138         for(unsigned i=0; i<4; ++i)
 139                 packet_write_int(pkt, viewport[i]);
 140         packet_write_int(pkt, GL_RGBA);
 141         packet_write_int(pkt, GL_UNSIGNED_BYTE);
 142         gldbg.send(pkt);
 143 }
 144
 145 int Grabber::write_png(const string &fn, unsigned width, unsigned height, void *data)
 146 {
 147         FILE *out = fopen(fn.c_str(), "w");
 148         if(!out)
 149                 return -1;
 150
 151         png_struct *png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
 152         if(!png)
 153         {
 154                 fclose(out);
 155                 return -1;
 156         }
 157
 158         png_info *info = png_create_info_struct(png);
 159         if(!info)
 160         {
 161                 png_destroy_write_struct(&png, 0);
 162                 fclose(out);
 163                 return -1;
 164         }
 165
 166         if(setjmp(png_jmpbuf(png)))
 167         {
 168                 png_destroy_write_struct(&png, &info);
 169                 fclose(out);
 170                 return -1;
 171         }
 172
 173         png_init_io(png, out);
 174         png_set_IHDR(png, info, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 175
 176         vector<png_byte *> row_ptrs(height);
 177         for(unsigned i=0; i<height; ++i)
 178                 row_ptrs[i] = reinterpret_cast<png_byte *>(data)+(height-1-i)*width*4;
 179         png_set_rows(png, info, &row_ptrs.front());
 180
 181         png_write_png(png, info, PNG_TRANSFORM_IDENTITY, 0);
 182         png_write_end(png, info);
 183
 184         png_destroy_write_struct(&png, &info);
 185         fclose(out);
 186
 187         return 0;
 188 }
 189
 190 void Grabber::next_frame()
 191 {
 192         ++frame_num;
 193         grab_num = 1;
 194 }
 195
 196 void Grabber::glViewport(void *user_data, int x, int y, int width, int height)
 197 {
 198         Grabber *self = reinterpret_cast<Grabber *>(user_data);
 199         self->viewport[0] = x;
 200         self->viewport[1] = y;
 201         self->viewport[2] = width;
 202         self->viewport[3] = height;
 203 }
 204
 205 void Grabber::glGetIntegerv(void *user_data, GLenum pname, int *params)
 206 {
 207         Grabber *self = reinterpret_cast<Grabber *>(user_data);
 208         if(pname==GL_VIEWPORT)
 209                 copy(params, params+4, self->viewport);
 210 }
 211
 212 void Grabber::glReadPixels(void *user_data, int, int, int width, int height, GLenum format, GLenum type, void *data)
 213 {
 214         Grabber *self = reinterpret_cast<Grabber *>(user_data);
 215
 216         string fn = strformat("grab-%04d-%04d.png", self->frame_num, self->grab_num);
 217         if(format==GL_RGBA && type==GL_UNSIGNED_BYTE)
 218         {
 219                 if(self->write_png(fn, width, height, data)<0)
 220                         printf("Failed to write png file %s\n", fn.c_str());
 221                 else
 222                         printf("Grabbed %dx%d png image to %s\n", width, height, fn.c_str());
 223         }
 224
 225         ++self->grab_num;
 226 }
 227
 228 void Grabber::gldBreak(void *user_data, unsigned short func, unsigned char flag)
 229 {
 230         Grabber *self = reinterpret_cast<Grabber *>(user_data);
 231         if(!self->autograb)
 232                 return;
 233
 234         if(flag==BREAK_CALL && func==break_funcs[0])
 235                 self->pending_grab = 1;
 236         else if(flag==BREAK_RETURN && self->autograb>=2)
 237         {
 238                 for(unsigned i=1; (!self->pending_grab && break_funcs[i]); ++i)
 239                         self->pending_grab = (func==break_funcs[i]);
 240         }
 241 }