avsnoop.cpp

   1 #include "avsnoop.hpp"
   2 #include "misc.hpp"
   3
   4 namespace
   5 {
   6         std::list<av_snooper*>* snoopers;
   7         std::list<av_snooper::dump_notification*> notifiers;
   8         std::string s_gamename;
   9         std::string s_rerecords;
  10         double s_gametime;
  11         std::list<std::pair<std::string, std::string>> s_authors;
  12         bool gameinfo_set;
  13 }
  14
  15 av_snooper::av_snooper() throw(std::bad_alloc)
  16 {
  17         if(!snoopers)
  18                 snoopers = new std::list<av_snooper*>();
  19         snoopers->push_back(this);
  20         for(auto i = notifiers.begin(); i != notifiers.end(); i++)
  21                 (*i)->dump_starting();
  22 }
  23
  24 av_snooper::~av_snooper() throw()
  25 {
  26         if(!snoopers)
  27                 return;
  28         for(auto i = snoopers->begin(); i != snoopers->end(); i++)
  29                 if(*i == this) {
  30                         snoopers->erase(i);
  31                         break;
  32                 }
  33         for(auto i = notifiers.begin(); i != notifiers.end(); i++)
  34                 (*i)->dump_ending();
  35 }
  36
  37 void av_snooper::frame(struct lcscreen& _frame, uint32_t fps_n, uint32_t fps_d, window* win) throw()
  38 {
  39         if(!snoopers)
  40                 return;
  41         for(auto i = snoopers->begin(); i != snoopers->end(); i++)
  42                 try {
  43                         (*i)->frame(_frame, fps_n, fps_d, win, true);
  44                 } catch(std::bad_alloc& e) {
  45                         OOM_panic(win);
  46                 } catch(std::exception& e) {
  47                         try {
  48                                 win->message(std::string("Error dumping frame: ") + e.what());
  49                         } catch(...) {
  50                         }
  51                 }
  52 }
  53
  54 void av_snooper::sample(short l, short r, window* win) throw()
  55 {
  56         if(!snoopers)
  57                 return;
  58         for(auto i = snoopers->begin(); i != snoopers->end(); i++)
  59                 try {
  60                         (*i)->sample(l, r);
  61                 } catch(std::bad_alloc& e) {
  62                         OOM_panic(win);
  63                 } catch(std::exception& e) {
  64                         try {
  65                                 win->message(std::string("Error dumping sample: ") + e.what());
  66                         } catch(...) {
  67                         }
  68                 }
  69 }
  70
  71 void av_snooper::end(window* win) throw()
  72 {
  73         if(!snoopers)
  74                 return;
  75         for(auto i = snoopers->begin(); i != snoopers->end(); i++)
  76                 try {
  77                         (*i)->end();
  78                 } catch(std::bad_alloc& e) {
  79                         OOM_panic(win);
  80                 } catch(std::exception& e) {
  81                         try {
  82                                 win->message(std::string("Error ending dump: ") + e.what());
  83                         } catch(...) {
  84                         }
  85                 }
  86 }
  87
  88 void av_snooper::gameinfo(const std::string& gamename, const std::list<std::pair<std::string, std::string>>&
  89                 authors, double gametime, const std::string& rerecords, window* win) throw(std::bad_alloc)
  90 {
  91         if(!snoopers)
  92                 return;
  93         s_gamename = gamename;
  94         s_authors = authors;
  95         s_gametime = gametime;
  96         s_rerecords = rerecords;
  97         gameinfo_set = true;
  98         for(auto i = snoopers->begin(); i != snoopers->end(); i++)
  99                 (*i)->send_gameinfo();
 100 }
 101
 102 void av_snooper::send_gameinfo() throw()
 103 {
 104         if(gameinfo_set)
 105                 try {
 106                         gameinfo(s_gamename, s_authors, s_gametime, s_rerecords);
 107                 } catch(...) {
 108                 }
 109 }
 110
 111 bool av_snooper::dump_in_progress() throw()
 112 {
 113         return (snoopers && !snoopers->empty());
 114 }
 115
 116 av_snooper::dump_notification::~dump_notification() throw()
 117 {
 118 }
 119
 120 void av_snooper::dump_notification::dump_starting() throw()
 121 {
 122 }
 123
 124 void av_snooper::dump_notification::dump_ending() throw()
 125 {
 126 }
 127
 128 void av_snooper::add_dump_notifier(av_snooper::dump_notification& notifier) throw(std::bad_alloc)
 129 {
 130         notifiers.push_back(&notifier);
 131 }
 132
 133 void av_snooper::remove_dump_notifier(av_snooper::dump_notification& notifier) throw()
 134 {
 135         for(auto i = notifiers.begin(); i != notifiers.end(); i++)
 136                 if(*i == &notifier) {
 137                         notifiers.erase(i);
 138                         return;
 139                 }
 140 }