| /* |
| * Copyright (c) 2014 Intel Corporation. All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| /* |
| * Simple JPEG encoder based on libVA. |
| * |
| * Usage: |
| * ./jpegenc <width> <height> <input file> <output file> <input filetype 0(I420)/1(NV12)/2(UYVY)/3(YUY2)/4(Y8)/5(RGBA)> q <quality> |
| * Currently supporting only I420/NV12/UYVY/YUY2/Y8 input file formats. |
| * |
| * NOTE: The intel-driver expects a packed header sent to it. So, the app is responsible to pack the header |
| * and send to the driver through LibVA. This unit test also showcases how to send the header to the driver. |
| */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <getopt.h> |
| #include <unistd.h> |
| |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <assert.h> |
| #include <time.h> |
| |
| #include <pthread.h> |
| |
| #include <va/va.h> |
| #include <va/va_enc_jpeg.h> |
| #include "va_display.h" |
| #include "jpegenc_utils.h" |
| |
| #ifndef VA_FOURCC_I420 |
| #define VA_FOURCC_I420 0x30323449 |
| #endif |
| |
| #define CHECK_VASTATUS(va_status,func) \ |
| if (va_status != VA_STATUS_SUCCESS) { \ |
| fprintf(stderr,"%s:%s (%d) failed,exit\n", __func__, func, __LINE__); \ |
| exit(1); \ |
| } |
| |
| |
| void show_help() |
| { |
| printf("Usage: ./jpegenc <width> <height> <input file> <output file> <fourcc value 0(I420)/1(NV12)/2(UYVY)/3(YUY2)/4(Y8)/5(RGBA)> q <quality>\n"); |
| printf("Currently supporting only I420/NV12/UYVY/YUY2/Y8 input file formats.\n"); |
| printf("Example: ./jpegenc 1024 768 input_file.yuv output.jpeg 0 50\n\n"); |
| return; |
| } |
| |
| |
| void jpegenc_pic_param_init(VAEncPictureParameterBufferJPEG *pic_param,int width,int height,int quality, YUVComponentSpecs yuvComp) |
| { |
| assert(pic_param); |
| |
| pic_param->picture_width = width; |
| pic_param->picture_height = height; |
| pic_param->quality = quality; |
| |
| pic_param->pic_flags.bits.profile = 0; //Profile = Baseline |
| pic_param->pic_flags.bits.progressive = 0; //Sequential encoding |
| pic_param->pic_flags.bits.huffman = 1; //Uses Huffman coding |
| pic_param->pic_flags.bits.interleaved = 0; //Input format is interleaved (YUV) |
| pic_param->pic_flags.bits.differential = 0; //non-Differential Encoding |
| |
| pic_param->sample_bit_depth = 8; //only 8 bit sample depth is currently supported |
| pic_param->num_scan = 1; |
| pic_param->num_components = yuvComp.num_components; // Supporting only upto 3 components maximum |
| //set component_id Ci and Tqi |
| if(yuvComp.fourcc_val == VA_FOURCC_Y800) { |
| pic_param->component_id[0] = 0; |
| pic_param->quantiser_table_selector[0] = 0; |
| } else { |
| pic_param->component_id[0] = pic_param->quantiser_table_selector[0] = 0; |
| pic_param->component_id[1] = pic_param->quantiser_table_selector[1] = 1; |
| pic_param->component_id[2] = 2; pic_param->quantiser_table_selector[2] = 1; |
| } |
| |
| pic_param->quality = quality; |
| } |
| |
| void jpegenc_qmatrix_init(VAQMatrixBufferJPEG *quantization_param, YUVComponentSpecs yuvComp) |
| { |
| int i=0; |
| quantization_param->load_lum_quantiser_matrix = 1; |
| |
| //LibVA expects the QM in zigzag order |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| quantization_param->lum_quantiser_matrix[i] = jpeg_luma_quant[jpeg_zigzag[i]]; |
| } |
| |
| |
| if(yuvComp.fourcc_val == VA_FOURCC_Y800) { |
| quantization_param->load_chroma_quantiser_matrix = 0; |
| } else { |
| quantization_param->load_chroma_quantiser_matrix = 1; |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| quantization_param->chroma_quantiser_matrix[i] = jpeg_chroma_quant[jpeg_zigzag[i]]; |
| } |
| } |
| |
| } |
| |
| void jpegenc_hufftable_init(VAHuffmanTableBufferJPEGBaseline *hufftable_param, YUVComponentSpecs yuvComp) |
| { |
| |
| hufftable_param->load_huffman_table[0] = 1; //Load Luma Hufftable |
| if(yuvComp.fourcc_val == VA_FOURCC_Y800) { |
| hufftable_param->load_huffman_table[1] = 0; //Do not load Chroma Hufftable for Y8 |
| } else { |
| hufftable_param->load_huffman_table[1] = 1; //Load Chroma Hufftable for other formats |
| } |
| |
| //Load Luma hufftable values |
| //Load DC codes |
| memcpy(hufftable_param->huffman_table[0].num_dc_codes, jpeg_hufftable_luma_dc+1, 16); |
| //Load DC Values |
| memcpy(hufftable_param->huffman_table[0].dc_values, jpeg_hufftable_luma_dc+17, 12); |
| //Load AC codes |
| memcpy(hufftable_param->huffman_table[0].num_ac_codes, jpeg_hufftable_luma_ac+1, 16); |
| //Load AC Values |
| memcpy(hufftable_param->huffman_table[0].ac_values, jpeg_hufftable_luma_ac+17, 162); |
| memset(hufftable_param->huffman_table[0].pad, 0, 2); |
| |
| |
| //Load Chroma hufftable values if needed |
| if(yuvComp.fourcc_val != VA_FOURCC_Y800) { |
| //Load DC codes |
| memcpy(hufftable_param->huffman_table[1].num_dc_codes, jpeg_hufftable_chroma_dc+1, 16); |
| //Load DC Values |
| memcpy(hufftable_param->huffman_table[1].dc_values, jpeg_hufftable_chroma_dc+17, 12); |
| //Load AC codes |
| memcpy(hufftable_param->huffman_table[1].num_ac_codes, jpeg_hufftable_chroma_ac+1, 16); |
| //Load AC Values |
| memcpy(hufftable_param->huffman_table[1].ac_values, jpeg_hufftable_chroma_ac+17, 162); |
| memset(hufftable_param->huffman_table[1].pad, 0, 2); |
| |
| } |
| |
| } |
| |
| void jpegenc_slice_param_init(VAEncSliceParameterBufferJPEG *slice_param, YUVComponentSpecs yuvComp) |
| { |
| slice_param->restart_interval = 0; |
| |
| slice_param->num_components = yuvComp.num_components; |
| |
| slice_param->components[0].component_selector = 1; |
| slice_param->components[0].dc_table_selector = 0; |
| slice_param->components[0].ac_table_selector = 0; |
| |
| if(yuvComp.num_components > 1) { |
| slice_param->components[1].component_selector = 2; |
| slice_param->components[1].dc_table_selector = 1; |
| slice_param->components[1].ac_table_selector = 1; |
| |
| slice_param->components[2].component_selector = 3; |
| slice_param->components[2].dc_table_selector = 1; |
| slice_param->components[2].ac_table_selector = 1; |
| } |
| } |
| |
| |
| void populate_quantdata(JPEGQuantSection *quantVal, int type) |
| { |
| uint8_t zigzag_qm[NUM_QUANT_ELEMENTS]; |
| int i; |
| |
| quantVal->DQT = DQT; |
| quantVal->Pq = 0; |
| quantVal->Tq = type; |
| if(type == 0) { |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| zigzag_qm[i] = jpeg_luma_quant[jpeg_zigzag[i]]; |
| } |
| |
| memcpy(quantVal->Qk, zigzag_qm, NUM_QUANT_ELEMENTS); |
| } else { |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| zigzag_qm[i] = jpeg_chroma_quant[jpeg_zigzag[i]]; |
| } |
| memcpy(quantVal->Qk, zigzag_qm, NUM_QUANT_ELEMENTS); |
| } |
| quantVal->Lq = 3 + NUM_QUANT_ELEMENTS; |
| } |
| |
| void populate_frame_header(JPEGFrameHeader *frameHdr, YUVComponentSpecs yuvComp, int picture_width, int picture_height) |
| { |
| int i=0; |
| |
| frameHdr->SOF = SOF0; |
| frameHdr->Lf = 8 + (3 * yuvComp.num_components); //Size of FrameHeader in bytes without the Marker SOF |
| frameHdr->P = 8; |
| frameHdr->Y = picture_height; |
| frameHdr->X = picture_width; |
| frameHdr->Nf = yuvComp.num_components; |
| |
| for(i=0; i<yuvComp.num_components; i++) { |
| frameHdr->JPEGComponent[i].Ci = i+1; |
| |
| if(i == 0) { |
| frameHdr->JPEGComponent[i].Hi = yuvComp.y_h_subsample; |
| frameHdr->JPEGComponent[i].Vi = yuvComp.y_v_subsample; |
| frameHdr->JPEGComponent[i].Tqi = 0; |
| |
| } else { |
| //Analyzing the sampling factors for U/V, they are 1 for all formats except for Y8. |
| //So, it is okay to have the code below like this. For Y8, we wont reach this code. |
| frameHdr->JPEGComponent[i].Hi = yuvComp.u_h_subsample; |
| frameHdr->JPEGComponent[i].Vi = yuvComp.u_v_subsample; |
| frameHdr->JPEGComponent[i].Tqi = 1; |
| } |
| } |
| } |
| |
| void populate_huff_section_header(JPEGHuffSection *huffSectionHdr, int th, int tc) |
| { |
| int i=0, totalCodeWords=0; |
| |
| huffSectionHdr->DHT = DHT; |
| huffSectionHdr->Tc = tc; |
| huffSectionHdr->Th = th; |
| |
| if(th == 0) { //If Luma |
| |
| //If AC |
| if(tc == 1) { |
| memcpy(huffSectionHdr->Li, jpeg_hufftable_luma_ac+1, NUM_AC_RUN_SIZE_BITS); |
| memcpy(huffSectionHdr->Vij, jpeg_hufftable_luma_ac+17, NUM_AC_CODE_WORDS_HUFFVAL); |
| } |
| |
| //If DC |
| if(tc == 0) { |
| memcpy(huffSectionHdr->Li, jpeg_hufftable_luma_dc+1, NUM_DC_RUN_SIZE_BITS); |
| memcpy(huffSectionHdr->Vij, jpeg_hufftable_luma_dc+17, NUM_DC_CODE_WORDS_HUFFVAL); |
| } |
| |
| for(i=0; i<NUM_AC_RUN_SIZE_BITS; i++) { |
| totalCodeWords += huffSectionHdr->Li[i]; |
| } |
| |
| huffSectionHdr->Lh = 3 + 16 + totalCodeWords; |
| |
| } else { //If Chroma |
| //If AC |
| if(tc == 1) { |
| memcpy(huffSectionHdr->Li, jpeg_hufftable_chroma_ac+1, NUM_AC_RUN_SIZE_BITS); |
| memcpy(huffSectionHdr->Vij, jpeg_hufftable_chroma_ac+17, NUM_AC_CODE_WORDS_HUFFVAL); |
| } |
| |
| //If DC |
| if(tc == 0) { |
| memcpy(huffSectionHdr->Li, jpeg_hufftable_chroma_dc+1, NUM_DC_RUN_SIZE_BITS); |
| memcpy(huffSectionHdr->Vij, jpeg_hufftable_chroma_dc+17, NUM_DC_CODE_WORDS_HUFFVAL); |
| } |
| |
| } |
| } |
| |
| void populate_scan_header(JPEGScanHeader *scanHdr, YUVComponentSpecs yuvComp) |
| { |
| |
| scanHdr->SOS = SOS; |
| scanHdr->Ns = yuvComp.num_components; |
| |
| //Y Component |
| scanHdr->ScanComponent[0].Csj = 1; |
| scanHdr->ScanComponent[0].Tdj = 0; |
| scanHdr->ScanComponent[0].Taj = 0; |
| |
| if(yuvComp.num_components > 1) { |
| //U Component |
| scanHdr->ScanComponent[1].Csj = 2; |
| scanHdr->ScanComponent[1].Tdj = 1; |
| scanHdr->ScanComponent[1].Taj = 1; |
| |
| //V Component |
| scanHdr->ScanComponent[2].Csj = 3; |
| scanHdr->ScanComponent[2].Tdj = 1; |
| scanHdr->ScanComponent[2].Taj = 1; |
| } |
| |
| scanHdr->Ss = 0; //0 for Baseline |
| scanHdr->Se = 63; //63 for Baseline |
| scanHdr->Ah = 0; //0 for Baseline |
| scanHdr->Al = 0; //0 for Baseline |
| |
| scanHdr->Ls = 3 + (yuvComp.num_components * 2) + 3; |
| |
| } |
| |
| // This method packs the header information which is to be sent to the driver through LibVA. |
| // All the information that needs to be inserted in the encoded buffer should be built and sent. |
| // It is the responsibility of the app talking to LibVA to build this header and send it. |
| // This includes Markers, Quantization tables (normalized with quality factor), Huffman tables,etc. |
| int build_packed_jpeg_header_buffer(unsigned char **header_buffer, YUVComponentSpecs yuvComp, int picture_width, int picture_height, uint16_t restart_interval, int quality) |
| { |
| bitstream bs; |
| int i=0, j=0; |
| uint32_t temp=0; |
| |
| bitstream_start(&bs); |
| |
| //Add SOI |
| bitstream_put_ui(&bs, SOI, 16); |
| |
| //Add AppData |
| bitstream_put_ui(&bs, APP0, 16); //APP0 marker |
| bitstream_put_ui(&bs, 16, 16); //Length excluding the marker |
| bitstream_put_ui(&bs, 0x4A, 8); //J |
| bitstream_put_ui(&bs, 0x46, 8); //F |
| bitstream_put_ui(&bs, 0x49, 8); //I |
| bitstream_put_ui(&bs, 0x46, 8); //F |
| bitstream_put_ui(&bs, 0x00, 8); //0 |
| bitstream_put_ui(&bs, 1, 8); //Major Version |
| bitstream_put_ui(&bs, 1, 8); //Minor Version |
| bitstream_put_ui(&bs, 1, 8); //Density units 0:no units, 1:pixels per inch, 2: pixels per cm |
| bitstream_put_ui(&bs, 72, 16); //X density |
| bitstream_put_ui(&bs, 72, 16); //Y density |
| bitstream_put_ui(&bs, 0, 8); //Thumbnail width |
| bitstream_put_ui(&bs, 0, 8); //Thumbnail height |
| |
| // Regarding Quantization matrices: As per JPEG Spec ISO/IEC 10918-1:1993(E), Pg-19: |
| // "applications may specify values which customize picture quality for their particular |
| // image characteristics, display devices, and viewing conditions" |
| |
| |
| //Normalization of quality factor |
| quality = (quality < 50) ? (5000/quality) : (200 - (quality*2)); |
| |
| //Add QTable - Y |
| JPEGQuantSection quantLuma; |
| populate_quantdata(&quantLuma, 0); |
| |
| bitstream_put_ui(&bs, quantLuma.DQT, 16); |
| bitstream_put_ui(&bs, quantLuma.Lq, 16); |
| bitstream_put_ui(&bs, quantLuma.Pq, 4); |
| bitstream_put_ui(&bs, quantLuma.Tq, 4); |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| //scale the quantization table with quality factor |
| temp = (quantLuma.Qk[i] * quality)/100; |
| //clamp to range [1,255] |
| temp = (temp > 255) ? 255 : temp; |
| temp = (temp < 1) ? 1 : temp; |
| quantLuma.Qk[i] = (unsigned char)temp; |
| bitstream_put_ui(&bs, quantLuma.Qk[i], 8); |
| } |
| |
| //Add QTable - U/V |
| if(yuvComp.fourcc_val != VA_FOURCC_Y800) { |
| JPEGQuantSection quantChroma; |
| populate_quantdata(&quantChroma, 1); |
| |
| bitstream_put_ui(&bs, quantChroma.DQT, 16); |
| bitstream_put_ui(&bs, quantChroma.Lq, 16); |
| bitstream_put_ui(&bs, quantChroma.Pq, 4); |
| bitstream_put_ui(&bs, quantChroma.Tq, 4); |
| for(i=0; i<NUM_QUANT_ELEMENTS; i++) { |
| //scale the quantization table with quality factor |
| temp = (quantChroma.Qk[i] * quality)/100; |
| //clamp to range [1,255] |
| temp = (temp > 255) ? 255 : temp; |
| temp = (temp < 1) ? 1 : temp; |
| quantChroma.Qk[i] = (unsigned char)temp; |
| bitstream_put_ui(&bs, quantChroma.Qk[i], 8); |
| } |
| } |
| |
| //Add FrameHeader |
| JPEGFrameHeader frameHdr; |
| memset(&frameHdr,0,sizeof(JPEGFrameHeader)); |
| populate_frame_header(&frameHdr, yuvComp, picture_width, picture_height); |
| |
| bitstream_put_ui(&bs, frameHdr.SOF, 16); |
| bitstream_put_ui(&bs, frameHdr.Lf, 16); |
| bitstream_put_ui(&bs, frameHdr.P, 8); |
| bitstream_put_ui(&bs, frameHdr.Y, 16); |
| bitstream_put_ui(&bs, frameHdr.X, 16); |
| bitstream_put_ui(&bs, frameHdr.Nf, 8); |
| for(i=0; i<frameHdr.Nf;i++) { |
| bitstream_put_ui(&bs, frameHdr.JPEGComponent[i].Ci, 8); |
| bitstream_put_ui(&bs, frameHdr.JPEGComponent[i].Hi, 4); |
| bitstream_put_ui(&bs, frameHdr.JPEGComponent[i].Vi, 4); |
| bitstream_put_ui(&bs, frameHdr.JPEGComponent[i].Tqi, 8); |
| } |
| |
| //Add HuffTable AC and DC for Y,U/V components |
| JPEGHuffSection acHuffSectionHdr, dcHuffSectionHdr; |
| |
| for(i=0; (i<yuvComp.num_components && (i<=1)); i++) { |
| //Add DC component (Tc = 0) |
| populate_huff_section_header(&dcHuffSectionHdr, i, 0); |
| |
| bitstream_put_ui(&bs, dcHuffSectionHdr.DHT, 16); |
| bitstream_put_ui(&bs, dcHuffSectionHdr.Lh, 16); |
| bitstream_put_ui(&bs, dcHuffSectionHdr.Tc, 4); |
| bitstream_put_ui(&bs, dcHuffSectionHdr.Th, 4); |
| for(j=0; j<NUM_DC_RUN_SIZE_BITS; j++) { |
| bitstream_put_ui(&bs, dcHuffSectionHdr.Li[j], 8); |
| } |
| |
| for(j=0; j<NUM_DC_CODE_WORDS_HUFFVAL; j++) { |
| bitstream_put_ui(&bs, dcHuffSectionHdr.Vij[j], 8); |
| } |
| |
| //Add AC component (Tc = 1) |
| populate_huff_section_header(&acHuffSectionHdr, i, 1); |
| |
| bitstream_put_ui(&bs, acHuffSectionHdr.DHT, 16); |
| bitstream_put_ui(&bs, acHuffSectionHdr.Lh, 16); |
| bitstream_put_ui(&bs, acHuffSectionHdr.Tc, 4); |
| bitstream_put_ui(&bs, acHuffSectionHdr.Th, 4); |
| for(j=0; j<NUM_AC_RUN_SIZE_BITS; j++) { |
| bitstream_put_ui(&bs, acHuffSectionHdr.Li[j], 8); |
| } |
| |
| for(j=0; j<NUM_AC_CODE_WORDS_HUFFVAL; j++) { |
| bitstream_put_ui(&bs, acHuffSectionHdr.Vij[j], 8); |
| } |
| |
| if(yuvComp.fourcc_val == VA_FOURCC_Y800) |
| break; |
| } |
| |
| //Add Restart Interval if restart_interval is not 0 |
| if(restart_interval != 0) { |
| JPEGRestartSection restartHdr; |
| restartHdr.DRI = DRI; |
| restartHdr.Lr = 4; |
| restartHdr.Ri = restart_interval; |
| |
| bitstream_put_ui(&bs, restartHdr.DRI, 16); |
| bitstream_put_ui(&bs, restartHdr.Lr, 16); |
| bitstream_put_ui(&bs, restartHdr.Ri, 16); |
| } |
| |
| //Add ScanHeader |
| JPEGScanHeader scanHdr; |
| populate_scan_header(&scanHdr, yuvComp); |
| |
| bitstream_put_ui(&bs, scanHdr.SOS, 16); |
| bitstream_put_ui(&bs, scanHdr.Ls, 16); |
| bitstream_put_ui(&bs, scanHdr.Ns, 8); |
| |
| for(i=0; i<scanHdr.Ns; i++) { |
| bitstream_put_ui(&bs, scanHdr.ScanComponent[i].Csj, 8); |
| bitstream_put_ui(&bs, scanHdr.ScanComponent[i].Tdj, 4); |
| bitstream_put_ui(&bs, scanHdr.ScanComponent[i].Taj, 4); |
| } |
| |
| bitstream_put_ui(&bs, scanHdr.Ss, 8); |
| bitstream_put_ui(&bs, scanHdr.Se, 8); |
| bitstream_put_ui(&bs, scanHdr.Ah, 4); |
| bitstream_put_ui(&bs, scanHdr.Al, 4); |
| |
| bitstream_end(&bs); |
| *header_buffer = (unsigned char *)bs.buffer; |
| |
| return bs.bit_offset; |
| } |
| |
| //Upload the yuv image from the file to the VASurface |
| void upload_yuv_to_surface(VADisplay va_dpy, FILE *yuv_fp, VASurfaceID surface_id, YUVComponentSpecs yuvComp, int picture_width, int picture_height, int frame_size) |
| { |
| |
| VAImage surface_image; |
| VAStatus va_status; |
| void *surface_p = NULL; |
| unsigned char newImageBuffer[frame_size]; |
| unsigned char *y_src, *u_src, *v_src; |
| unsigned char *y_dst, *u_dst; |
| int y_size = picture_width * picture_height; |
| int u_size = 0; |
| int row, col; |
| size_t n_items; |
| |
| //u_size is used for I420, NV12 formats only |
| u_size = ((picture_width >> 1) * (picture_height >> 1)); |
| |
| memset(newImageBuffer,0,frame_size); |
| do { |
| n_items = fread(newImageBuffer, frame_size, 1, yuv_fp); |
| } while (n_items != 1); |
| |
| va_status = vaDeriveImage(va_dpy, surface_id, &surface_image); |
| CHECK_VASTATUS(va_status,"vaDeriveImage"); |
| |
| vaMapBuffer(va_dpy, surface_image.buf, &surface_p); |
| assert(VA_STATUS_SUCCESS == va_status); |
| |
| y_src = newImageBuffer; |
| u_src = newImageBuffer + y_size; /* UV offset for NV12 */ |
| v_src = newImageBuffer + y_size + u_size; |
| |
| y_dst = surface_p + surface_image.offsets[0]; |
| u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */ |
| |
| if((yuvComp.fourcc_val == VA_FOURCC_NV12) || (yuvComp.fourcc_val == VA_FOURCC_I420) || |
| (yuvComp.fourcc_val == VA_FOURCC_Y800) ) { |
| |
| /* Y plane */ |
| for (row = 0; row < surface_image.height; row++) { |
| memcpy(y_dst, y_src, surface_image.width); |
| y_dst += surface_image.pitches[0]; |
| y_src += picture_width; |
| } |
| |
| if(yuvComp.num_components > 1) { |
| |
| switch(yuvComp.fourcc_val) { |
| case VA_FOURCC_NV12: { |
| for (row = 0; row < surface_image.height/2; row++) { |
| memcpy(u_dst, u_src, surface_image.width); |
| u_dst += surface_image.pitches[1]; |
| u_src += (picture_width); |
| } |
| break; |
| } |
| |
| case VA_FOURCC_I420: { |
| for (row = 0; row < surface_image.height / 2; row++) { |
| for (col = 0; col < surface_image.width / 2; col++) { |
| u_dst[col * 2] = u_src[col]; |
| u_dst[col * 2 + 1] = v_src[col]; |
| } |
| |
| u_dst += surface_image.pitches[1]; |
| u_src += (picture_width / 2); |
| v_src += (picture_width / 2); |
| } |
| break; |
| } |
| }//end of switch |
| }//end of if check |
| } else if((yuvComp.fourcc_val == VA_FOURCC_UYVY) || (yuvComp.fourcc_val == VA_FOURCC_YUY2)) { |
| |
| for(row = 0; row < surface_image.height; row++) { |
| memcpy(y_dst, y_src, surface_image.width*2); |
| y_dst += surface_image.pitches[0]; |
| y_src += picture_width*2; |
| } |
| |
| } else if(yuvComp.fourcc_val == VA_FOURCC_RGBA) { |
| |
| for (row = 0; row < surface_image.height; row++) { |
| memcpy(y_dst, y_src, surface_image.width*4); |
| y_dst += surface_image.pitches[0]; |
| y_src += picture_width*4; |
| } |
| } |
| |
| vaUnmapBuffer(va_dpy, surface_image.buf); |
| vaDestroyImage(va_dpy, surface_image.image_id); |
| |
| } |
| |
| |
| |
| void init_yuv_component(YUVComponentSpecs *yuvComponent, int yuv_type, int *surface_type, VASurfaceAttrib *fourcc) |
| { |
| yuvComponent->yuv_type = yuv_type; |
| |
| //<fourcc value 0(I420)/1(NV12)/2(UYVY)/3(YUY2)/4(Y8)/5(RGBA)> |
| switch(yuv_type) |
| { |
| case 0 : //I420 |
| case 1 : { //NV12 |
| yuvComponent->va_surface_format = (*surface_type) = VA_RT_FORMAT_YUV420; |
| if(yuv_type == 0) { |
| yuvComponent->fourcc_val = VA_FOURCC_I420; |
| fourcc->value.value.i = VA_FOURCC_NV12; |
| } else { |
| yuvComponent->fourcc_val = fourcc->value.value.i = VA_FOURCC_NV12; |
| } |
| yuvComponent->num_components = 3; |
| yuvComponent->y_h_subsample = 2; |
| yuvComponent->y_v_subsample = 2; |
| yuvComponent->u_h_subsample = 1; |
| yuvComponent->u_v_subsample = 1; |
| yuvComponent->v_h_subsample = 1; |
| yuvComponent->v_v_subsample = 1; |
| break; |
| } |
| |
| case 2: { //UYVY |
| yuvComponent->va_surface_format = (*surface_type) = VA_RT_FORMAT_YUV422; |
| yuvComponent->fourcc_val = fourcc->value.value.i = VA_FOURCC_UYVY; |
| yuvComponent->num_components = 3; |
| yuvComponent->y_h_subsample = 2; |
| yuvComponent->y_v_subsample = 1; |
| yuvComponent->u_h_subsample = 1; |
| yuvComponent->u_v_subsample = 1; |
| yuvComponent->v_h_subsample = 1; |
| yuvComponent->v_v_subsample = 1; |
| break; |
| } |
| |
| case 3: { //YUY2 |
| yuvComponent->va_surface_format = (*surface_type) = VA_RT_FORMAT_YUV422; |
| yuvComponent->fourcc_val = fourcc->value.value.i = VA_FOURCC_YUY2; |
| yuvComponent->num_components = 3; |
| yuvComponent->y_h_subsample = 2; |
| yuvComponent->y_v_subsample = 1; |
| yuvComponent->u_h_subsample = 1; |
| yuvComponent->u_v_subsample = 1; |
| yuvComponent->v_h_subsample = 1; |
| yuvComponent->v_v_subsample = 1; |
| break; |
| } |
| |
| case 4: { //Y8 |
| yuvComponent->va_surface_format = (*surface_type) = VA_RT_FORMAT_YUV400; |
| yuvComponent->fourcc_val = fourcc->value.value.i = VA_FOURCC_Y800; |
| yuvComponent->num_components = 1; |
| yuvComponent->y_h_subsample = 1; |
| yuvComponent->y_v_subsample = 1; |
| yuvComponent->u_h_subsample = 0; |
| yuvComponent->u_v_subsample = 0; |
| yuvComponent->v_h_subsample = 0; |
| yuvComponent->v_v_subsample = 0; |
| break; |
| } |
| |
| case 5: { //RGBA |
| yuvComponent->va_surface_format = (*surface_type) = VA_RT_FORMAT_RGB32; |
| yuvComponent->fourcc_val = fourcc->value.value.i = VA_FOURCC_RGBA; |
| yuvComponent->num_components = 3; |
| yuvComponent->y_h_subsample = 1; |
| yuvComponent->y_v_subsample = 1; |
| yuvComponent->u_h_subsample = 1; |
| yuvComponent->u_v_subsample = 1; |
| yuvComponent->v_h_subsample = 1; |
| yuvComponent->v_v_subsample = 1; |
| break; |
| } |
| |
| default: { |
| printf("Unsupported format:\n"); |
| show_help(); |
| break; |
| } |
| |
| } |
| |
| } |
| |
| int encode_input_image(FILE *yuv_fp, FILE *jpeg_fp, int picture_width, int picture_height, int frame_size, int yuv_type, int quality) |
| { |
| int num_entrypoints,enc_entrypoint; |
| int major_ver, minor_ver; |
| int surface_type; |
| VAEntrypoint entrypoints[5]; |
| VASurfaceAttrib fourcc; |
| VAConfigAttrib attrib[2]; |
| VADisplay va_dpy; |
| VAStatus va_status; |
| VAConfigID config_id; |
| VASurfaceID surface_id; |
| VAContextID context_id; |
| VABufferID pic_param_buf_id; /* Picture parameter id*/ |
| VABufferID slice_param_buf_id; /* Slice parameter id, only 1 slice per frame in jpeg encode */ |
| VABufferID codedbuf_buf_id; /* Output buffer id, compressed data */ |
| VABufferID packed_raw_header_param_buf_id; /* Header parameter buffer id */ |
| VABufferID packed_raw_header_buf_id; /* Header buffer id */ |
| VABufferID qmatrix_buf_id; /* Quantization Matrix id */ |
| VABufferID huffmantable_buf_id; /* Huffman table id*/ |
| VAEncPictureParameterBufferJPEG pic_param; /* Picture parameter buffer */ |
| VAEncSliceParameterBufferJPEG slice_param; /* Slice parameter buffer */ |
| VAQMatrixBufferJPEG quantization_param; /* Quantization Matrix buffer */ |
| VAHuffmanTableBufferJPEGBaseline hufftable_param; /* Huffmantable buffer */ |
| YUVComponentSpecs yuvComponent; |
| int writeToFile = 1; |
| |
| //Clamp the quality factor value to [1,100] |
| if(quality >= 100) quality=100; |
| if(quality <= 0) quality=1; |
| |
| fourcc.type =VASurfaceAttribPixelFormat; |
| fourcc.flags=VA_SURFACE_ATTRIB_SETTABLE; |
| fourcc.value.type=VAGenericValueTypeInteger; |
| |
| init_yuv_component(&yuvComponent, yuv_type, &surface_type, &fourcc); |
| |
| /* 1. Initialize the va driver */ |
| va_dpy = va_open_display(); |
| va_status = vaInitialize(va_dpy, &major_ver, &minor_ver); |
| assert(va_status == VA_STATUS_SUCCESS); |
| |
| /* 2. Query for the entrypoints for the JPEGBaseline profile */ |
| va_status = vaQueryConfigEntrypoints(va_dpy, VAProfileJPEGBaseline, entrypoints, &num_entrypoints); |
| CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints"); |
| // We need picture level encoding (VAEntrypointEncPicture). Find if it is supported. |
| for (enc_entrypoint = 0; enc_entrypoint < num_entrypoints; enc_entrypoint++) { |
| if (entrypoints[enc_entrypoint] == VAEntrypointEncPicture) |
| break; |
| } |
| if (enc_entrypoint == num_entrypoints) { |
| /* No JPEG Encode (VAEntrypointEncPicture) entry point found */ |
| assert(0); |
| } |
| |
| /* 3. Query for the Render Target format supported */ |
| attrib[0].type = VAConfigAttribRTFormat; |
| attrib[1].type = VAConfigAttribEncJPEG; |
| vaGetConfigAttributes(va_dpy, VAProfileJPEGBaseline, VAEntrypointEncPicture, &attrib[0], 2); |
| |
| // RT should be one of below. |
| if(!((attrib[0].value & VA_RT_FORMAT_YUV420) || (attrib[0].value & VA_RT_FORMAT_YUV422) || (attrib[0].value & VA_RT_FORMAT_RGB32) |
| ||(attrib[0].value & VA_RT_FORMAT_YUV444) || (attrib[0].value & VA_RT_FORMAT_YUV400))) |
| { |
| /* Did not find the supported RT format */ |
| assert(0); |
| } |
| |
| VAConfigAttribValEncJPEG jpeg_attrib_val; |
| jpeg_attrib_val.value = attrib[1].value; |
| |
| /* Set JPEG profile attribs */ |
| jpeg_attrib_val.bits.arithmatic_coding_mode = 0; |
| jpeg_attrib_val.bits.progressive_dct_mode = 0; |
| jpeg_attrib_val.bits.non_interleaved_mode = 1; |
| jpeg_attrib_val.bits.differential_mode = 0; |
| |
| attrib[1].value = jpeg_attrib_val.value; |
| |
| /* 4. Create Config for the profile=VAProfileJPEGBaseline, entrypoint=VAEntrypointEncPicture, |
| * with RT format attribute */ |
| va_status = vaCreateConfig(va_dpy, VAProfileJPEGBaseline, VAEntrypointEncPicture, |
| &attrib[0], 2, &config_id); |
| CHECK_VASTATUS(va_status, "vaQueryConfigEntrypoints"); |
| |
| /* 5. Create Surface for the input picture */ |
| va_status = vaCreateSurfaces(va_dpy, surface_type, picture_width, picture_height, |
| &surface_id, 1, &fourcc, 1); |
| CHECK_VASTATUS(va_status, "vaCreateSurfaces"); |
| |
| //Map the input yuv file to the input surface created with the surface_id |
| upload_yuv_to_surface(va_dpy, yuv_fp, surface_id, yuvComponent, picture_width, picture_height, frame_size); |
| |
| /* 6. Create Context for the encode pipe*/ |
| va_status = vaCreateContext(va_dpy, config_id, picture_width, picture_height, |
| VA_PROGRESSIVE, &surface_id, 1, &context_id); |
| CHECK_VASTATUS(va_status, "vaCreateContext"); |
| |
| /* Create buffer for Encoded data to be stored */ |
| va_status = vaCreateBuffer(va_dpy, context_id, VAEncCodedBufferType, |
| frame_size, 1, NULL, &codedbuf_buf_id); |
| CHECK_VASTATUS(va_status,"vaCreateBuffer"); |
| |
| //Initialize the picture parameter buffer |
| pic_param.coded_buf = codedbuf_buf_id; |
| jpegenc_pic_param_init(&pic_param, picture_width, picture_height, quality, yuvComponent); |
| |
| /* 7. Create buffer for the picture parameter */ |
| va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType, |
| sizeof(VAEncPictureParameterBufferJPEG), 1, &pic_param, &pic_param_buf_id); |
| CHECK_VASTATUS(va_status,"vaCreateBuffer"); |
| |
| //Load the QMatrix |
| jpegenc_qmatrix_init(&quantization_param, yuvComponent); |
| |
| /* 8. Create buffer for Quantization Matrix */ |
| va_status = vaCreateBuffer(va_dpy, context_id, VAQMatrixBufferType, |
| sizeof(VAQMatrixBufferJPEG), 1, &quantization_param, &qmatrix_buf_id); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| //Load the Huffman Tables |
| jpegenc_hufftable_init(&hufftable_param, yuvComponent); |
| |
| /* 9. Create buffer for Huffman Tables */ |
| va_status = vaCreateBuffer(va_dpy, context_id, VAHuffmanTableBufferType, |
| sizeof(VAHuffmanTableBufferJPEGBaseline), 1, &hufftable_param, &huffmantable_buf_id); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| //Initialize the slice parameter buffer |
| jpegenc_slice_param_init(&slice_param, yuvComponent); |
| |
| /* 10. Create buffer for slice parameter */ |
| va_status = vaCreateBuffer(va_dpy, context_id, VAEncSliceParameterBufferType, |
| sizeof(slice_param), 1, &slice_param, &slice_param_buf_id); |
| CHECK_VASTATUS(va_status, "vaCreateBuffer"); |
| |
| //Pack headers and send using Raw data buffer |
| VAEncPackedHeaderParameterBuffer packed_header_param_buffer; |
| unsigned int length_in_bits; |
| unsigned char *packed_header_buffer = NULL; |
| |
| length_in_bits = build_packed_jpeg_header_buffer(&packed_header_buffer, yuvComponent, picture_width, picture_height, slice_param.restart_interval, quality); |
| packed_header_param_buffer.type = VAEncPackedHeaderRawData; |
| packed_header_param_buffer.bit_length = length_in_bits; |
| packed_header_param_buffer.has_emulation_bytes = 0; |
| |
| /* 11. Create raw buffer for header */ |
| va_status = vaCreateBuffer(va_dpy, |
| context_id, |
| VAEncPackedHeaderParameterBufferType, |
| sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer, |
| &packed_raw_header_param_buf_id); |
| CHECK_VASTATUS(va_status,"vaCreateBuffer"); |
| |
| va_status = vaCreateBuffer(va_dpy, |
| context_id, |
| VAEncPackedHeaderDataBufferType, |
| (length_in_bits + 7) / 8, 1, packed_header_buffer, |
| &packed_raw_header_buf_id); |
| CHECK_VASTATUS(va_status,"vaCreateBuffer"); |
| |
| /* 12. Begin picture */ |
| va_status = vaBeginPicture(va_dpy, context_id, surface_id); |
| CHECK_VASTATUS(va_status, "vaBeginPicture"); |
| |
| /* 13. Render picture for all the VA buffers created */ |
| va_status = vaRenderPicture(va_dpy,context_id, &pic_param_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &qmatrix_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &huffmantable_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &slice_param_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &packed_raw_header_param_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaRenderPicture(va_dpy,context_id, &packed_raw_header_buf_id, 1); |
| CHECK_VASTATUS(va_status, "vaRenderPicture"); |
| |
| va_status = vaEndPicture(va_dpy,context_id); |
| CHECK_VASTATUS(va_status, "vaEndPicture"); |
| |
| if (writeToFile) { |
| VASurfaceStatus surface_status; |
| size_t w_items; |
| VACodedBufferSegment *coded_buffer_segment; |
| unsigned char *coded_mem; |
| int slice_data_length; |
| |
| va_status = vaSyncSurface(va_dpy, surface_id); |
| CHECK_VASTATUS(va_status, "vaSyncSurface"); |
| |
| surface_status = 0; |
| va_status = vaQuerySurfaceStatus(va_dpy, surface_id, &surface_status); |
| CHECK_VASTATUS(va_status,"vaQuerySurfaceStatus"); |
| |
| va_status = vaMapBuffer(va_dpy, codedbuf_buf_id, (void **)(&coded_buffer_segment)); |
| CHECK_VASTATUS(va_status,"vaMapBuffer"); |
| |
| coded_mem = coded_buffer_segment->buf; |
| |
| if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) { |
| vaUnmapBuffer(va_dpy, codedbuf_buf_id); |
| printf("ERROR......Coded buffer too small\n"); |
| } |
| |
| |
| slice_data_length = coded_buffer_segment->size; |
| |
| do { |
| w_items = fwrite(coded_mem, slice_data_length, 1, jpeg_fp); |
| } while (w_items != 1); |
| |
| va_status = vaUnmapBuffer(va_dpy, codedbuf_buf_id); |
| CHECK_VASTATUS(va_status, "vaUnmapBuffer"); |
| } |
| |
| vaDestroyBuffer(va_dpy, pic_param_buf_id); |
| vaDestroyBuffer(va_dpy, qmatrix_buf_id); |
| vaDestroyBuffer(va_dpy, slice_param_buf_id); |
| vaDestroyBuffer(va_dpy, huffmantable_buf_id); |
| vaDestroyBuffer(va_dpy, codedbuf_buf_id); |
| vaDestroyBuffer(va_dpy, packed_raw_header_param_buf_id); |
| vaDestroyBuffer(va_dpy, packed_raw_header_buf_id); |
| vaDestroySurfaces(va_dpy,&surface_id,1); |
| vaDestroyContext(va_dpy,context_id); |
| vaDestroyConfig(va_dpy,config_id); |
| vaTerminate(va_dpy); |
| va_close_display(va_dpy); |
| |
| return 0; |
| } |
| |
| |
| int main(int argc, char *argv[]) |
| { |
| FILE *yuv_fp; |
| FILE *jpeg_fp; |
| off_t file_size; |
| clock_t start_time, finish_time; |
| unsigned int duration; |
| unsigned int yuv_type = 0; |
| int quality = 0; |
| unsigned int picture_width = 0; |
| unsigned int picture_height = 0; |
| unsigned int frame_size = 0; |
| |
| va_init_display_args(&argc, argv); |
| |
| if(argc != 7) { |
| show_help(); |
| return -1; |
| } |
| |
| picture_width = atoi(argv[1]); |
| picture_height = atoi(argv[2]); |
| yuv_type = atoi(argv[5]); |
| quality = atoi(argv[6]); |
| |
| //<input file type: 0(I420)/1(NV12)/2(UYVY)/3(YUY2)/4(Y8)/5(RGBA)> |
| switch(yuv_type) |
| { |
| case 0 : //I420 |
| case 1 : { //NV12 |
| frame_size = picture_width * picture_height + ((picture_width * picture_height) >> 1) ; |
| break; |
| } |
| |
| case 2: //UYVY |
| case 3: { //YUY2 |
| frame_size = 2 * (picture_width * picture_height); |
| break; |
| } |
| |
| case 4: { //Y8 |
| frame_size = picture_width * picture_height; |
| break; |
| } |
| |
| case 5: { //RGBA |
| frame_size = 4 * (picture_width * picture_height) ; |
| break; |
| } |
| |
| default: { |
| printf("Unsupported format:\n"); |
| show_help(); |
| return -1; |
| } |
| } |
| |
| yuv_fp = fopen(argv[3],"rb"); |
| if ( yuv_fp == NULL){ |
| printf("Can't open input YUV file\n"); |
| return -1; |
| } |
| |
| fseeko(yuv_fp, (off_t)0, SEEK_END); |
| file_size = ftello(yuv_fp); |
| |
| if ( (file_size < frame_size) || (file_size % frame_size) ) { |
| fclose(yuv_fp); |
| printf("The YUV file's size is not correct: file_size=%zd, frame_size=%d\n", file_size, frame_size); |
| return -1; |
| } |
| |
| fseeko(yuv_fp, (off_t)0, SEEK_SET); |
| |
| jpeg_fp = fopen(argv[4], "wb"); |
| if ( jpeg_fp == NULL) { |
| fclose(yuv_fp); |
| printf("Can't open output destination jpeg file\n"); |
| return -1; |
| } |
| |
| start_time = clock(); |
| encode_input_image(yuv_fp, jpeg_fp, picture_width, picture_height, frame_size, yuv_type, quality); |
| if(yuv_fp != NULL) fclose(yuv_fp); |
| if(jpeg_fp != NULL) fclose(jpeg_fp); |
| finish_time = clock(); |
| duration = finish_time - start_time; |
| printf("Encoding finished in %u ticks\n", duration); |
| |
| return 0; |
| } |
| |
