1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
|
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2012-2015 - Michael Lelli
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef INTERNAL_CORES_H__
#define INTERNAL_CORES_H__
#include <boolean.h>
#include <libretro.h>
#include <retro_common_api.h>
#include <retro_environment.h>
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
RETRO_BEGIN_DECLS
void libretro_dummy_retro_init(void);
void libretro_dummy_retro_deinit(void);
unsigned libretro_dummy_retro_api_version(void);
void libretro_dummy_retro_get_system_info(struct retro_system_info *info);
void libretro_dummy_retro_get_system_av_info(struct retro_system_av_info *info);
void libretro_dummy_retro_set_environment(retro_environment_t cb);
void libretro_dummy_retro_set_video_refresh(retro_video_refresh_t cb);
void libretro_dummy_retro_set_audio_sample(retro_audio_sample_t cb);
void libretro_dummy_retro_set_audio_sample_batch(retro_audio_sample_batch_t cb);
void libretro_dummy_retro_set_input_poll(retro_input_poll_t cb);
void libretro_dummy_retro_set_input_state(retro_input_state_t cb);
void libretro_dummy_retro_set_controller_port_device(unsigned port, unsigned device);
void libretro_dummy_retro_reset(void);
void libretro_dummy_retro_run(void);
size_t libretro_dummy_retro_serialize_size(void);
bool libretro_dummy_retro_serialize(void *data, size_t size);
bool libretro_dummy_retro_unserialize(const void *data, size_t size);
void libretro_dummy_retro_cheat_reset(void);
void libretro_dummy_retro_cheat_set(unsigned index, bool enabled, const char *code);
bool libretro_dummy_retro_load_game(const struct retro_game_info *game);
bool libretro_dummy_retro_load_game_special(unsigned game_type,
const struct retro_game_info *info, size_t num_info);
void libretro_dummy_retro_unload_game(void);
unsigned libretro_dummy_retro_get_region(void);
void *libretro_dummy_retro_get_memory_data(unsigned id);
size_t libretro_dummy_retro_get_memory_size(unsigned id);
#ifdef HAVE_FFMPEG
/* Internal ffmpeg core. */
void libretro_ffmpeg_retro_init(void);
void libretro_ffmpeg_retro_deinit(void);
unsigned libretro_ffmpeg_retro_api_version(void);
void libretro_ffmpeg_retro_get_system_info(struct retro_system_info *info);
void libretro_ffmpeg_retro_get_system_av_info(struct retro_system_av_info *info);
void libretro_ffmpeg_retro_set_environment(retro_environment_t cb);
void libretro_ffmpeg_retro_set_video_refresh(retro_video_refresh_t cb);
void libretro_ffmpeg_retro_set_audio_sample(retro_audio_sample_t cb);
void libretro_ffmpeg_retro_set_audio_sample_batch(retro_audio_sample_batch_t cb);
void libretro_ffmpeg_retro_set_input_poll(retro_input_poll_t cb);
void libretro_ffmpeg_retro_set_input_state(retro_input_state_t cb);
void libretro_ffmpeg_retro_set_controller_port_device(unsigned port, unsigned device);
void libretro_ffmpeg_retro_reset(void);
void libretro_ffmpeg_retro_run(void);
size_t libretro_ffmpeg_retro_serialize_size(void);
bool libretro_ffmpeg_retro_serialize(void *data, size_t size);
bool libretro_ffmpeg_retro_unserialize(const void *data, size_t size);
void libretro_ffmpeg_retro_cheat_reset(void);
void libretro_ffmpeg_retro_cheat_set(unsigned index, bool enabled, const char *code);
bool libretro_ffmpeg_retro_load_game(const struct retro_game_info *game);
bool libretro_ffmpeg_retro_load_game_special(unsigned game_type,
const struct retro_game_info *info, size_t num_info);
void libretro_ffmpeg_retro_unload_game(void);
unsigned libretro_ffmpeg_retro_get_region(void);
void *libretro_ffmpeg_retro_get_memory_data(unsigned id);
size_t libretro_ffmpeg_retro_get_memory_size(unsigned id);
#endif
#ifdef HAVE_IMAGEVIEWER
/* Internal image viewer core. */
void libretro_imageviewer_retro_init(void);
void libretro_imageviewer_retro_deinit(void);
unsigned libretro_imageviewer_retro_api_version(void);
void libretro_imageviewer_retro_get_system_info(struct retro_system_info *info);
void libretro_imageviewer_retro_get_system_av_info(struct retro_system_av_info *info);
void libretro_imageviewer_retro_set_environment(retro_environment_t cb);
void libretro_imageviewer_retro_set_video_refresh(retro_video_refresh_t cb);
void libretro_imageviewer_retro_set_audio_sample(retro_audio_sample_t cb);
void libretro_imageviewer_retro_set_audio_sample_batch(retro_audio_sample_batch_t cb);
void libretro_imageviewer_retro_set_input_poll(retro_input_poll_t cb);
void libretro_imageviewer_retro_set_input_state(retro_input_state_t cb);
void libretro_imageviewer_retro_set_controller_port_device(unsigned port, unsigned device);
void libretro_imageviewer_retro_reset(void);
void libretro_imageviewer_retro_run(void);
size_t libretro_imageviewer_retro_serialize_size(void);
bool libretro_imageviewer_retro_serialize(void *data, size_t size);
bool libretro_imageviewer_retro_unserialize(const void *data, size_t size);
void libretro_imageviewer_retro_cheat_reset(void);
void libretro_imageviewer_retro_cheat_set(unsigned index, bool enabled, const char *code);
bool libretro_imageviewer_retro_load_game(const struct retro_game_info *game);
bool libretro_imageviewer_retro_load_game_special(unsigned game_type,
const struct retro_game_info *info, size_t num_info);
void libretro_imageviewer_retro_unload_game(void);
unsigned libretro_imageviewer_retro_get_region(void);
void *libretro_imageviewer_retro_get_memory_data(unsigned id);
size_t libretro_imageviewer_retro_get_memory_size(unsigned id);
#endif
#if defined(HAVE_NETWORKGAMEPAD) && defined(HAVE_NETWORKING)
/* Internal networked retropad core. */
void libretro_netretropad_retro_init(void);
void libretro_netretropad_retro_deinit(void);
unsigned libretro_netretropad_retro_api_version(void);
void libretro_netretropad_retro_get_system_info(struct retro_system_info *info);
void libretro_netretropad_retro_get_system_av_info(struct retro_system_av_info *info);
void libretro_netretropad_retro_set_environment(retro_environment_t cb);
void libretro_netretropad_retro_set_video_refresh(retro_video_refresh_t cb);
void libretro_netretropad_retro_set_audio_sample(retro_audio_sample_t cb);
void libretro_netretropad_retro_set_audio_sample_batch(retro_audio_sample_batch_t cb);
void libretro_netretropad_retro_set_input_poll(retro_input_poll_t cb);
void libretro_netretropad_retro_set_input_state(retro_input_state_t cb);
void libretro_netretropad_retro_set_controller_port_device(unsigned port, unsigned device);
void libretro_netretropad_retro_reset(void);
void libretro_netretropad_retro_run(void);
size_t libretro_netretropad_retro_serialize_size(void);
bool libretro_netretropad_retro_serialize(void *data, size_t size);
bool libretro_netretropad_retro_unserialize(const void *data, size_t size);
void libretro_netretropad_retro_cheat_reset(void);
void libretro_netretropad_retro_cheat_set(unsigned index, bool enabled, const char *code);
bool libretro_netretropad_retro_load_game(const struct retro_game_info *game);
bool libretro_netretropad_retro_load_game_special(unsigned game_type,
const struct retro_game_info *info, size_t num_info);
void libretro_netretropad_retro_unload_game(void);
unsigned libretro_netretropad_retro_get_region(void);
void *libretro_netretropad_retro_get_memory_data(unsigned id);
size_t libretro_netretropad_retro_get_memory_size(unsigned id);
#endif
#if defined(HAVE_V4L2)
/* Internal video processor core. */
void libretro_videoprocessor_retro_init(void);
void libretro_videoprocessor_retro_deinit(void);
unsigned libretro_videoprocessor_retro_api_version(void);
void libretro_videoprocessor_retro_get_system_info(struct retro_system_info *info);
void libretro_videoprocessor_retro_get_system_av_info(struct retro_system_av_info *info);
void libretro_videoprocessor_retro_set_environment(retro_environment_t cb);
void libretro_videoprocessor_retro_set_video_refresh(retro_video_refresh_t cb);
void libretro_videoprocessor_retro_set_audio_sample(retro_audio_sample_t cb);
void libretro_videoprocessor_retro_set_audio_sample_batch(retro_audio_sample_batch_t cb);
void libretro_videoprocessor_retro_set_input_poll(retro_input_poll_t cb);
void libretro_videoprocessor_retro_set_input_state(retro_input_state_t cb);
void libretro_videoprocessor_retro_set_controller_port_device(unsigned port, unsigned device);
void libretro_videoprocessor_retro_reset(void);
void libretro_videoprocessor_retro_run(void);
size_t libretro_videoprocessor_retro_serialize_size(void);
bool libretro_videoprocessor_retro_serialize(void *data, size_t size);
bool libretro_videoprocessor_retro_unserialize(const void *data, size_t size);
void libretro_videoprocessor_retro_cheat_reset(void);
void libretro_videoprocessor_retro_cheat_set(unsigned index, bool enabled, const char *code);
bool libretro_videoprocessor_retro_load_game(const struct retro_game_info *game);
bool libretro_videoprocessor_retro_load_game_special(unsigned game_type,
const struct retro_game_info *info, size_t num_info);
void libretro_videoprocessor_retro_unload_game(void);
unsigned libretro_videoprocessor_retro_get_region(void);
void *libretro_videoprocessor_retro_get_memory_data(unsigned id);
size_t libretro_videoprocessor_retro_get_memory_size(unsigned id);
#endif
RETRO_END_DECLS
#endif
|
