资源简介
rgb编码成jpeg,验证通过的
/******************************************************************************
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright (c) 2003 Intel Corporation. All Rights Reserved.
//
// Description:
// Intel(R) Integrated Performance Primitives Sample Code JPEG Encoder
//
******************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "sampjpeg.h"
/******************************************************************************
// Name: encoder_init_alloc_jpeg
// Description:
// This function does the prepare work for the JPEG encoding, including:1.
// Parse BMP header; 2. Read in the BMP data; 3 Convert the BGR data into
// YUV format. 4. Load the table for quantization and huffman encoding.
// Input Arguments:
// src - File Pointer to the source BMP file
// quality_ind - Quality indicator. 1: high quality; 0: low quality
// Output Arguments:
// enc_state - Pointer to the encoder state structure, its content
// will be initialized in this function
// picture - Pointer to the source picture in YUV format. The buffer
// in it will be allocated and filled with YUV data in this
// function.
// bitstream - Pointer to the output JPEG bitstream. Its buffers will
// be allocated in this function.
// Returns:
// SAMPLE_STATUS_NOERR - No error
// SAMPLE_STATUS_NOMEM_ERR - Memory error
// SAMPLE_STATUS_NOTSUPPORTED_ERR - Not supported input
// SAMPLE_STATUS_ERR - Other errors
******************************************************************************/
sample_status encoder_init_alloc_jpeg(FILE *src, int quality_ind,
jpeg_enc_state *enc_state,
sample_picture *picture,
sample_bitstream *bitstream)
{
int data_size;
int x_num, y_num;
int i, j;
int num_bytes;
void *rgb_buffer = NULL;
void *src_buf, *buf;
Ipp16s *dst_buf[3];
int yuv_size;
int color_mode;
int data32;
short *buffer;
sample_status status;
Ipp8u *quant_table1, *table1;
Ipp8u *quant_table2, *table2;
/* Read the BMP file for format information */
status = read_bmp_file(src, enc_state, &color_mode, &data_size);
if(SAMPLE_STATUS_NOERR != status) {
return status;
}
/* Malloc the buffer for RGB data */
if(JPEG_BGR888 == color_mode) {
rgb_buffer = (Ipp8u *)malloc(data_size 7);
num_bytes = 3;
} else {
rgb_buffer = (Ipp16u *)malloc(data_size 7);
num_bytes = 2;
}
if(rgb_buffer == NULL) {
return SAMPLE_STATUS_NOMEM_ERR;
}
src_buf = (int *)SAMPLE_ALIGN8(rgb_buffer);
data32 = fread(src_buf, 1, data_size, src);
if(data32 != data_size) {
return SAMPLE_STATUS_ERR;
}
/* Malloc the buffer for Y, Cb, Cr */
yuv_size = enc_state->width * enc_state->height;
yuv_size = yuv_size (yuv_size >> 1);
/*
// Malloc the buffer for encoder input and output.
// Half of the buffer is used for YUV, another half is used for
// Output bitstream;
*/
enc_state->in_buf = NULL;
enc_state->out_buf = NULL;
enc_state->in_buf = (short *)malloc(yuv_size * 2);
buffer = (short *)SAMPLE_ALIGN8(enc_state->in_buf);
/* Initialize the input structure */
picture->pic_plane[0] = buffer;
picture->pic_width = enc_state->width;
picture->pic_height = enc_state->height;
picture->pic_plane_step[0] = enc_state->width;
picture->pic_plane_num = 1;
/*
// Assign the buffer for encoder ouput bitstream
// It is assumed that the output size will not be larger than
// input size a lot
*/
enc_state->out_buf = (short *)malloc(yuv_size * 3);
buffer = enc_state->out_buf;
bitstream->bs_buffer = (unsigned char *)buffer;
bitstream->bs_bytelen = yuv_size * 3;
bitstream->bs_cur_byte = bitstream->bs_buffer;
bitstream->bs_cur_bitoffset = 0;
/*
// Check if the picture width and height is multiple of 16, if not,
// return not supported information
*/
if(enc_state->width & 0xf) {
return SAMPLE_STATUS_NOTSUPPORTED_ERR;
}
if(enc_state->height & 0xf) {
return SAMPLE_STATUS_NOTSUPPORTED_ERR;
}
/* Do the color conversion, from BGR to Y:U:V = 4:1:1 */
/*
// x_num is the horizontal MCU number.
// x_num = width / 16
// y_num is the vertical MCU number
// y_num = height / 16;
*/
x_num = enc_state->width >> 4;
y_num = enc_state->height >> 4;
/* Jump to the last MCU line */
src_buf = (char *)src_buf (y_num * JPEG_MCU_LINE - 1) * enc_state->step;
buf = src_buf;
/* Prepare the Y, U, V block pointer */
dst_buf[0] = picture->pic_plane[0];
dst_buf[1] = dst_buf[0] (64 << 2);
dst_buf[2] = dst_buf[1] 64;
for(i = 0; i < y_num; i ) {
src_buf = buf;
for(j = 0; j < x_num; j ) {
if(JPEG_BGR888 == color_mode) {
ippiBGRToYCbCr411LS_MCU_8u16s_C3P3R((Ipp8u *)src_buf,
-(enc_state->step), dst_buf);
/* Move to next MCU */
src_buf = (char *)src_buf JPEG_MCU_LINE * num_bytes;
dst_buf[0] = 6 * JPEG_BLOCK_SIZE;
dst_buf[1] = 6 * JPEG_BLOCK_SIZE;
dst_buf[2] = 6 * JPEG_BLOCK_SIZE;
} else if (JPEG_BGR555 == color_mode) {
ippiBGR555ToYCbCr411LS_MCU_16u16s_C3P3R((const Ipp16u *)src_buf,
-(enc_state->step),
dst_buf);
/* Move to next MCU */
src_buf = (char *)src_buf JPEG_MCU_LINE * num_bytes;
dst_buf[0] = 6 * JPEG_BLOCK_SIZE;
dst_buf[1] = 6 * JPEG_BLOCK_SIZE;
dst_buf[2] = 6 * JPEG_BLOCK_SIZE;
} else {
ippiBGR565ToYCbCr411LS_MCU_16u16s_C3P3R((const Ipp16u *)src_buf,
-(enc_state->step), dst_buf);
/* Move to next MCU */
src_buf = (char *)src_buf JPEG_MCU_LINE * num_bytes;
dst_buf[0] = 6 * JPEG_BLOCK_SIZE;
dst_buf[1] = 6 * JPEG_BLOCK_SIZE;
dst_buf[2] = 6 * JPEG_BLOCK_SIZE;
}
}
/* Move to next line of slice */
buf = (char *)buf - JPEG_MCU_LINE * enc_state->step;
}
enc_state->color_mode = color_mode;
/*
// Notes:
// In above code, because the input BMP file is stored up-bottom
// inverted, so the src_buf storage order is also inverted. To make
// it normal, the color conversion begins from the buffer end, and
// step back to the buffer beginning. After the color conversion,
// the pixel in the dst_buf is in normal up-down order.
// Besides, the dst_buf contains the components in order of:
// Y block, Y block, Y block, Y block, U block, V block
*/
free(rgb_buffer); /* This buffer is no longer in use */
/* Set the quality indicator */
enc_state->quality = quality_ind;
/* Load the quantization table according to the quality indication*/
/*
// Because of the DCT and quantization are integrated to enhance the
// performance, the raw quantization tables must be modified by the
// DCT coefficients.
*/
/*
// The quality is indicated by quality_ind, its values can be:
// 1: high quality encoding; 0: low quality encoding
*/
quant_table1 = malloc((JPEG_BLOCK_SIZE 4) * 2);
table1 = (Ipp8u *)SAMPLE_ALIGN8(quant_table1);
quant_table2 = malloc((JPEG_BLOCK_SIZE 4)* 2);
table2 = (Ipp8u *)SAMPLE_ALIGN8(quant_table2);
if(1 == quality_ind) {
for(i = 0; i < 64; i ) {
table1[i] = h_lum_quant_table[i];
table2[i] = h_chrom_quant_table[i];
}
} else {
for(i = 0; i < 64; i ) {
table1[i] = l_lum_quant_table[i];
table2[i] = l_chrom_quant_table[i];
}
}
ippiDCTQuantFwdTableInit_JPEG_8u16u(table1,
(Ipp16u *)SAMPLE_ALIGN8(enc_state->lum_quant_table));
ippiDCTQuantFwdTableInit_JPEG_8u16u(table2,
(Ipp16u *)SAMPLE_ALIGN8(enc_state->chrom_quant_table));
free(quant_table1);
free(quant_table2);
/* Load and init the huffman table, use the default huffman table */
ippiEncodeHuffmanSpecInit_JPEG_8u(lum_dc_huffbits, lum_dc_huffvalues,
&(enc_state->lum_dc_huffmansize_table));
ippiEncodeHuffmanSpecInit_JPEG_8u(lum_ac_huffbits, lum_ac_huffvalues,
&(enc_state->lum_ac_huffmansize_table));
ippiEncodeHuffmanSpecInit_JPEG_8u(chrom_dc_huffbits, chrom_dc_huffvalues,
&(enc_state->chrom_dc_huffmansize_table));
ippiEncodeHuffmanSpecInit_JPEG_8u(chrom_ac_huffbits, chrom_ac_huffvalues,
&(enc_state->chrom_ac_huffmansize_table));
/*
// Allocate the work buffer, this work buffer will be used as temporary
// buffer for DCT-quantization output and huffman encoding input
*/
enc_state->work_buf = NULL;
enc_state->work_buf = (short *)malloc((JPEG_MCU_SIZE 7) * 2);
/* Reset the DC prediction value */
for(i = 0; i < 3; i ) {
enc_state->dc_pred[i] = 0;
}
return SAMPLE_STATUS_NOERR;
}
/******************************************************************************
// Name: encode_jpeg
// Description:
// This function encodes the input YUV data into JPEG format bitstream.
// Input Arguments:
// src_picture - Pointer to the source picture in YUV format.
// enc_state - Pointer to the encoder state structure.
// Output Arguments:
// dst_stream - Pointer to the output JPEG bitstream.
// Returns
// SAMPLE_STATUS_NOERR - No error
******************************************************************************/
sample_status encode_jpeg(sample_picture *src_picture,
sample_bitstream *dst_stream,
jpeg_enc_state *enc_state)
{
int i, j;
int x_num;
int y_num;
short *tmp_buf;
short *in_buf;
int used_bits_len = 0;
int used_byte_len;
/* Write the head of JPEG */
write_head_information(dst_stream, enc_state);
/* Put the SOS and the table information into the bitstream */
write_sos_information(dst_stream);
/* Compute the MCU number in x and y direction */
x_num = enc_state->width >> 4;
y_num = enc_state->height >> 4;
tmp_buf = (Ipp16s *)SAMPLE_ALIGN8(enc_state->work_buf);
in_buf = src_picture->pic_plane[0];
for(i = 0; i < y_num; i ) {
for(j = 0; j < x_num; j ) {
/* First, the DCT transformation will be called followed by
the quantization */
/*
// The DCT and quantization are performed on each Y block and Cb,
// Cr block. For this program only support Y:Cb:Cr = 4:1:1 mode.
// There will be 6 DCT-quantization operations for each MCU
*/
/* DCT-quantization for 4 Y blocks */
ippiDCTQuantFwd_JPEG_16s(in_buf, tmp_buf,
(Ipp16u *)SAMPLE_ALIGN8(enc_state->lum_quant_table));
ippiDCTQuantFwd_JPEG_16s(&in_buf[64], &tmp_buf[64],
(Ipp16u *)SAMPLE_ALIGN8(enc_state->lum_quant_table));
ippiDCTQuantFwd_JPEG_16s(&in_buf[128], &tmp_buf[128],
(Ipp16u *)SAMPLE_ALIGN8(enc_state->lum_quant_table));
ippiDCTQuantFwd_JPEG_16s(&in_buf[192], &tmp_buf[192],
(Ipp16u *)SAMPLE_ALIGN8(enc_state->lum_quant_table));
/* DCT-quantization for Cb block */
ippiDCTQuantFwd_JPEG_16s(&in_buf[256], &tmp_buf[256],
(Ipp16u *)SAMPLE_ALIGN8(enc_state->chrom_quant_table));
/* DCT-quantization for Cr block */
ippiDCTQuantFwd_JPEG_16s(&in_buf[320], &tmp_buf[320],
(Ipp16u *)SAMPLE_ALIGN8(enc_state->chrom_quant_table));
in_buf = JPEG_MCU_SIZE;
/* Now huffman encode the quantized coefficient */
/* First encode the 4 luminance(Y) blocks */
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (tmp_buf,
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[0]),
&(enc_state->lum_dc_huffmansize_table),
&(enc_state->lum_ac_huffmansize_table));
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (&tmp_buf[64],
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[0]),
&(enc_state->lum_dc_huffmansize_table),
&(enc_state->lum_ac_huffmansize_table));
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (&tmp_buf[128],
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[0]),
&(enc_state->lum_dc_huffmansize_table),
&(enc_state->lum_ac_huffmansize_table));
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (&tmp_buf[192],
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[0]),
&(enc_state->lum_dc_huffmansize_table),
&(enc_state->lum_ac_huffmansize_table));
/* Huffman encode the chrominance(Cb) block */
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (&tmp_buf[256],
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[1]),
&(enc_state->chrom_dc_huffmansize_table),
&(enc_state->chrom_ac_huffmansize_table));
/* Huffman encode the chrominance(Cr) block */
ippiEncodeHuffman8x8_Direct_JPEG_16s1u_C1 (&tmp_buf[320],
dst_stream->bs_cur_byte,
&used_bits_len,
&(enc_state->dc_pred[2]),
&(enc_state->chrom_dc_huffmansize_table),
&(enc_state->chrom_ac_huffmansize_table));
}
}
/* Put EOI mark to the end of stream */
used_byte_len = used_bits_len >> 3;
/*
// Check if the last byte is completely filled, if not, stuff it and move
// to the next byte for writing
*/
if(used_bits_len & 0x7) {
used_byte_len = 1;
}
dst_stream->bs_cur_byte = used_byte_len;
*dst_stream->bs_cur_byte = 0xff; /* Write the high part of EOI */
*dst_stream->bs_cur_byte = JPEG_MARKER_EOI;
return SAMPLE_STATUS_NOERR;
}
/******************************************************************************
// Name: encoder_free_jpeg
// Description:
// This function free the buffer malloced in the initialization function
// Input arguments:
// enc_state - Pointer to the JPEG encoder structure
// Returns:
// SAMPLE_STATUS_NOERR - No error
******************************************************************************/
sample_status encoder_free_jpeg(jpeg_enc_state *enc_state)
{
if(NULL != enc_state->in_buf) {
free(enc_state->in_buf);
}
enc_state->in_buf = NULL;
if(NULL != enc_state->out_buf) {
free(enc_state->out_buf);
}
enc_state->out_buf = NULL;
if(NULL != enc_state->work_buf) {
free(enc_state->work_buf);
}
enc_state->work_buf = NULL;
return SAMPLE_STATUS_NOERR;
}
/* EOF */
代码片段和文件信息
/******************************************************************************
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright （c） 2003 Intel Corporation. All Rights Reserved.
//
// Description:
// Intel（R） Integrated Performance Primitives Sample Code JPEG Encoder
//
******************************************************************************/
#include
#include
#include “sampjpeg.h“
/******************************************************************************
// Name: encoder_init_alloc_jpeg
// Description:
// This function does the prepare work for the JPEG encoding including:1.
// Parse BMP header; 2. Read in the BMP data; 3 Convert the BGR data into
// YUV format. 属性 大小 日期 时间 名称
----------- --------- ---------- ----- ----
文件 15282 2005-09-29 10:30 jpeg_encode\jpgenc.c
文件 11711 2005-09-29 10:30 jpeg_encode\jpgmain.c
文件 18186 2005-09-29 10:30 jpeg_encode\jpgmisc.c
文件 5986 2005-09-29 10:30 jpeg_encode\jpgtab.c
文件 11709 2014-07-02 10:22 jpeg_encode\sampjpeg.h
目录 0 2014-07-02 10:02 jpeg_encode\
- 上一篇：单片机开发
- 下一篇：STM32开发板实验指导1
相关资源
- stm32编码器
- 编码及转码（libiconv库）
-
C++ ba
se64编码（提高篇-560）.zip - C编码规范.pdf
- 哈夫曼编码（c++实现）
- h.264编解码程序
- C和C++安全编码（中文版）
- 香农编码 哈夫曼编码 信息论期中作业
- 利用LT码编码并译码一段字符
- C++编码规范
- 26个大写字符和空格的Huffman编码
- 数据压缩试验指导书LZW、算术编码、
- 哈夫曼树的编码与译码包含文件输入
- 霍夫曼编码 C语言实现
- hdb3编码的C语言编码
- huffmantree对英文短文编码，译码
- lz78压缩编码论文及源代码
- CVSD编解码
- 哈夫曼编码器c代码
- c++ 图像中值梯度锐化、拉普拉斯锐化
- C++实现香农编码
- huffman算法源码
- MFC下的哈夫曼编码及应用
- C++自适应编码
- C++设计游程编码
- Huffman课程设计
- C语言编码哈夫曼树
- 用C++做的霍夫曼编码
- 几种编码的相互转换
- Huffman文件压缩解压缩-C语言-数据结构
评论
共有 条评论