MJPEG 转JPEG代码

最近在做usb摄像头的开发，发现usb摄像头出来的是MJPEG格式的，找了很久都没有找到简单的转码方法。后来以“AVI1”和“MJPEG”作为关键字google了一下（在MJPEG帧里面发现开头对应JFIF的位置有AVI1的关键字，现在也依然不太明白是什么意思），发现了一个开源的视频处理库ffmpg，里面有一个mjpeg2jpeg.c的文件。我将这段代码改了一下，发现可以工作，现在把 这段代码共享一下，希望高手可以指导一下

#include
#include
#include
#include


uint8_t mjpeg[100000];
uint8_t jpeg[100000];


static const  uint8_t jpeg_header[] = {
0xff, 0xd8,                     // SOI
0xff, 0xe0,                     // APP0
0x00, 0x10,                     // APP0 header size (including
// this field, but excluding preceding)
0x4a, 0x46, 0x49, 0x46, 0x00,   // ID string 'JFIF\0'
0x01, 0x01,                     // version
0x00,                           // bits per type
0x00, 0x00,                     // X density
0x00, 0x00,                     // Y density
0x00,                           // X thumbnail size
0x00,                           // Y thumbnail size
};


static const int dht_segment_size = 420;
static const  uint8_t dht_segment_head[] = { 0xFF, 0xC4, 0x01, 0xA2, 0x00 };
static const  uint8_t dht_segment_frag[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
0x0a, 0x0b, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
};


/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
/* IMPORTANT: these are only valid for 8-bit data precision! */
const  uint8_t avpriv_mjpeg_bits_dc_luminance[17] =
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
const  uint8_t avpriv_mjpeg_val_dc[12] =
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };


const  uint8_t avpriv_mjpeg_bits_dc_chrominance[17] =
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };


const  uint8_t avpriv_mjpeg_bits_ac_luminance[17] =
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
const  uint8_t avpriv_mjpeg_val_ac_luminance[] =
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa
};


const  uint8_t avpriv_mjpeg_bits_ac_chrominance[17] =
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };


const  uint8_t avpriv_mjpeg_val_ac_chrominance[] =
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa
};


static  uint8_t *append( uint8_t *buf, const  uint8_t *src, int size)
{
memcpy(buf, src, size);
return buf + size;
}


static  uint8_t *append_dht_segment( uint8_t *buf)
{
buf = append(buf, dht_segment_head, sizeof(dht_segment_head));
buf = append(buf, avpriv_mjpeg_bits_dc_luminance + 1, 16);
buf = append(buf, dht_segment_frag, sizeof(dht_segment_frag));
buf = append(buf, avpriv_mjpeg_val_dc, 12);
*(buf++) = 0x10;
buf = append(buf, avpriv_mjpeg_bits_ac_luminance + 1, 16);
buf = append(buf, avpriv_mjpeg_val_ac_luminance, 162);
*(buf++) = 0x11;
buf = append(buf, avpriv_mjpeg_bits_ac_chrominance + 1, 16);
buf = append(buf, avpriv_mjpeg_val_ac_chrominance, 162);
return buf;
}



static int mjpeg2jpeg_filter( uint8_t **poutbuf, int *poutbuf_size,
const  uint8_t *buf, int buf_size)
{
int input_skip, output_size;
uint8_t *output, *out;
int i;
FILE *test_mjpeg;
FILE *test_jpeg;


test_mjpeg = fopen("/tmp/test_frame25.txt","wb+");
test_jpeg  = fopen("/tmp/test_frame25_jpeg.txt","wb+");


if (buf_size < 12) {
printf( "input is truncated\n");
return 0 ;
}
if (memcmp("AVI1", buf + 6, 4)) {
printf(  "input is not MJPEG/AVI1\n");
return 0;
}
input_skip = (buf[4] << 8) + buf[5] + 4;
if (buf_size < input_skip) {
printf(  "input is truncated\n");
return 0;
}
output_size = buf_size - input_skip +
sizeof(jpeg_header) + dht_segment_size;
output = out =( uint8_t*) malloc(output_size);
if (!output)
return 0 ;
out = append(out, jpeg_header, sizeof(jpeg_header));
out = append_dht_segment(out);
out = append(out, buf + input_skip, buf_size - input_skip);


for(i=0 ; isprintf(mjpeg,"%s%x",mjpeg,*( uint8_t*)(buf+input_skip+i));
}
for(i=0 ; isprintf(jpeg,"%s%x",jpeg,*( uint8_t*)(output+sizeof(jpeg_header) + dht_segment_size+i));
}
fwrite(mjpeg,buf_size-input_skip,1,test_mjpeg);
fwrite(jpeg,buf_size-input_skip,1,test_jpeg);




fclose(test_mjpeg);
fclose(test_jpeg);
*poutbuf = output;
*poutbuf_size = output_size;
return 1;
}


int main(int argc, char* argv[])
{


FILE *mjpeg_frame;
FILE *test_mjpeg_frame;
FILE *jpeg_frame;
uint8_t *mjpeg_buf;
uint8_t *jpeg_buf;
int jpeg_len;
long file_len;
long current_pos;
int status;
int actual_read_len;
mjpeg_frame = fopen("/tmp/frame25.txt","r");
jpeg_frame  = fopen("/tmp/frame25_jpeg.txt","wb+");
test_mjpeg_frame = fopen("/tmp/test_frame25_mjpeg.txt","wb+");
current_pos = ftell(mjpeg_frame);
fseek(mjpeg_frame,0,SEEK_END);
file_len = ftell(mjpeg_frame);
fseek(mjpeg_frame,current_pos,SEEK_SET);
printf("the file length is %d\n",file_len);


mjpeg_buf =( uint8_t*) malloc(file_len);
actual_read_len = fread(mjpeg_buf,file_len,1,mjpeg_frame);
printf("the actually read length is %d\n",actual_read_len);


status = mjpeg2jpeg_filter(&jpeg_buf , &jpeg_len , mjpeg_buf , file_len);
printf("the transfer result is %d\n",status);
fwrite(jpeg_buf,jpeg_len,1,jpeg_frame);
fwrite(mjpeg_buf,file_len,1,test_mjpeg_frame);




fclose(jpeg_frame);
fclose(mjpeg_frame);
free(mjpeg_buf);
free(jpeg_buf);
getchar();
return 0;
}