← Back to branch summary

~ubuntu-branches/debian/squeeze/stella/squeeze

« back to all changes in this revision

Viewing changes to src/emucore/EventStreamer.cxx

  • Committer: Bazaar Package Importer
  • Author(s): Luca Falavigna, Franczen Attila, Luca Falavigna
  • Date: 2008-11-08 12:04:12 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20081108120412-w6xq87vzgokstfey
Tags: 2.6.1-0ubuntu1
https://launchpad.net/bugs/183571
[ Franczen Attila ]
* New upstream release (LP: #183571).
* Updated policy to 3.8.0.

[ Luca Falavigna ]
* debian/patches/gcc-4.3: fix FTBFS with gcc-4.3 compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emucore/EventStreamer.cxx
1
 
//============================================================================
2
 
//
3
 
//   SSSS    tt          lll  lll
4
 
//  SS  SS   tt           ll   ll
5
 
//  SS     tttttt  eeee   ll   ll   aaaa
6
 
//   SSSS    tt   ee  ee  ll   ll      aa
7
 
//      SS   tt   eeeeee  ll   ll   aaaaa  --  "An Atari 2600 VCS Emulator"
8
 
//  SS  SS   tt   ee      ll   ll  aa  aa
9
 
//   SSSS     ttt  eeeee llll llll  aaaaa
10
 
//
11
 
// Copyright (c) 1995-2005 by Bradford W. Mott and the Stella team
12
 
//
13
 
// See the file "license" for information on usage and redistribution of
14
 
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
15
 
//
16
 
// $Id: EventStreamer.cxx,v 1.6 2006/03/05 01:18:42 stephena Exp $
17
 
//============================================================================
18
 
 
19
 
#include "bspf.hxx"
20
 
 
21
 
#include "OSystem.hxx"
22
 
#include "Event.hxx"
23
 
#include "EventHandler.hxx"
24
 
#include "EventStreamer.hxx"
25
 
#include "System.hxx"
26
 
 
27
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
28
 
EventStreamer::EventStreamer(OSystem* osystem)
29
 
  : myOSystem(osystem),
30
 
    myEventWriteFlag(false),
31
 
    myEventReadFlag(false),
32
 
    myFrameCounter(-1),
33
 
    myEventPos(0)
34
 
{
35
 
}
36
 
 
37
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
38
 
EventStreamer::~EventStreamer()
39
 
{
40
 
  stopRecording();
41
 
 
42
 
  myEventHistory.clear();
43
 
  myStreamReader.close();
44
 
  myStreamWriter.close();
45
 
}
46
 
 
47
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
48
 
void EventStreamer::reset()
49
 
{
50
 
//cerr << "EventStreamer::reset()\n";
51
 
  myEventWriteFlag = false;
52
 
  myEventReadFlag = false;
53
 
  myFrameCounter = -1;
54
 
  myEventPos = 0;
55
 
}
56
 
 
57
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
58
 
bool EventStreamer::startRecording()
59
 
{
60
 
  string eventfile = /*myOSystem->baseDir() + BSPF_PATH_SEPARATOR +*/ "test.inp";
61
 
  if(!myStreamWriter.open(eventfile))
62
 
    return false;
63
 
 
64
 
  // And save the current state to it
65
 
  string md5 = myOSystem->console().properties().get(Cartridge_MD5);
66
 
  if(!myOSystem->console().system().saveState(md5, myStreamWriter))
67
 
    return false;
68
 
  myEventHistory.clear();
69
 
 
70
 
  reset();
71
 
  return myEventWriteFlag = true;
72
 
}
73
 
 
74
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
75
 
bool EventStreamer::stopRecording()
76
 
{
77
 
  if(!myStreamWriter.isOpen() || !myEventWriteFlag)
78
 
    return false;
79
 
 
80
 
  // Append the event history to the eventstream
81
 
  int size = myEventHistory.size();
82
 
 
83
 
  try
84
 
  {
85
 
    myStreamWriter.putString("EventStream");
86
 
    myStreamWriter.putInt(size);
87
 
    for(int i = 0; i < size; ++i)
88
 
      myStreamWriter.putInt(myEventHistory[i]);
89
 
  }
90
 
  catch(char *msg)
91
 
  {
92
 
    cerr << msg << endl;
93
 
    return false;
94
 
  }
95
 
  catch(...)
96
 
  {
97
 
    cerr << "Error saving eventstream" << endl;
98
 
    return false;
99
 
  }
100
 
 
101
 
  myStreamWriter.close();
102
 
  return true;
103
 
}
104
 
 
105
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
106
 
bool EventStreamer::loadRecording()
107
 
{
108
 
cerr << "EventStreamer::loadRecording()\n";
109
 
  string eventfile = /*myOSystem->baseDir() + BSPF_PATH_SEPARATOR +*/ "test.inp";
110
 
  if(!myStreamReader.open(eventfile))
111
 
    return false;
112
 
 
113
 
  // Load ROM state
114
 
  string md5 = myOSystem->console().properties().get(Cartridge_MD5);
115
 
  if(!myOSystem->console().system().loadState(md5, myStreamReader))
116
 
    return false;
117
 
 
118
 
  try
119
 
  {
120
 
    if(myStreamReader.getString() != "EventStream")
121
 
      return false;
122
 
 
123
 
    // Now load the event stream
124
 
    myEventHistory.clear();
125
 
    int size = myStreamReader.getInt();
126
 
    for(int i = 0; i < size; ++i)
127
 
      myEventHistory.push_back(myStreamReader.getInt());
128
 
  }
129
 
  catch(char *msg)
130
 
  {
131
 
    cerr << msg << endl;
132
 
    return false;
133
 
  }
134
 
  catch(...)
135
 
  {
136
 
    cerr << "Error loading eventstream" << endl;
137
 
    return false;
138
 
  }
139
 
 
140
 
  reset();
141
 
  myEventReadFlag  = myEventHistory.size() > 0;
142
 
 
143
 
  return true;
144
 
}
145
 
 
146
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
147
 
void EventStreamer::addEvent(int type, int value)
148
 
{
149
 
  if(myEventWriteFlag)
150
 
  {
151
 
    myEventHistory.push_back(type);
152
 
    myEventHistory.push_back(value);
153
 
  }
154
 
}
155
 
 
156
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
157
 
bool EventStreamer::pollEvent(int& type, int& value)
158
 
{
159
 
  if(!myEventReadFlag)
160
 
    return false;
161
 
 
162
 
  bool status = false;
163
 
 
164
 
  // Read a new event from the stream when we've waited the appropriate
165
 
  // number of frames
166
 
  ++myFrameCounter;
167
 
  if(myFrameCounter >= 0)
168
 
  {
169
 
    int first = myEventHistory[myEventPos++];
170
 
    if(first < 0)
171
 
    {
172
 
      myFrameCounter = first;
173
 
      cerr << "wait " << -myFrameCounter << " frames\n";
174
 
    }
175
 
    else if(myEventPos < (int)myEventHistory.size())
176
 
    {
177
 
      type = first;
178
 
      value = myEventHistory[myEventPos++];
179
 
cerr << "type = " << type << ", value = " << value << endl;
180
 
      status = true;
181
 
    }
182
 
  }
183
 
 
184
 
  myEventReadFlag = myEventPos < (int)myEventHistory.size() - 2;
185
 
  return status;
186
 
}
187
 
 
188
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
189
 
void EventStreamer::nextFrame()
190
 
{
191
 
  if(myEventWriteFlag)
192
 
  {
193
 
    int idx = myEventHistory.size() - 1;
194
 
    if(idx >= 0 && myEventHistory[idx] < 0)
195
 
      --myEventHistory[idx];
196
 
    else
197
 
      myEventHistory.push_back(-1);
198
 
  }
199
 
}