/**
* Software fallback for generate mipmap levels.
*/
static void
fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
struct gl_texture_object *texObj)
{
struct pipe_context *pipe = st_context(ctx)->pipe;
struct pipe_resource *pt = st_get_texobj_resource(texObj);
const uint baseLevel = texObj->BaseLevel;
const uint lastLevel = pt->last_level;
const uint face = _mesa_tex_target_to_face(target);
uint dstLevel;
GLenum datatype;
GLuint comps;
GLboolean compressed;
if (ST_DEBUG & DEBUG_FALLBACK)
debug_printf("%s: fallback processing\n", __FUNCTION__);
assert(target != GL_TEXTURE_3D); /* not done yet */
compressed =
_mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);
if (compressed) {
GLenum type =
_mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);
datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;
comps = 4;
}
else {
_mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
&datatype, &comps);
assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");
}
for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
const uint srcLevel = dstLevel - 1;
const uint srcWidth = u_minify(pt->width0, srcLevel);
const uint srcHeight = u_minify(pt->height0, srcLevel);
const uint srcDepth = u_minify(pt->depth0, srcLevel);
const uint dstWidth = u_minify(pt->width0, dstLevel);
const uint dstHeight = u_minify(pt->height0, dstLevel);
const uint dstDepth = u_minify(pt->depth0, dstLevel);
struct pipe_transfer *srcTrans, *dstTrans;
const ubyte *srcData;
ubyte *dstData;
int srcStride, dstStride;
srcTrans = pipe_get_transfer(pipe, pt, srcLevel,
face,
PIPE_TRANSFER_READ, 0, 0,
srcWidth, srcHeight);
dstTrans = pipe_get_transfer(pipe, pt, dstLevel,
face,
PIPE_TRANSFER_WRITE, 0, 0,
dstWidth, dstHeight);
srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);
dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);
srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);
dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);
/* this cannot work correctly for 3d since it does
not respect layerStride. */
if (compressed) {
const enum pipe_format format = pt->format;
const uint bw = util_format_get_blockwidth(format);
const uint bh = util_format_get_blockheight(format);
const uint srcWidth2 = align(srcWidth, bw);
const uint srcHeight2 = align(srcHeight, bh);
const uint dstWidth2 = align(dstWidth, bw);
const uint dstHeight2 = align(dstHeight, bh);
uint8_t *srcTemp, *dstTemp;
assert(comps == 4);
srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
/* decompress the src image: srcData -> srcTemp */
decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);
_mesa_generate_mipmap_level(target, datatype, comps,
0 /*border*/,
srcWidth2, srcHeight2, srcDepth,
srcTemp,
srcWidth2, /* stride in texels */
dstWidth2, dstHeight2, dstDepth,
dstTemp,
dstWidth2); /* stride in texels */
/* compress the new image: dstTemp -> dstData */
compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);
free(srcTemp);
free(dstTemp);
}
else {
_mesa_generate_mipmap_level(target, datatype, comps,
0 /*border*/,
srcWidth, srcHeight, srcDepth,
srcData,
srcStride, /* stride in texels */
dstWidth, dstHeight, dstDepth,
dstData,
dstStride); /* stride in texels */
}
pipe_transfer_unmap(pipe, srcTrans);
pipe_transfer_unmap(pipe, dstTrans);
pipe->transfer_destroy(pipe, srcTrans);
pipe->transfer_destroy(pipe, dstTrans);
}
}
// find image in buffer
int CameraMJPG::cut_image(char* buffer, int length)
{
if(!buffer || length<=0)
return 1;
// find MIME header
if( find_data_in_buffer(buffer, length,
CAMERA_MJPG_MIME_CONTENT_TYPE_JPEG, CAMERA_MJPG_MIME_CONTENT_TYPE_JPEG_SIZE) != 0 )
{
//printf("[i][CameraMJPG][cut_image] Image header!\n");
// get message with image size
const char* pdest1 = find_data_in_buffer(buffer, length,
CAMERA_MJPG_MIME_CONTENT_LENGTH, CAMERA_MJPG_MIME_CONTENT_LENGTH_SIZE);
pdest1 += CAMERA_MJPG_MIME_CONTENT_LENGTH_SIZE;
const char* pdest2 = strstr(pdest1, "\r\n\r\n");
int str_len = pdest2 - pdest1;
if (str_len > 128){
printf("[!][CameraMJPG][cut_image] Error: image size error!\n");
str_len = 128;
}
char str_size[128];
memcpy(str_size, pdest1, str_len);
str_size[str_len] = 0;
int size = atoi(str_size);
// printf("[i][CameraMJPG][cut_image] image size: %d \n", size);
if(size > buf_video.real_size)
printf("[!][CameraMJPG][cut_image] Warning: too big image: %d !\n", size);
// get data length
int recv_len = length - (pdest2 - buffer + 4);
// pointer to image data
const char* pimage = pdest2 + 4;
// not all image in buffer
if (recv_len < size){
return 2;
}
//
// got image!
//
image_counter++;
#if CAMERA_MJPG_SAVE_JPEG_IMAGE
//
// save JPEG into file
//
char file[128];
snprintf(file, 128, "image%02d.jpg", imageCounter);
writeBufferToFile(file, pimage, size);
#endif //#if VIDEOSERVER_SAVE_JPEG_IMAGE
remove_frame();
#if defined(USE_OPENCV)
//
// unpack JPEG-image
//
frame = decompress_image(pimage, size);
#else
frame = new char[size];
if(frame){
memcpy(frame, pimage, size);
frame_size = size;
}
else{
printf("[!][cut_image][cut_image] Error: cant allocate memory!\n");
}
#endif // #if defined(USE_OPENCV)
#if 0
// reset buffer
buf_video.zero();
#else
int i, j;
for(j=0, i=(pimage-buffer)+size; i<length; i++, j++){
buf_video.data[j] = buf_video.data[i];
}
buf_video.size = j;
#endif
return 0;
}
return 3;
}