static void display_sage_run(void *arg)
{
struct state_sage *s = (struct state_sage *)arg;
s->magic = MAGIC_SAGE;
while (!s->should_exit) {
display_sage_handle_events();
sem_wait(&s->semaphore);
if (s->should_exit)
break;
if (s->deinterlace) {
vc_deinterlace((unsigned char *) s->tile->data, vc_get_linesize(s->tile->width,
s->frame->color_spec), s->tile->height);
}
s->sage_state->swapBuffer(SAGE_NON_BLOCKING);
sageMessage msg;
if (s->sage_state->checkMsg(msg, false) > 0) {
switch (msg.getCode()) {
case APP_QUIT:
sage::printLog("Ultragrid: QUIT message");
exit_uv(1);
break;
}
}
s->tile->data = (char *) s->sage_state->getBuffer();
pthread_mutex_lock(&s->buffer_writable_lock);
s->buffer_writable = 1;
if(s->grab_waiting) {
pthread_cond_broadcast(&s->buffer_writable_cond);
}
pthread_mutex_unlock(&s->buffer_writable_lock);
s->frames++;
gettimeofday(&s->t, NULL);
double seconds = tv_diff(s->t, s->t0);
if (seconds >= 5) {
float fps = s->frames / seconds;
log_msg(LOG_LEVEL_INFO, "[SAGE] %d frames in %g seconds = %g FPS\n",
s->frames, seconds, fps);
s->t0 = s->t;
s->frames = 0;
}
}
}
struct video_frame * dxt_glsl_compress(struct module *mod, struct video_frame * tx, int buffer_idx)
{
struct state_video_compress_rtdxt *s = (struct state_video_compress_rtdxt *) mod->priv_data;
int i;
unsigned char *line1, *line2;
assert(buffer_idx >= 0 && buffer_idx < 2);
unsigned int x;
gl_context_make_current(&s->gl_context);
if(!s->configured) {
int ret;
ret = configure_with(s, tx);
if(!ret)
return NULL;
}
for (x = 0; x < tx->tile_count; ++x) {
struct tile *in_tile = vf_get_tile(tx, x);
struct tile *out_tile = vf_get_tile(s->out[buffer_idx], x);
line1 = (unsigned char *) in_tile->data;
line2 = (unsigned char *) s->decoded;
for (i = 0; i < (int) in_tile->height; ++i) {
s->decoder(line2, line1, s->encoder_input_linesize,
0, 8, 16);
line1 += vc_get_linesize(in_tile->width, tx->color_spec);
line2 += s->encoder_input_linesize;
}
if(s->interlaced_input)
vc_deinterlace((unsigned char *) s->decoded, s->encoder_input_linesize,
in_tile->height);
dxt_encoder_compress(s->encoder[x],
(unsigned char *) s->decoded,
(unsigned char *) out_tile->data);
}
gl_context_make_current(NULL);
return s->out[buffer_idx];
}
struct video_frame * fastdxt_compress(void *args, struct video_frame *tx, int buffer_idx)
{
/* This thread will be called from main.c and handle the compress_threads */
struct video_compress *compress = (struct video_compress *)args;
unsigned int x;
unsigned char *line1, *line2;
struct video_frame *out = compress->out[buffer_idx];
struct tile *out_tile = &out->tiles[0];
assert(tx->tile_count == 1);
assert(vf_get_tile(tx, 0)->width % 4 == 0);
pthread_mutex_lock(&(compress->lock));
if(vf_get_tile(tx, 0)->width != out_tile->width ||
vf_get_tile(tx, 0)->height != out_tile->height ||
tx->interlacing != compress->interlacing_source ||
tx->color_spec != compress->tx_color_spec)
{
int ret;
ret = reconfigure_compress(compress, vf_get_tile(tx, 0)->width, vf_get_tile(tx, 0)->height, tx->color_spec, tx->interlacing, tx->fps);
if(!ret)
return NULL;
}
line1 = (unsigned char *) tx->tiles[0].data;
line2 = compress->output_data;
for (x = 0; x < out_tile->height; ++x) {
int src_linesize = vc_get_linesize(out_tile->width, compress->tx_color_spec);
compress->decoder(line2, line1, out_tile->linesize,
0, 8, 16);
line1 += src_linesize;
line2 += out_tile->linesize;
}
if(tx->interlacing != INTERLACED_MERGED && tx->interlacing != PROGRESSIVE) {
fprintf(stderr, "Unsupported interlacing format.\n");
exit_uv(1);
}
if(tx->interlacing == INTERLACED_MERGED) {
vc_deinterlace(compress->output_data, out_tile->linesize,
out_tile->height);
}
compress->buffer_idx = buffer_idx;
for (x = 0; x < (unsigned int) compress->num_threads; x++) {
platform_sem_post(&compress->thread_compress[x]);
}
for (x = 0; x < (unsigned int) compress->num_threads; x++) {
platform_sem_wait(&compress->thread_done[x]);
}
out_tile->data_len = out_tile->width * compress->dxt_height / 2;
pthread_mutex_unlock(&(compress->lock));
return out;
}
