{LOGGER] Add domain (node) with log.
delete pf;
return got_str;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Try App: %s Key: %s", lpAppName, lpKeyName);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Try App: %s Key: %s", lpAppName, lpKeyName);
pf->Fseek(0, FILEIO_SEEK_SET);
do {
key_str = key;
delete pf;
got_str.erase(0, pos + key_str.length());
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Got: %s Length: %d", got_str.c_str(), got_str.length());
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Got: %s Length: %d", got_str.c_str(), got_str.length());
return got_str;
}
} else {
i = strtol(s.c_str(), NULL, 10);
}
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Got Int: %d\n", i);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Got Int: %d\n", i);
return i;
}
#endif
#endif
#if defined(_USE_QT) && !defined(Q_OS_WIN)
- AGAR_DebugLog(AGAR_LOG_INFO, "Read Done.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Read config done.");
#endif
}
MyWritePrivateProfileInt(_T("Video"), _T("VideoFramerate"), config.video_frame_rate, config_path);
#endif
#if defined(_USE_QT) && !defined(Q_OS_WIN)
- AGAR_DebugLog(AGAR_LOG_INFO, "Write done.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Write config done.");
#endif
my_tcscpy_s(prev_buffer, 1024, buffer);
#if defined(_USE_QT) || defined(_USE_AGAR) || defined(_USE_SDL)
- AGAR_DebugLog(AGAR_LOG_DEBUG, "%s", buffer);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_EMU, "%s", buffer);
#else
if(debug_log) {
_ftprintf(debug_log, _T("%s"), buffer);
my_tcscpy_s(prev_buffer, 1024, buffer);
#if defined(_USE_QT) || defined(_USE_AGAR) || defined(_USE_SDL)
- AGAR_DebugLog(AGAR_LOG_DEBUG, "%s", buffer);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_EMU, "%s", buffer);
#else
if(debug_log) {
_ftprintf(debug_log, _T("%s"), buffer);
void EMU::out_message(const _TCHAR* format, ...)
{
+//#if defined(_USE_QT)
+// _TCHAR mes_buf[1024];
+//#endif
va_list ap;
va_start(ap, format);
my_vstprintf_s(message, 1024, format, ap); // Security for MSVC:C6386.
+//#if defined(_USE_QT)
+// memset(mes_buf, 0x00, sizeof(mes_buf));
+// my_vstprintf_s(mes_buf, 1024, format, ap); // Security for MSVC:C6386.
+// csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_EMU, "%s", mes_buf);
+//#endif
va_end(ap);
message_count = 4; // 4sec
}
)
set_target_properties(CSPosd PROPERTIES
- SOVERSION 2.2.0
- VERSION 2.2.0
+ SOVERSION 2.3.0
+ VERSION 2.3.0
)
INSTALL(TARGETS CSPosd DESTINATION ${LIBCSP_INSTALL_DIR})
endif()
)
set_target_properties(CSPavio PROPERTIES
- SOVERSION 2.3.1
- VERSION 2.3.1
+ SOVERSION 2.4.0
+ VERSION 2.4.0
)
INSTALL(TARGETS CSPavio DESTINATION ${LIBCSP_INSTALL_DIR})
endif()
-
#include "../osd.h"
#include "movie_loader.h"
#include "agar_logger.h"
if (ret < 0) {
char str_buf[AV_ERROR_MAX_STRING_SIZE] = {0};
av_make_error_string(str_buf, AV_ERROR_MAX_STRING_SIZE, ret);
- AGAR_DebugLog(AGAR_LOG_INFO, "Error decoding video frame (%s)\n", str_buf);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error decoding video frame (%s)\n", str_buf);
return ret;
}
if (*got_frame) {
frame->format != pix_fmt) {
/* To handle this change, one could call av_image_alloc again and
* decode the following frames into another rawvideo file. */
- AGAR_DebugLog(AGAR_LOG_INFO, "Error: Width, height and pixel format have to be "
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error: Width, height and pixel format have to be "
"constant in a rawvideo file, but the width, height or "
"pixel format of the input video changed:\n"
"old: width = %d, height = %d, format = %s\n"
dst_width, dst_height, AV_PIX_FMT_BGRA, 1);
if(ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "MOVIE_LOADER: Could not re-allocate output buffer\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "MOVIE_LOADER: Could not re-allocate output buffer\n");
old_dst_width = dst_width;
old_dst_height = dst_height;
video_mutex->unlock();
video_frame_count++;
//av_ts_make_time_string(str_buf2, frame->pts, &video_dec_ctx->time_base);
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "video_frame%s n:%d coded_n:%d pts:%s\n",
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_LOADER, "video_frame%s n:%d coded_n:%d pts:%s\n",
// cached ? "(cached)" : "",
// video_frame_count++, frame->coded_picture_number,
// str_buf2);
AV_PIX_FMT_BGRA,
SCALE_FLAGS, NULL, NULL, NULL);
if (sws_context == NULL) {
- AGAR_DebugLog(AGAR_LOG_INFO,
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER,
"MOVIE_LOADER: Could not initialize the conversion context\n");
return -1;
}
if (ret < 0) {
char str_buf[AV_ERROR_MAX_STRING_SIZE] = {0};
av_make_error_string(str_buf, AV_ERROR_MAX_STRING_SIZE, ret);
- AGAR_DebugLog(AGAR_LOG_INFO, "Error decoding audio frame (%s)\n", str_buf);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error decoding audio frame (%s)\n", str_buf);
return ret;
}
/* Some audio decoders decode only part of the packet, and have to be
int dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_context, c->sample_rate) + frame->nb_samples,
c->sample_rate, c->sample_rate, AV_ROUND_UP);
//av_ts_make_time_string(str_buf, frame->pts, &audio_dec_ctx->time_base);
- //AGAR_DebugLog(AGAR_LOG_DEBUG,"audio_frame%s n:%d nb_samples:%d pts:%s\n",
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_LOADER,"audio_frame%s n:%d nb_samples:%d pts:%s\n",
// cached ? "(cached)" : "",
// audio_frame_count++, frame->nb_samples,
// str_buf);
px->data[1] = px->data[2] = px->data[3] = NULL;
if(px->data[0] == NULL) {
free(px);
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while converting\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error while converting\n");
return -1;
}
ret = swr_convert(swr_context,
if (ret < 0) {
free(px->data[0]);
free(px);
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while converting\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error while converting\n");
return -1;
}
px->unpadded_linesize = (long)dst_nb_samples * 2 * sizeof(int16_t);
sound_data_queue.enqueue(px);
snd_write_lock->unlock();
} else {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while converting\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Error while converting\n");
return -1;
}
}
ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not find %s stream in input file '%s'\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not find %s stream in input file '%s'\n",
av_get_media_type_string(type), _filename.toLocal8Bit().constData());
return ret;
} else {
dec_ctx = st->codec;
dec = avcodec_find_decoder(dec_ctx->codec_id);
if (!dec) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Failed to find %s codec\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Failed to find %s codec\n",
av_get_media_type_string(type));
return AVERROR(EINVAL);
}
/* Init the decoders, with or without reference counting */
av_dict_set(&opts, "refcounted_frames", refcount ? "1" : "0", 0);
if ((ret = avcodec_open2(dec_ctx, dec, &opts)) < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Failed to open %s codec\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Failed to open %s codec\n",
av_get_media_type_string(type));
return ret;
}
}
}
- AGAR_DebugLog(AGAR_LOG_INFO,
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER,
"sample format %s is not supported as output format\n",
av_get_sample_fmt_name(sample_fmt));
return -1;
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, _filename.toLocal8Bit().constData(), NULL, NULL) < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not open source file %s\n", _filename.toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not open source file %s\n", _filename.toLocal8Bit().constData());
return -1;
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not find stream information\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not find stream information\n");
exit(1);
}
rate = av_stream_get_r_frame_rate(video_stream);
frame_rate = av_q2d(rate);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate raw video buffer\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not allocate raw video buffer\n");
goto _end;
}
video_dst_bufsize = ret;
}
swr_context = swr_alloc();
if(swr_context == NULL) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate resampler context\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not allocate resampler context\n");
goto _end;
}
av_opt_set_int (swr_context, "in_channel_count", audio_stream->codec->channels, 0);
/* initialize the resampling context */
if ((ret = swr_init(swr_context)) < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Failed to initialize the resampling context\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Failed to initialize the resampling context\n");
goto _end;
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, _filename.toLocal8Bit().constData(), 0);
- AGAR_DebugLog(AGAR_LOG_INFO, "Video is %f fps", frame_rate);
- AGAR_DebugLog(AGAR_LOG_INFO, "Audio is %d Hz ", sound_rate);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Video is %f fps", frame_rate);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Audio is %d Hz ", sound_rate);
if (!audio_stream && !video_stream) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not find audio or video stream in the input, aborting\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not find audio or video stream in the input, aborting\n");
ret = 1;
goto _end;
}
frame = av_frame_alloc();
if (!frame) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate frame\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto _end;
}
old_dst_height = dst_height;
video_mutex->unlock();
if(ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "MOVIE_LOADER: Could not re-allocate output buffer\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "MOVIE_LOADER: Could not re-allocate output buffer\n");
//video_mutex->unlock();
goto _end;
}
// ToDo : Initialize SWScaler and SWresampler.
- AGAR_DebugLog(AGAR_LOG_INFO, "MOVIE_LOADER: Loading movie completed.\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "MOVIE_LOADER: Loading movie completed.\n");
return true;
_end:
this->close();
now_playing = false;
now_pausing = false;
- AGAR_DebugLog(AGAR_LOG_INFO, "MOVIE_LOADER: Close movie.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_LOADER, "MOVIE_LOADER: Close movie.");
}
double MOVIE_LOADER::get_movie_frame_rate(void)
while(v_f || a_f) {
v_f = (av_rescale_rnd(video_frame_count, 1000000000, (int64_t)(frame_rate * 1000.0), AV_ROUND_UP) < duration_us);
a_f = (av_rescale_rnd(audio_total_samples, 1000000, audio_stream->codec->sample_rate, AV_ROUND_UP) < duration_us);
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "%lld usec. V=%lld A=%lld, %d - %d\n", duration_us, video_frame_count, audio_total_samples, v_f, a_f);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_LOADER, "%lld usec. V=%lld A=%lld, %d - %d\n", duration_us, video_frame_count, audio_total_samples, v_f, a_f);
if(!a_f && !v_f) break;
av_read_frame(fmt_ctx, &pkt);
decode_packet(&got_frame, 0);
}
#endif
-
// Copy from FFMPEG-3.0.2; doc/example/muxing.c .
#define STREAM_PIX_FMT AV_PIX_FMT_RGBA /* default pix_fmt */
const AVPacket *pkt = (const AVPacket *)_pkt;
AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;
- AGAR_DebugLog(AGAR_LOG_DEBUG, "pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
ts2str(pkt->pts).toLocal8Bit().constData(),
ts2timestr(pkt->pts, (void *)time_base).toLocal8Bit().constData(),
ts2str(pkt->dts).toLocal8Bit().constData(),
if(req_stop) return;
uint32_t *pq;
VIDEO_DATA *px = new VIDEO_DATA(frames, width, height, p);
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Movie: Enqueue video data %dx%d %d bytes %dx%d %d frames", width, height, p->byteCount(), p->width(), p->height(), frames);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Movie: Enqueue video data %dx%d %d bytes %dx%d %d frames", width, height, p->byteCount(), p->width(), p->height(), frames);
//video_queue_mutex->lock();
video_data_queue.enqueue(px);
//video_queue_mutex->unlock();
memcpy(&(p[_width * y]), pq, ((_width * sizeof(uint32_t)) > pp_i->bytesPerLine()) ? pp_i->bytesPerLine() : _width * sizeof(uint32_t));
}
video_size = _width * y;
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Movie: Dequeue video data %d bytes", pp->byteCount());
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Movie: Dequeue video data %d bytes", pp->byteCount());
}
#else
video_size = 0;
if(p == NULL) return;
if(req_stop) return;
QByteArray *pp = new QByteArray((const char *)p, size);
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Movie: Enqueue audio data %d bytes", size);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Movie: Enqueue audio data %d bytes", size);
audio_data_queue.enqueue(pp);
// audio_enqueue_count++;
#endif
}
//memcpy(p, pp->constData(), audio_size);
audio_count++;
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Movie: Dequeue audio data %d bytes", pp->size());
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Movie: Dequeue audio data %d bytes", pp->size());
#else
audio_size = 0;
#endif
void MOVIE_SAVER::run()
{
bRunThread = true;
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE THREAD: Start");
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "MOVIE THREAD: Start");
int ret;
int fps_wait = (int)((1000.0 / (double)rec_fps) / 4.0);
int tmp_wait = fps_wait;
recording = false;
goto _next_turn;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE/Saver: Start to recording.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "MOVIE/Saver: Start to recording.");
old_recording = true;
a_f = v_f = false;
}
audio_st.next_pts, audio_st.st->codec->time_base) <= 0)) {
n_encode_video = write_video_frame();
if(n_encode_video < 0) {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE/Saver: Something wrong with encoding video.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "MOVIE/Saver: Something wrong with encoding video.");
goto _final;
}
} else {
n_encode_audio = write_audio_frame();
if(n_encode_audio < 0) {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE/Saver: Something wrong with encoding audio.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "MOVIE/Saver: Something wrong with encoding audio.");
goto _final;
}
}
if (ret < 0 && ret != AVERROR_EOF) {
char errbuf[128];
av_strerror(ret, errbuf, sizeof(errbuf));
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while filtering: %s\n", (const char *)errbuf);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error while filtering: %s\n", (const char *)errbuf);
goto _final;
}
do_close_main();
old_recording = false;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Exit thread.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "MOVIE: Exit thread.");
if(recording) {
req_close = true;
do_close_main();
int ret;
enum AVSampleFormat sample_fmt = (enum AVSampleFormat)_sample_fmt;
if (!frame) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error allocating an audio frame\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error allocating an audio frame\n");
exit(1);
}
if (nb_samples) {
ret = av_frame_get_buffer(frame, 0);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error allocating an audio buffer\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error allocating an audio buffer\n");
return NULL;
}
}
ret = avcodec_open2(c, codec, &opt);
av_dict_free(&opt);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not open audio codec: %s\n", err2str(ret).toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not open audio codec: %s\n", err2str(ret).toLocal8Bit().constData());
return false;
}
/* set options */
ost->swr_ctx = swr_alloc();
if (!ost->swr_ctx) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate resampler context\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not allocate resampler context\n");
return false;
}
av_opt_set_int (ost->swr_ctx, "in_channel_count", c->channels, 0);
AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16, audio_sample_rate,
0, NULL);
if (ost->swr_ctx == NULL) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Failed to initialize the resampling context\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Failed to initialize the resampling context\n");
return false;
}
#endif
/* initialize the resampling context */
if ((ret = swr_init(ost->swr_ctx)) < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Failed to initialize the resampling context\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Failed to initialize the resampling context\n");
return false;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Open to write audio : Success.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Open to write audio : Success.");
return true;
#else
return true;
*/
ret = av_frame_make_writable(ost->frame);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE/Saver: Audio: Fail to make writable frame.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER, "Audio: Fail to make writable frame.");
return -1;
}
/* convert to destination format */
ost->frame->data, dst_nb_samples,
(const uint8_t **)frame_src->data, frame_src->nb_samples);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while converting\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error while converting\n");
return -1;
}
ret = avcodec_encode_audio2(c, &pkt, frame_dst, &got_packet);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error encoding audio frame: %s\n", err2str(ret).toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error encoding audio frame: %s\n", err2str(ret).toLocal8Bit().constData());
return -1;
}
if (got_packet) {
ret = this->write_frame((void *)oc, (const void *)&c->time_base, (void *)ost->st, (void *)&pkt);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while writing audio frame: %s\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error while writing audio frame: %s\n",
err2str(ret).toLocal8Bit().constData());
return -1;
}
/* find the encoder */
*codec = avcodec_find_encoder(codec_id);
if (!(*codec)) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not find encoder for '%s'\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not find encoder for '%s'\n",
(const char *)avcodec_get_name(codec_id));
return false;
}
ost->st = avformat_new_stream(oc, *codec);
if (!ost->st) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate stream\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not allocate stream\n");
return false;
}
ost->st->id = oc->nb_streams-1;
if (!(fmt->flags & AVFMT_NOFILE)) {
ret = avio_open(&oc->pb, _filename.toLocal8Bit().constData(), AVIO_FLAG_WRITE);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not open '%s': %s\n", _filename.toLocal8Bit().constData(),
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER,
+ "Could not open '%s': %s\n", _filename.toLocal8Bit().constData(),
err2str(ret).toLocal8Bit().constData());
goto _err_final;
} else {
- AGAR_DebugLog(AGAR_LOG_INFO, "Success to Open file: '%s\n", _filename.toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER,
+ "Success to Open file: '%s\n", _filename.toLocal8Bit().constData());
}
}
totalSrcFrame = 0;
/* Write the stream header, if any. */
ret = avformat_write_header(oc, &raw_options_list);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error occurred when opening output file: %s\n",
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER,
+ "Error occurred when opening output file: %s\n",
err2str(ret).toLocal8Bit().constData());
goto _err_final;
}
}
video_data_queue.clear();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Close: Left: Video %lld frames, Audio %lld frames",
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER,
+ "Close: Left: Video %lld frames, Audio %lld frames",
leftq_v,
leftq_a
);
// Message
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Close: Write: Video %lld frames, Audio %lld frames", totalDstFrame, totalAudioFrame);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Close: Dequeue: Video %lld frames, Audio %lld frames", totalDstFrame, audio_count);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER,
+ "MOVIE: Close: Write: Video %lld frames, Audio %lld frames", totalDstFrame, totalAudioFrame);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER,
+ "MOVIE: Close: Dequeue: Video %lld frames, Audio %lld frames", totalDstFrame, audio_count);
totalSrcFrame = 0;
totalDstFrame = 0;
totalAudioFrame = 0;
/* allocate the buffers for the frame data */
ret = av_frame_get_buffer(picture, 32);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate frame data.\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not allocate frame data.\n");
return (void *)NULL;
}
ret = avcodec_open2(c, codec, &opt);
av_dict_free(&opt);
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not open video codec: %s\n", err2str(ret).toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not open video codec: %s\n", err2str(ret).toLocal8Bit().constData());
return false;
}
/* allocate and init a re-usable frame */
ost->frame = (AVFrame *)alloc_picture(c->pix_fmt, c->width, c->height);
if (!ost->frame) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not allocate video frame\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not allocate video frame\n");
return false;
}
}
//}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MOVIE: Open to write video : Success.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_MOVIE_SAVER,
+ "MOVIE: Open to write video : Success.");
return true;
#else
return false;
av_frame_free(&ost->tmp_frame);
ost->tmp_frame = (AVFrame *)alloc_picture(AV_PIX_FMT_BGRA, _width, _height);
if (ost->tmp_frame == NULL) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Could not re-allocate video frame\n");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Could not re-allocate video frame\n");
return (void *)NULL;
}
}
c->pix_fmt,
SCALE_FLAGS, NULL, NULL, NULL);
if (!ost->sws_ctx) {
- AGAR_DebugLog(AGAR_LOG_INFO,
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER,
"Could not initialize the conversion context\n");
return (void *)NULL;
}
ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
//if(!got_packet) break;
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error encoding video frame: %s\n", err2str(ret).toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error encoding video frame: %s\n", err2str(ret).toLocal8Bit().constData());
return -1;
}
totalDstFrame++;
}
if (ret < 0) {
- AGAR_DebugLog(AGAR_LOG_INFO, "Error while writing video frame: %s\n", err2str(ret).toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_MOVIE_SAVER, "Error while writing video frame: %s\n", err2str(ret).toLocal8Bit().constData());
return -1;
}
//}
void EmuThreadClass::do_stop_auto_key(void)
{
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "AutoKey: stop\n");
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL,
+ // "AutoKey: stop\n");
#if defined(USE_AUTO_KEY)
p_emu->stop_auto_key();
#endif
} while(1);
_exit:
//emit quit_draw_thread();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "EmuThread : EXIT");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL,
+ "EmuThread : EXIT");
emit sig_finished();
this->quit();
}
connect(this, SIGNAL(sig_stop_auto_key()), hRunEmu, SLOT(do_stop_auto_key()));
#endif
//connect(actionExit_Emulator, SIGNAL(triggered()), hRunEmu, SLOT(doExit()));
- AGAR_DebugLog(AGAR_LOG_DEBUG, "EmuThread : Start.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "EmuThread : Start.");
objNameStr = QString("EmuThreadClass");
hRunEmu->setObjectName(objNameStr);
delete reader;
emu->get_osd()->set_buttons();
#endif
- AGAR_DebugLog(AGAR_LOG_DEBUG, "DrawThread : Start.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "DrawThread : Start.");
connect(hDrawEmu, SIGNAL(sig_draw_frames(int)), hRunEmu, SLOT(print_framerate(int)));
connect(hRunEmu, SIGNAL(window_title_changed(QString)), this, SLOT(do_set_window_title(QString)));
connect(hDrawEmu, SIGNAL(message_changed(QString)), this, SLOT(message_status_bar(QString)));
objNameStr = QString("EmuDrawThread");
hDrawEmu->setObjectName(objNameStr);
hDrawEmu->start();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "DrawThread : Launch done.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "DrawThread : Launch done.");
hSaveMovieThread = new MOVIE_SAVER(640, 400, 30, emu->get_osd(), using_flags->get_config_ptr());
objNameStr = QString("EmuMovieThread");
hSaveMovieThread->setObjectName(objNameStr);
hSaveMovieThread->start();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "MovieThread : Launch done.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "MovieThread : Launch done.");
connect(action_SetupMovie, SIGNAL(triggered()), this, SLOT(rise_movie_dialog()));
hRunEmu->start();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "EmuThread : Launch done.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "EmuThread : Launch done.");
this->set_screen_aspect(using_flags->get_config_ptr()->window_stretch_type);
emit sig_movie_set_width(SCREEN_WIDTH);
emit sig_movie_set_height(SCREEN_HEIGHT);
#endif
bLogSYSLOG = (int)0;
bLogSTDOUT = (int)1;
- AGAR_OpenLog(bLogSYSLOG, bLogSTDOUT, DEVICE_NAME); // Write to syslog, console
+ //csp_logger = new CSP_Logger((bLogSYSLOG != 0), (bLogSTDOUT != 0), DEVICE_NAME); // Write to syslog, console
archstr = "Generic";
#if defined(__x86_64__)
#if defined(__i386__)
archstr = "ia32";
#endif
- AGAR_DebugLog(AGAR_LOG_INFO, "Start Common Source Project '%s'", my_procname.c_str());
- AGAR_DebugLog(AGAR_LOG_INFO, "(C) Toshiya Takeda / Qt Version K.Ohta");
- AGAR_DebugLog(AGAR_LOG_INFO, "Architecture: %s", archstr.c_str());
- //AGAR_DebugLog(AGAR_LOG_INFO, " -? is print help(s).");
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Moduledir = %s home = %s", cpp_confdir.c_str(), cpp_homedir.c_str()); // Debug
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Start Common Source Project '%s'", my_procname.c_str());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "(C) Toshiya Takeda / Qt Version K.Ohta");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Architecture: %s", archstr.c_str());
+
+ //csp_logger->debug_log(AGAR_LOG_INFO, " -? is print help(s).");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Moduledir = %s home = %s", cpp_confdir.c_str(), cpp_homedir.c_str()); // Debug
#if !defined(Q_OS_CYGWIN)
{
QDir dir;
setup_logs();
cpp_homedir.copy(homedir, PATH_MAX - 1, 0);
flag = FALSE;
+ csp_logger->set_emu_vm_name(DEVICE_NAME); // Write to syslog, console
/*
* Into Qt's Loop.
*/
SDL_Init(SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_VIDEO);
//SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO);
#endif
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Audio and JOYSTICK subsystem was initialised.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Audio and JOYSTICK subsystem was initialised.");
GuiMain = new QApplication(argc, argv);
load_config(create_local_path(_T("%s.ini"), _T(CONFIG_NAME)));
rMainWindow->connect(rMainWindow, SIGNAL(sig_quit_all(void)), rMainWindow, SLOT(deleteLater(void)));
rMainWindow->setCoreApplication(GuiMain);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "InitInstance() OK.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "InitInstance() OK.");
// disable ime
)
set_target_properties(CSPemu_utils PROPERTIES
- SOVERSION 2.0.0
- VERSION 2.0.0
+ SOVERSION 2.1.0
+ VERSION 2.1.0
)
INSTALL(TARGETS CSPemu_utils DESTINATION ${LIBCSP_INSTALL_DIR})
endif()
message("* qt/gui")
set(s_qt_gui_headers
+ agar_logger.h
+
qt_dialogs.h
qt_gldraw.h
qt_glutil_gl2_0.h
)
set_target_properties(CSPgui PROPERTIES
- SOVERSION 2.0.3
- VERSION 2.0.3
+ SOVERSION 2.1.0
+ VERSION 2.1.0
)
INSTALL(TARGETS CSPgui DESTINATION ${LIBCSP_INSTALL_DIR})
endif()
* Licence : GPLv2
*/
+#include <QMutex>
+#include <QMutexLocker>
+
#include "agar_logger.h"
#include <string.h>
#include "emu.h"
#include "vm/vm.h"
#include "menu_flags.h"
-static int syslog_flag = 0;
-static int log_cons = 0;
-static int log_onoff = 0;
-static int log_opened = FALSE;
-static char log_sysname[256];
-//extern class USING_FLAGS *using_flags;
-extern "C"
+CSP_Logger::CSP_Logger(bool b_syslog, bool cons, const char *devname)
{
-
-void AGAR_OpenLog(int syslog, int cons, const char *devname)
+ lock_mutex = new QMutex(QMutex::Recursive);
+ QString tmps;
+ const char *p;
+
+ component_names.clear();
+ vfile_names.clear();
+ cpu_names.clear();
+ device_names.clear();
+
+ const char *components[] = {
+ "GENERAL",
+ "OSD",
+ "EMU",
+ "VM",
+ "GUI",
+ "SOUND",
+ "VIDEO",
+ "KEYBOARD",
+ "MOUSE",
+ "JOYSTICK",
+ "MOVIE_LOADER",
+ "MOVIE_SAVER",
+ "SCREEN",
+ "PRINTER",
+ "SOCKET",
+ "Undefined",
+ NULL
+ };
+ for(int i = 0; ; i++) {
+ p = components[i];
+ if(p == NULL) break;
+ tmps = QString::fromUtf8(p);
+ component_names.append(tmps);
+ }
+ const char *vfiles[] = {
+ "BINARY",
+ "BUBBLE",
+ "CART",
+ "CMT",
+ "CD",
+ "FD",
+ "LD",
+ "QD",
+ NULL
+ };
+ for(int i = 0; ; i++) {
+ QString ss;
+ int lim;
+ p = vfiles[i];
+ if(p == NULL) break;
+ tmps = QString::fromUtf8(p);
+ if(i == 5) { // FD
+ lim = 16;
+ } else if(i == 7) { // QD
+ lim = 16;
+ } else {
+ lim = 8;
+ }
+ for(int j = 0; j < lim; j++) {
+ ss.setNum(j + 1);
+ vfile_names.append(tmps + ss);
+ }
+ }
+
+ tmps = QString::fromUtf8("CPU"); // Enable to update
+ for(int i = 0; i < 8; i++) {
+ QString ss;
+ ss.setNum(i);
+ cpu_names.append(tmps + ss);
+ }
+ tmps = QString::fromUtf8("DEV"); // Enable to update
+ for(int i = 0; i < (256 - (32 + 8)); i++) {
+ QString ss;
+ ss.setNum(i);
+ device_names.append(tmps + ss);
+ }
+
+
+ this->open(b_syslog, cons, devname);
+}
+
+CSP_Logger::~CSP_Logger()
+{
+ loglist.clear();
+ log_sysname.clear();
+ squeue.clear();
+ delete lock_mutex;
+}
+
+//extern class USING_FLAGS *using_flags;
+void CSP_Logger::open(bool b_syslog, bool cons, const char *devname)
{
int flags = 0;
- log_onoff = 1;
- memset(log_sysname, 0x00, sizeof(log_sysname));
- strncpy(log_sysname, "Common Source Project(", sizeof(log_sysname));
+ log_onoff = true;
+
+ loglist.clear();
+ log_sysname.clear();
+ squeue.clear();
+
+ QString dname;
if(devname != NULL) {
- strncat(log_sysname, devname, sizeof(log_sysname));
+ dname = QString::fromUtf8(devname);
+ } else {
+ dname = QString::fromUtf8("*Undefined*");
}
- strncat(log_sysname, ")", sizeof(log_sysname));
+ log_sysname = QString::fromUtf8("Common Source Code Project(");
+ log_sysname = log_sysname + dname + QString::fromUtf8(")");
- if(syslog != 0) {
- syslog_flag = -1;
+ if(b_syslog) {
+ syslog_flag = true;
#if defined(_SYS_SYSLOG_H) || defined(_SYSLOG_H)
- if(cons != 0) {
+ if(cons) {
flags = LOG_CONS;
}
- openlog(log_sysname, flags | LOG_PID | LOG_NOWAIT, LOG_USER);
+ openlog(log_sysname.toLocal8Bit().constData(), flags | LOG_PID | LOG_NOWAIT, LOG_USER);
#endif
} else {
- syslog_flag = 0;
+ syslog_flag = false;
}
log_cons = cons;
- log_opened = TRUE;
+ log_opened = true;
+ log_cons_out = log_cons;
+ syslog_flag_out = syslog_flag;
+
+ cons_log_levels = 1 << CSP_LOG_INFO;
+ linenum = 1;
+ line_wrap = 0;
+
+ this->debug_log(CSP_LOG_INFO, "Start logging.");
}
-
-void AGAR_DebugLog(int level, const char *fmt, ...)
+
+void CSP_Logger::debug_log(int level, const char *fmt, ...)
+{
+ char strbuf[4096];
+ va_list ap;
+
+ va_start(ap, fmt);
+ vsnprintf(strbuf, 4095, fmt, ap);
+ debug_log(level, 0, strbuf);
+ va_end(ap);
+}
+
+
+void CSP_Logger::debug_log(int level, int domain_num, const char *fmt, ...)
{
+ char strbuf[4096];
va_list ap;
+
+ va_start(ap, fmt);
+ vsnprintf(strbuf, 4095, fmt, ap);
+ debug_log(level, domain_num, strbuf);
+ va_end(ap);
+}
+
+void CSP_Logger::debug_log(int level, int domain_num, char *strbuf)
+{
struct tm *timedat;
time_t nowtime;
- char strbuf[4096];
char strbuf2[256];
char strbuf3[24];
struct timeval tv;
+
+ if(!log_opened) return;
+ if(level < 0) level = 0;
+ if(level >= CSP_LOG_LEVELS) level = CSP_LOG_LEVELS - 1;
+
#if !defined(Q_OS_WIN)
int level_flag = LOG_USER;
-
- if(log_onoff == 0) return;
-
- if(level == AGAR_LOG_DEBUG) {
+ if(level == CSP_LOG_DEBUG) {
level_flag |= LOG_DEBUG;
- } else if(level == AGAR_LOG_INFO) {
+ } else if(level == CSP_LOG_INFO) {
level_flag |= LOG_INFO;
- } else if(level == AGAR_LOG_WARN) {
+ } else if(level == CSP_LOG_WARN) {
level_flag |= LOG_WARNING;
} else {
level_flag |= LOG_DEBUG;
char *p;
char *p_bak;
const char delim[2] = "\n";
- va_start(ap, fmt);
- vsnprintf(strbuf, 4095, fmt, ap);
#ifdef __MINGW32__
p = strtok(strbuf, delim);
#else
p = strtok_r(strbuf, delim, &p_bak);
#endif
if(strbuf != NULL) {
-
nowtime = time(NULL);
gettimeofday(&tv, NULL);
if(log_cons != 0) { // Print only
strftime(strbuf2, 255, "%Y-%m-%d %H:%M:%S", timedat);
snprintf(strbuf3, 23, ".%06ld", tv.tv_usec);
}
+ QString time_s = QString::fromUtf8(strbuf2) + QString::fromUtf8(strbuf3);
+ QMutexLocker locker(lock_mutex);
+
+ int cons_log_level_n = (1 << level) & cons_log_levels;
+ int sys_log_level_n = (1 << level) & sys_log_levels;
+ QString domain_s;
+ domain_s.clear();
+
+ if((domain_num > 0) && (domain_num < CSP_LOG_TYPE_COMPONENT_END)) {
+ domain_s = component_names.at(domain_num - 1);
+ } else if((domain_num >= CSP_LOG_TYPE_VM_CPU0) && (domain_num < CSP_LOG_TYPE_VM_DEVICE_0)) {
+ domain_s = cpu_names.at(domain_num - CSP_LOG_TYPE_VM_CPU0);
+ } else if((domain_num >= CSP_LOG_TYPE_VM_DEVICE_0) && (domain_num <= CSP_LOG_TYPE_VM_DEVICE_END)) {
+ domain_s = device_names.at(domain_num - CSP_LOG_TYPE_VM_DEVICE_0);
+ } else if((domain_num >= CSP_LOG_TYPE_VFILE_HEAD) && (domain_num < CSP_LOG_TYPE_VFILE_END)) {
+ domain_s = vfile_names.at(domain_num - CSP_LOG_TYPE_VFILE_HEAD);
+ }
+ if(!domain_s.isEmpty()) {
+ domain_s = QString::fromUtf8("[") + domain_s + QString::fromUtf8("]");
+ }
+ if(!log_cons || !log_cons_out) cons_log_level_n = 0;
+ if(!syslog_flag || !syslog_flag_out) sys_log_level_n = 0;
+
do {
if(p != NULL) {
- if(log_cons != 0) fprintf(stdout, "%s : %s%s %s\n", log_sysname, strbuf2, strbuf3, p);
+ CSP_LoggerLine *tmps;
+ if(linenum == LLONG_MAX) line_wrap++;
+ tmps = new CSP_LoggerLine(linenum++, level, domain_s, time_s, QString::fromUtf8(p));
+ squeue.enqueue(tmps);
+ if(log_onoff) {
+ if(cons_log_level_n != 0) {
+ fprintf(stdout, "%s : %s\n",
+ log_sysname.toLocal8Bit().constData(),
+ tmps->get_element_console().toLocal8Bit().constData());
+ }
#if !defined(Q_OS_WIN)
- if(syslog_flag != 0) syslog(level_flag, "uS=%06ld %s", tv.tv_usec, p);
+ if(sys_log_level_n != 0) {
+ syslog(level_flag, "uS=%06ld %s",
+ tv.tv_usec,
+ tmps->get_element_syslog().toLocal8Bit().constData());
+ }
#endif
+ }
#ifdef __MINGW32__
p = strtok(NULL, delim);
#else
#endif
} while(p != NULL);
}
- va_end(ap);
}
-void AGAR_SetLogStatus(int sw)
+void CSP_Logger::set_log_status(bool sw)
{
- if(sw == 0) {
- log_onoff = 0;
- } else {
- log_onoff = 1;
- }
+ log_onoff = sw;
}
-void AGAR_SetLogStdOut(int sw)
+void CSP_Logger::set_log_stdout(int level, bool sw)
{
- if(sw == 0) {
- log_cons = 0;
+ if((level < 0) || (level >= 32)) {
+ log_cons_out = sw;
+ return;
+ }
+ int lv = 1 << level;
+ if(sw) {
+ cons_log_levels |= lv;
} else {
- log_cons = 1;
+ cons_log_levels &= ~lv;
}
}
-void AGAR_SetLogSysLog(int sw)
+void CSP_Logger::set_log_syslog(int level, bool sw)
{
- if(sw == 0) {
- syslog_flag = 0;
+ if((level < 0) || (level >= 32)) {
+ syslog_flag_out = sw;
+ return;
+ }
+ int lv = 1 << level;
+ if(sw) {
+ sys_log_levels |= lv;
} else {
- syslog_flag = 1;
+ sys_log_levels &= ~lv;
}
}
-bool AGAR_LogGetStatus(void)
+bool CSP_Logger::get_status(void)
{
- return (bool) log_opened;
+ return log_opened;
}
-void AGAR_CloseLog(void)
+void CSP_Logger::close(void)
{
+ QMutexLocker locker(lock_mutex);
+
+ log_opened = false;
#if !defined(Q_OS_WIN32)
if(syslog_flag != 0) {
closelog();
}
#endif
- syslog_flag = 0;
- log_cons = 0;
- log_onoff = 0;
- log_opened = 0;
- }
+ syslog_flag = false;
+ syslog_flag_out = false;
+
+ log_cons = false;
+ log_cons_out = false;
+
+ log_onoff = false;
+
+ while(!squeue.isEmpty()) {
+ CSP_LoggerLine *p = squeue.dequeue();
+ if(p != NULL) delete p;
+ }
+ loglist.clear();
+ log_sysname.clear();
+ squeue.clear();
}
+void CSP_Logger::set_emu_vm_name(const char *devname)
+{
+ QString dname;
+ if(devname != NULL) {
+ dname = QString::fromUtf8(devname);
+ } else {
+ dname = QString::fromUtf8("*Undefined*");
+ }
+ log_sysname = QString::fromUtf8("Common Source Code Project(");
+ log_sysname = log_sysname + dname + QString::fromUtf8(")");
+}
+
+void CSP_Logger::set_device_name(int num, char *devname)
+{
+ if(num < 0) return;
+ if(num > (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0)) return;
+ if(devname == NULL) return;
+ QString tmps = QString::fromUtf8(devname);
+ device_names.replace(num, tmps);
+}
+
+void CSP_Logger::set_cpu_name(int num, char *devname)
+{
+ if(num < 0) return;
+ if(num > (CSP_LOG_TYPE_VM_CPU7 - CSP_LOG_TYPE_VM_CPU0)) return;
+ if(devname == NULL) return;
+ QString tmps = QString::fromUtf8(devname);
+ device_names.replace(num, tmps);
+}
#include <stdarg.h>
#include <stdio.h>
-#include <QWidget>
+#include <QObject>
+#include <QStringList>
+#include <QString>
+#include <QQueue>
+
#if !defined(Q_OS_WIN32)
# include <syslog.h>
#endif
#include "simd_types.h"
#include "common.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
- void DLL_PREFIX AGAR_OpenLog(int syslog, int cons, const char *devname);
- void DLL_PREFIX AGAR_DebugLog(int level, const char *fmt, ...);
- void DLL_PREFIX AGAR_CloseLog(void);
- void DLL_PREFIX AGAR_SetLogStatus(int sw);
- void DLL_PREFIX AGAR_SetLogSysLog(int sw);
- void DLL_PREFIX AGAR_SetLogStdOut(int sw);
- bool DLL_PREFIX AGAR_LogGetStatus(void);
-
-#define AGAR_LOG_ON 1
-#define AGAR_LOG_OFF 0
+#define CSP_LOG_ON 1
+#define CSP_LOG_OFF 0
-#define AGAR_LOG_DEBUG 0
-#define AGAR_LOG_INFO 1
-#define AGAR_LOG_WARN 2
+#define CSP_LOG_DEBUG 0
+#define CSP_LOG_INFO 1
+#define CSP_LOG_WARN 2
+#define CSP_LOG_DEBUG2 3
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#define TRUE (!FALSE)
-#endif
+#define CSP_LOG_LEVELS 8
+
+enum {
+ CSP_LOG_TYPE_UNDEFINED = 0,
+ CSP_LOG_TYPE_GENERAL = 1,
+ CSP_LOG_TYPE_OSD,
+ CSP_LOG_TYPE_EMU,
+ CSP_LOG_TYPE_VM,
+ CSP_LOG_TYPE_GUI,
+ CSP_LOG_TYPE_SOUND,
+ CSP_LOG_TYPE_VIDEO,
+ CSP_LOG_TYPE_KEYBOARD,
+ CSP_LOG_TYPE_MOUSE,
+ CSP_LOG_TYPE_JOYSTICK,
+ CSP_LOG_TYPE_MOVIE_LOADER,
+ CSP_LOG_TYPE_MOVIE_SAVER,
+ CSP_LOG_TYPE_SCREEN,
+ CSP_LOG_TYPE_PRINTER,
+ CSP_LOG_TYPE_SOCKET,
+ CSP_LOG_TYPE_COMPONENT_END,
+ CSP_LOG_TYPE_VM_CPU0 = 32,
+ CSP_LOG_TYPE_VM_CPU1,
+ CSP_LOG_TYPE_VM_CPU2,
+ CSP_LOG_TYPE_VM_CPU3,
+ CSP_LOG_TYPE_VM_CPU4,
+ CSP_LOG_TYPE_VM_CPU5,
+ CSP_LOG_TYPE_VM_CPU6,
+ CSP_LOG_TYPE_VM_CPU7,
+ CSP_LOG_TYPE_VM_DEVICE_0,
+ CSP_LOG_TYPE_VM_DEVICE_END = 255,
+ CSP_LOG_TYPE_VFILE_HEAD = 256,
+ CSP_LOG_TYPE_VFILE_BINARY = 256,
+ CSP_LOG_TYPE_VFILE_BUBBLE = 264,
+ CSP_LOG_TYPE_VFILE_CART = 272,
+ CSP_LOG_TYPE_VFILE_CMT = 280,
+ CSP_LOG_TYPE_VFILE_COMPACTDISC = 288,
+ CSP_LOG_TYPE_VFILE_FLOPPY = 296,
+ CSP_LOG_TYPE_VFILE_LASERDISC = 312,
+ CSP_LOG_TYPE_VFILE_QUICKDISK = 320,
+ CSP_LOG_TYPE_VFILE_END = 336,
+
+};
+
+
+
+QT_BEGIN_NAMESPACE
+
+class CSP_LoggerLine {
+private:
+ int64_t linenum;
+ int level;
+ QString domain;
+ QString mainstr;
+ QString timestamp;
+public:
+ CSP_LoggerLine(int64_t line, int _level, QString _domain, QString time_s, QString s) {
+ mainstr = s;
+ linenum = line;
+ level = _level;
+ domain = _domain;
+ timestamp = time_s;
+ };
+ ~CSP_LoggerLine() {};
+ QString get_element_syslog(void) {
+ QString s;
+ if(domain.isEmpty()) {
+ s = mainstr;
+ } else {
+ s = domain + QString::fromUtf8(" ") + mainstr;
+ }
+ return s;
+ };
+ QString get_element_console(void) {
+ QString s;
+ if(domain.isEmpty()) {
+ s = timestamp + QString::fromUtf8(" ") + mainstr;
+ } else {
+ s = timestamp + QString::fromUtf8(" ") + domain + QString::fromUtf8(" ") + mainstr;
+ }
+ return s;
+ };
+};
+
+class QMutex;
+class CSP_Logger: public QObject {
+ Q_OBJECT
+private:
+ bool syslog_flag;
+ bool syslog_flag_out;
+
+ bool log_cons;
+ bool log_cons_out;
+ bool log_onoff;
+ bool log_opened;
+
+ int64_t linenum;
+ int64_t line_wrap;
+ int cons_log_levels;
+ int sys_log_levels;
+
+ QString loglist;
+ QString log_sysname;
+ QStringList component_names;
+ QStringList vfile_names;
+ QStringList cpu_names;
+ QStringList device_names;
+
+ QQueue<CSP_LoggerLine *> squeue;
+ QMutex *lock_mutex;
+
+protected:
+ void debug_log(int level, int domain_num, char *strbuf);
+
+public:
+ CSP_Logger(bool b_syslog, bool cons, const char *devname);
+ ~CSP_Logger();
+ void open(bool b_syslog, bool cons, const char *devname);
+ void debug_log(int level, const char *fmt, ...);
+ void debug_log(int level, int domain_num, const char *fmt, ...);
+ void close(void);
+ void set_log_status(bool sw);
+ void set_log_syslog(int level, bool sw);
+ void set_log_stdout(int level, bool sw);
+ bool get_status(void);
+
+ void set_emu_vm_name(const char *devname);
+ void set_device_name(int num, char *devname);
+ void set_cpu_name(int num, char *devname);
+};
+QT_END_NAMESPACE
+
+extern CSP_Logger *csp_logger;
-#ifdef __cplusplus
-}
-#endif
-
#endif
void DrawThreadClass::doExit(void)
{
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "DrawThread : Exit.");
+ //csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL,
+ // "DrawThread : Exit.");
bRunThread = false;
}
wait_count -= (qreal)wait_factor;
}
} while(bRunThread);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "DrawThread : Exit.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL,
+ "DrawThread : Exit.");
this->exit(0);
}
void Ui_MainWindowBase::OnReset(void)
{
- AGAR_DebugLog(AGAR_LOG_INFO, "Reset");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GUI, "Reset");
emit sig_vm_reset();
}
void Ui_MainWindowBase::OnSpecialReset(void)
{
- AGAR_DebugLog(AGAR_LOG_INFO, "Special Reset");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GUI, "Special reset");
emit sig_vm_specialreset();
}
joystick_plugged(i);
}
# endif
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Start.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Start.");
} else {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Any joysticks were not connected.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Any joysticks were not connected.");
}
bRunThread = true;
} else {
joyhandle[i] = NULL;
names[i] = QString::fromUtf8("None");
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : None launched because this VM has not supported joystick.");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : None launched because this VM has not supported joystick.");
bRunThread = false;
}
}
SDL_GameControllerClose(controller_table[i]);
controller_table[i] = NULL;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : EXIT");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : EXIT");
# else
for(i = 0; i < 16; i++) {
SDL_JoystickClose(joyhandle[i]);
joyhandle[i] = NULL;
}
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : EXIT");
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : EXIT");
# endif
}
}
joyhandle[num] = SDL_GameControllerGetJoystick(controller_table[num]);
if(controller_table[num] != NULL) {
names[num] = QString::fromUtf8(SDL_GameControllerNameForIndex(num));
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Controller %d : %s : is plugged.", num, names[num].toUtf8().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Controller %d : %s : is plugged.", num, names[num].toUtf8().constData());
strncpy(p_config->assigned_joystick_name[num], names[num].toUtf8().constData(), 255);
joy_num[num] = num;
}
joyhandle[i] = SDL_JoystickOpen(num);
joy_num[i] = SDL_JoystickInstanceID(joyhandle[i]);
names[i] = QString::fromUtf8(SDL_JoystickNameForIndex(num));
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Joystick %d : %s : is plugged.", num, names[i].toUtf8().data());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Joystick %d : %s : is plugged.", num, names[i].toUtf8().data());
strncpy(p_config->assigned_joystick_name[num], names[num].toUtf8().constData(), 255);
break;
}
if(controller_table[num] != NULL) {
SDL_GameControllerClose(controller_table[num]);
controller_table[num] = NULL;
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Controller %d : %s : is removed.", num, names[num].toUtf8().data());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Controller %d : %s : is removed.", num, names[num].toUtf8().data());
joy_num[num] = -1;
}
joyhandle[num] = NULL;
if(joyhandle[num] != NULL) {
SDL_JoystickClose(joyhandle[num]);
joyhandle[num] = NULL;
- AGAR_DebugLog(AGAR_LOG_DEBUG, "JoyThread : Joystick %d : %s : is removed.", num, names[num].toUtf8().data());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Joystick %d : %s : is removed.", num, names[num].toUtf8().data());
joy_num[num] = -1;
}
}
void CSP_DiskParams::_open_disk(QString s)
{
int d = getDrive();
- AGAR_DebugLog(AGAR_LOG_INFO, "Try to open media image: %s", s.toLocal8Bit().constData());
- AGAR_DebugLog(AGAR_LOG_INFO, "Drive = %d\n", d);
+ int n = d + CSP_LOG_TYPE_VFILE_FLOPPY;
+ csp_logger->debug_log(CSP_LOG_INFO, n, "Try to open media image: %s", s.toLocal8Bit().constData());
emit do_open_disk(d, s);
}
delay_update = true;
}
//do_set_texture_size(imgptr, screen_texture_width, screen_texture_height);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "ResizeGL: %dx%d", width , height);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "ResizeGL: %dx%d", width , height);
emit sig_resize_uibar(width, height);
}
QOpenGLFunctions_3_0 *funcs_3_0 = glContext->versionFunctions<QOpenGLFunctions_3_0>();
if((funcs_3_0 != NULL) && (extfunc == NULL)){
extfunc = new GLDraw_3_0(this, using_flags);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Use OpenGL v3.0");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Use OpenGL v3.0");
}
#endif
QOpenGLFunctions_2_0 *funcs_2_0 = glContext->versionFunctions<QOpenGLFunctions_2_0>();
if((funcs_2_0 != NULL) && (extfunc == NULL)){
extfunc = new GLDraw_2_0(this, using_flags);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Use OpenGL v2.0");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "Use OpenGL v2.0");
}
if(extfunc != NULL) {
extfunc->initGLObjects();
extfunc->initFBO();
extfunc->initLocalGLObjects();
} else {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "None using OpenGL.");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL, "None using OpenGL.");
//str_gl_version = QString::fromUtf8("None");
}
}
#include "common.h"
#include "fileio.h"
#include "menu_flags.h"
+#include "agar_logger.h"
extern std::string cpp_homedir;
extern std::string cpp_confdir;
extern int MainLoop(int argc, char *argv[], config_t *cfg);
extern config_t config;
+CSP_Logger *csp_logger;
+
/*
* This is main for Qt.
*/
/*
* アプリケーション初期化
*/
+
+ csp_logger = new CSP_Logger(false, true, NULL); // Write to syslog, console
+ csp_logger->set_log_stdout(CSP_LOG_DEBUG, true);
+ csp_logger->set_log_stdout(CSP_LOG_INFO, true);
+ csp_logger->set_log_stdout(CSP_LOG_WARN, true);
Q_INIT_RESOURCE(commontexts);
Q_INIT_RESOURCE(shaders);
nErrorCode = MainLoop(argc, argv, &config);
Q_CLEANUP_RESOURCE(shaders);
Q_CLEANUP_RESOURCE(commontexts);
+ if(csp_logger != NULL) delete csp_logger;
+
return nErrorCode;
}
#if defined(Q_OS_WIN)
strcpy(using_flags->get_config_ptr()->initial_compact_disc_dir, path_shadow);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
emit sig_close_cdrom();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "CD-ROM: Open : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_COMPACTDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_cdrom(s_path);
menu_CDROM->do_update_histories(listCDROM);
menu_CDROM->do_set_initialize_directory(using_flags->get_config_ptr()->initial_compact_disc_dir);
strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
emit sig_close_cdrom();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "CD-ROM: Open : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_COMPACTDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_cdrom(path);
menu_CDROM->do_update_histories(listCDROM);
menu_CDROM->do_set_initialize_directory(using_flags->get_config_ptr()->initial_compact_disc_dir);
get_parent_dir(path_shadow);
strcpy(using_flags->get_config_ptr()->initial_tape_dir, path_shadow);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Tape: Open READ");
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_VFILE_CMT + 0, "Open READ");
emit sig_close_tape();
emit sig_play_tape(s_path);
strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
emit sig_close_tape();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Tape: Open READ : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_CMT + 0, "Open READ : filename = %s", path_shadow);
emit sig_play_tape(path);
menu_CMT->do_update_histories(listCMT);
menu_CMT->do_set_initialize_directory(using_flags->get_config_ptr()->initial_tape_dir);
emit sig_close_tape();
if(menu_CMT->getWriteProtect() != false) {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Tape: Open READ : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_CMT + 0, "Open READ : filename = %s", path_shadow);
emit sig_play_tape(path);
} else {
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Tape: Open Write : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_CMT + 0, "Open Write : filename = %s", path_shadow);
emit sig_rec_tape(path);
}
menu_CMT->do_update_histories(listCMT);
strcpy(using_flags->get_config_ptr()->initial_laser_disc_dir, path_shadow);
strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
emit sig_close_laserdisc();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Laserdisc: Open : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_LASERDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_laserdisc(s_path);
menu_Laserdisc->do_update_histories(listLaserdisc);
menu_Laserdisc->do_set_initialize_directory(using_flags->get_config_ptr()->initial_laser_disc_dir);
strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
emit sig_close_laserdisc();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "Laserdisc: Open : filename = %s", path_shadow);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_LASERDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_laserdisc(path);
menu_Laserdisc->do_update_histories(listLaserdisc);
menu_Laserdisc->do_set_initialize_directory(using_flags->get_config_ptr()->initial_laser_disc_dir);
{
static _TCHAR file_path[_MAX_PATH];
snprintf(file_path, _MAX_PATH, _T("%s%s"), app_path, file_name);
- AGAR_DebugLog(AGAR_LOG_INFO, "BIOS PATH:%s", file_path);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_OSD, "BIOS PATH:%s", file_path);
return file_path;
}
emit sig_enqueue_video(i, vm_screen_width, vm_screen_height, &video_result);
//i--;
}
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "Push Video %d frames\n", counter);
+ csp_logger->debug_log(CSP_LOG_DEBUG2, CSP_LOG_TYPE_SCREEN, "Push Video %d frames\n", counter);
}
return counter;
}
bitmap->hPainter.begin(&(bitmap->pImage));
bitmap->hPainter.fillRect(0, 0, width, height, col);
bitmap->hPainter.end();
- AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Create bitmap: %08x %d x %d", bitmap, width, height);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Create bitmap: %08x %d x %d", bitmap, width, height);
}
void OSD_BASE::release_bitmap(bitmap_t *bitmap)
{
release_screen_buffer(bitmap);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Release bitmap: %08x", bitmap);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Release bitmap: %08x", bitmap);
}
void OSD_BASE::create_font(font_t *font, const _TCHAR *family, int width, int height, int rotate, bool bold, bool italic)
font->hFont.setStretch((width * 10000) / (metric.width("F") * 100));
font->rotate = rotate;
font->init_flag = true;
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Create Font: Family=%s WIDTH=%d HEIGHT=%d",fontName.toUtf8().constData(), width, height);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Create Font: Family=%s WIDTH=%d HEIGHT=%d",fontName.toUtf8().constData(), width, height);
// Qt uses substitution font if not found.
}
void OSD_BASE::release_font(font_t *font)
{
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Release Font");
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Release Font");
}
void OSD_BASE::create_pen(pen_t *pen, int width, uint8_t r, uint8_t g, uint8_t b)
QColor color = QColor(r, g, b, 255);
pen->hPen.setColor(color);
pen->hPen.setWidth(width);
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Create PEN %08x to width=%d (RGB)=(%d,%d,%d)\n", pen, width, r, g, b);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Create PEN %08x to width=%d (RGB)=(%d,%d,%d)\n", pen, width, r, g, b);
}
void OSD_BASE::release_pen(pen_t *pen)
{
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Release Pen %08x", pen);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Release Pen %08x", pen);
}
void OSD_BASE::clear_bitmap(bitmap_t *bitmap, uint8_t r, uint8_t g, uint8_t b)
{
//lock_vm();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Clear bitmap %08x", bitmap);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Clear bitmap %08x", bitmap);
draw_rectangle_to_bitmap(bitmap, 0, 0, bitmap->width, bitmap->height, r, g, b);
//unlock_vm();
}
bitmap->hPainter.setFont(font->hFont);
bitmap->hPainter.drawText(loc, str);
bitmap->hPainter.end();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Draw Text to BITMAP %08x : (%d,%d) %s : Color(%d,%d,%d)", bitmap, x, y, str.toUtf8().constData(), r, g, b);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Draw Text to BITMAP %08x : (%d,%d) %s : Color(%d,%d,%d)", bitmap, x, y, str.toUtf8().constData(), r, g, b);
}
void OSD_BASE::draw_line_to_bitmap(bitmap_t *bitmap, pen_t *pen, int sx, int sy, int ex, int ey)
bitmap->hPainter.setPen(pen->hPen);
bitmap->hPainter.drawLine(line);
bitmap->hPainter.end();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Draw Line from (%d,%d) to (%d,%d) to BITMAP %08x", sx, sy, ex, ey, bitmap);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Draw Line from (%d,%d) to (%d,%d) to BITMAP %08x", sx, sy, ex, ey, bitmap);
}
void OSD_BASE::draw_point_to_bitmap(bitmap_t *bitmap, int x, int y, uint8_t r, uint8_t g, uint8_t b)
bitmap->hPainter.setPen(d_pen);
bitmap->hPainter.drawPoint(point);
bitmap->hPainter.end();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Draw Point to BITMAP %08x :(%d,%d) Color=(%d,%d,%d)", bitmap, x, y, r, g, b);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Draw Point to BITMAP %08x :(%d,%d) Color=(%d,%d,%d)", bitmap, x, y, r, g, b);
}
void OSD_BASE::draw_rectangle_to_bitmap(bitmap_t *bitmap, int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b)
//bitmap->hPainter.setBackgroundMode(Qt::OpaqueMode);
bitmap->hPainter.fillRect(x, y, width, height, d_brush);
bitmap->hPainter.end();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Draw Rect BITMAP %08x :from (%d,%d) size=(%d,%d) Color=(%d,%d,%d)", bitmap, x, y, width, height, r, g, b);
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Draw Rect BITMAP %08x :from (%d,%d) size=(%d,%d) Color=(%d,%d,%d)", bitmap, x, y, width, height, r, g, b);
}
void OSD_BASE::stretch_bitmap(bitmap_t *dest, int dest_x, int dest_y, int dest_width, int dest_height, bitmap_t *source, int source_x, int source_y, int source_width, int source_height)
//dest->hPainter.setBackgroundMode(Qt::OpaqueMode);
dest->hPainter.drawImage(dest_r, source->pImage, src_r);
dest->hPainter.end();
- //AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Scale (%d,%d, %d, %d) to (%d,%d, %d, %d)", source_x, source_y, source_width, source_height,
+ //csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Scale (%d,%d, %d, %d) to (%d,%d, %d, %d)", source_x, source_y, source_width, source_height,
// dest_x, dest_y, dest_width, dest_height);
}
//#endif
{
int comp_quality = 0;
bitmap->pImage.save(QString::fromUtf8(file_path), "PNG", comp_quality);
- AGAR_DebugLog(AGAR_LOG_DEBUG, "PRINTER: Save bitmap %08x to %s", bitmap, file_path);
+ csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_PRINTER, "Save (print outed) bitmap %08x to %s", bitmap, file_path);
}
int OSD_BASE::get_vm_window_width()
}
if((*(pData->sound_write_pos) + len2) >= *(pData->sound_buffer_size) ) len2 = *(pData->sound_buffer_size) - *(pData->sound_write_pos);
- if(*(pData->sound_debug)) AGAR_DebugLog(AGAR_LOG_DEBUG, "SND:Callback,sound_write_pos=%d,spos=%d,len=%d,len2=%d",
- *(pData->sound_write_pos), spos, len, len2);
+ if(*(pData->sound_debug)) csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_SOUND,
+ "Callback,sound_write_pos=%d,spos=%d,len=%d,len2=%d",
+ *(pData->sound_write_pos), spos, len, len2);
if((len2 > 0) && (sndlen > 0)){
writepos = *pData->sound_write_pos;
p = (Uint8 *)(*pData->sound_buf_ptr);
#if defined(USE_SDL2)
for(i = 0; i < SDL_GetNumAudioDevices(0); i++) {
//devname = SDL_GetAudioDeviceName(i, 0);
- //AGAR_DebugLog(AGAR_LOG_INFO, "Audio Device: %s", devname.c_str());
QString tmps = QString::fromUtf8(SDL_GetAudioDeviceName(i, 0));
- AGAR_DebugLog(AGAR_LOG_INFO, "Audio Device: %s", tmps.toLocal8Bit().constData());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_SOUND,
+ "Audio Device: %s", tmps.toLocal8Bit().constData());
}
#endif
SDL_OpenAudio(&snd_spec_req, &snd_spec_presented);
sound_buf_ptr = NULL;
return;
}
- AGAR_DebugLog(AGAR_LOG_INFO, "Sound OK: BufSize = %d", sound_buffer_size);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_SOUND,
+ "Sound OK: BufSize = %d", sound_buffer_size);
memset(sound_buf_ptr, 0x00, sound_buffer_size * sizeof(Sint16));
#if defined(USE_SDL2)
SDL_PauseAudioDevice(audio_dev_id, 0);
// start play
// check current position
play_c = sound_write_pos;
- if(sound_debug) AGAR_DebugLog(AGAR_LOG_DEBUG, "SND: Called time=%d sound_write_pos=%d\n", osd_timer.elapsed(), play_c);
+ if(sound_debug) csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_SOUND,
+ "Called time=%d sound_write_pos=%d\n", osd_timer.elapsed(), play_c);
if(!sound_first_half) {
if(play_c < (sound_buffer_size / 2)) {
return;
OSDN Git Service
