364 lines
9.0 KiB
C
364 lines
9.0 KiB
C
/**
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
*
|
|
* Copyright (C) Jay Sorg 2004-2013
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* jpeg compressor
|
|
*/
|
|
|
|
#include "libxrdp.h"
|
|
|
|
#if defined(XRDP_TJPEG)
|
|
|
|
/* turbo jpeg */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <turbojpeg.h>
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
|
|
struct stream *s, int bpp, int byte_limit,
|
|
int start_line, struct stream *temp_s,
|
|
int e, int quality)
|
|
{
|
|
int error;
|
|
int i;
|
|
int j;
|
|
unsigned int pixel;
|
|
unsigned int *src32;
|
|
unsigned int *dst32;
|
|
unsigned long cdata_bytes;
|
|
unsigned char *src_buf;
|
|
unsigned char *dst_buf;
|
|
char *temp_buf;
|
|
tjhandle tj_han;
|
|
|
|
if (bpp != 24)
|
|
{
|
|
g_writeln("xrdp_jpeg_compress: bpp wrong %d", bpp);
|
|
return height;
|
|
}
|
|
if (handle == 0)
|
|
{
|
|
g_writeln("xrdp_jpeg_compress: handle is nil");
|
|
return height;
|
|
}
|
|
tj_han = (tjhandle) handle;
|
|
cdata_bytes = byte_limit;
|
|
src_buf = (unsigned char *) in_data;
|
|
dst_buf = (unsigned char *) (s->p);
|
|
temp_buf = 0;
|
|
if (e == 0)
|
|
{
|
|
src_buf = (unsigned char*)in_data;
|
|
}
|
|
else
|
|
{
|
|
temp_buf = (char *) g_malloc((width + e) * height * 4, 0);
|
|
dst32 = (unsigned int *) temp_buf;
|
|
src32 = (unsigned int *) in_data;
|
|
for (j = 0; j < height; j++)
|
|
{
|
|
for (i = 0; i < width; i++)
|
|
{
|
|
pixel = *src32;
|
|
src32++;
|
|
*dst32 = pixel;
|
|
dst32++;
|
|
}
|
|
for (i = 0; i < e; i++)
|
|
{
|
|
*dst32 = pixel;
|
|
dst32++;
|
|
}
|
|
}
|
|
src_buf = (unsigned char *) temp_buf;
|
|
}
|
|
dst_buf = (unsigned char*)(s->p);
|
|
error = tjCompress(tj_han, src_buf, width + e, (width + e) * 4, height,
|
|
TJPF_XBGR, dst_buf, &cdata_bytes,
|
|
TJSAMP_420, quality, 0);
|
|
s->p += cdata_bytes;
|
|
g_free(temp_buf);
|
|
return height;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void *APP_CC
|
|
xrdp_jpeg_init(void)
|
|
{
|
|
tjhandle tj_han;
|
|
|
|
tj_han = tjInitCompress();
|
|
return tj_han;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_deinit(void *handle)
|
|
{
|
|
tjhandle tj_han;
|
|
|
|
if (handle == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
tj_han = (tjhandle) handle;
|
|
tjDestroy(tj_han);
|
|
return 0;
|
|
}
|
|
|
|
#elif defined(XRDP_JPEG)
|
|
|
|
/* libjpeg */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <jpeglib.h>
|
|
|
|
#define JP_QUALITY 75
|
|
|
|
struct mydata_comp
|
|
{
|
|
char *cb;
|
|
int cb_bytes;
|
|
int total_done;
|
|
int overwrite;
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
/* called at begining */
|
|
static void DEFAULT_CC
|
|
my_init_destination(j_compress_ptr cinfo)
|
|
{
|
|
struct mydata_comp *md;
|
|
|
|
md = (struct mydata_comp *)(cinfo->client_data);
|
|
md->total_done = 0;
|
|
md->overwrite = 0;
|
|
cinfo->dest->next_output_byte = md->cb;
|
|
cinfo->dest->free_in_buffer = md->cb_bytes;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* called when buffer is full and we need more space */
|
|
static int DEFAULT_CC
|
|
my_empty_output_buffer(j_compress_ptr cinfo)
|
|
{
|
|
struct mydata_comp *md;
|
|
int chunk_bytes;
|
|
|
|
md = (struct mydata_comp *)(cinfo->client_data);
|
|
chunk_bytes = md->cb_bytes;
|
|
md->total_done += chunk_bytes;
|
|
cinfo->dest->next_output_byte = md->cb;
|
|
cinfo->dest->free_in_buffer = md->cb_bytes;
|
|
md->overwrite = 1;
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* called at end */
|
|
static void DEFAULT_CC
|
|
my_term_destination(j_compress_ptr cinfo)
|
|
{
|
|
struct mydata_comp *md;
|
|
int chunk_bytes;
|
|
|
|
md = (struct mydata_comp *)(cinfo->client_data);
|
|
chunk_bytes = md->cb_bytes - cinfo->dest->free_in_buffer;
|
|
md->total_done += chunk_bytes;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int APP_CC
|
|
jp_do_compress(char *data, int width, int height, int bpp, int quality,
|
|
char *comp_data, int *comp_data_bytes)
|
|
{
|
|
struct jpeg_compress_struct cinfo;
|
|
struct jpeg_error_mgr jerr;
|
|
struct jpeg_destination_mgr dst_mgr;
|
|
struct mydata_comp md;
|
|
JSAMPROW row_pointer[4];
|
|
int Bpp;
|
|
|
|
Bpp = (bpp + 7) / 8;
|
|
memset(&cinfo, 0, sizeof(cinfo));
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
jpeg_create_compress(&cinfo);
|
|
memset(&md, 0, sizeof(md));
|
|
md.cb = comp_data,
|
|
md.cb_bytes = *comp_data_bytes;
|
|
cinfo.client_data = &md;
|
|
memset(&dst_mgr, 0, sizeof(dst_mgr));
|
|
dst_mgr.init_destination = my_init_destination;
|
|
dst_mgr.empty_output_buffer = my_empty_output_buffer;
|
|
dst_mgr.term_destination = my_term_destination;
|
|
cinfo.dest = &dst_mgr;
|
|
cinfo.image_width = width;
|
|
cinfo.image_height = height;
|
|
cinfo.input_components = Bpp;
|
|
cinfo.in_color_space = JCS_RGB;
|
|
jpeg_set_defaults(&cinfo);
|
|
cinfo.num_components = 3;
|
|
cinfo.dct_method = JDCT_FLOAT;
|
|
jpeg_set_quality(&cinfo, quality, 1);
|
|
jpeg_start_compress(&cinfo, 1);
|
|
|
|
while (cinfo.next_scanline + 3 < cinfo.image_height)
|
|
{
|
|
row_pointer[0] = data;
|
|
data += width * Bpp;
|
|
row_pointer[1] = data;
|
|
data += width * Bpp;
|
|
row_pointer[2] = data;
|
|
data += width * Bpp;
|
|
row_pointer[3] = data;
|
|
data += width * Bpp;
|
|
jpeg_write_scanlines(&cinfo, row_pointer, 4);
|
|
}
|
|
|
|
while (cinfo.next_scanline < cinfo.image_height)
|
|
{
|
|
row_pointer[0] = data;
|
|
data += width * Bpp;
|
|
jpeg_write_scanlines(&cinfo, row_pointer, 1);
|
|
}
|
|
|
|
jpeg_finish_compress(&cinfo);
|
|
*comp_data_bytes = md.total_done;
|
|
jpeg_destroy_compress(&cinfo);
|
|
|
|
if (md.overwrite)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
static int APP_CC
|
|
jpeg_compress(char *in_data, int width, int height,
|
|
struct stream *s, struct stream *temp_s, int bpp,
|
|
int byte_limit, int e, int quality)
|
|
{
|
|
char *data;
|
|
tui32 *src32;
|
|
tui16 *src16;
|
|
tui8 *dst8;
|
|
tui32 pixel;
|
|
int red;
|
|
int blue;
|
|
int green;
|
|
int j;
|
|
int i;
|
|
int cdata_bytes;
|
|
|
|
data = temp_s->data;
|
|
dst8 = data;
|
|
|
|
if (bpp == 24)
|
|
{
|
|
src32 = (tui32 *)in_data;
|
|
|
|
for (j = 0; j < height; j++)
|
|
{
|
|
for (i = 0; i < width; i++)
|
|
{
|
|
pixel = src32[i + j * width];
|
|
SPLITCOLOR32(red, green, blue, pixel);
|
|
*(dst8++) = blue;
|
|
*(dst8++) = green;
|
|
*(dst8++) = red;
|
|
}
|
|
|
|
for (i = 0; i < e; i++)
|
|
{
|
|
*(dst8++) = blue;
|
|
*(dst8++) = green;
|
|
*(dst8++) = red;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_writeln("bpp wrong %d", bpp);
|
|
}
|
|
|
|
cdata_bytes = byte_limit;
|
|
jp_do_compress(data, width + e, height, 24, quality, s->p, &cdata_bytes);
|
|
s->p += cdata_bytes;
|
|
return cdata_bytes;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
|
|
struct stream *s, int bpp, int byte_limit,
|
|
int start_line, struct stream *temp_s,
|
|
int e, int quality)
|
|
{
|
|
jpeg_compress(in_data, width, height, s, temp_s, bpp, byte_limit,
|
|
e, quality);
|
|
return height;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void *APP_CC
|
|
xrdp_jpeg_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_deinit(void *handle)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_compress(void *handle, char *in_data, int width, int height,
|
|
struct stream *s, int bpp, int byte_limit,
|
|
int start_line, struct stream *temp_s,
|
|
int e, int quality)
|
|
{
|
|
return height;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void *APP_CC
|
|
xrdp_jpeg_init(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
int APP_CC
|
|
xrdp_jpeg_deinit(void *handle)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif
|