URL
https://opencores.org/ocsvn/bluespec-h264/bluespec-h264/trunk
Subversion Repositories bluespec-h264
[/] [bluespec-h264/] [trunk/] [test/] [decoder/] [ldecod/] [src/] [output.c] - Rev 100
Compare with Previous | Blame | View Log
/*! ************************************************************************ * \file output.c * * \brief * Output an image and Trance support * * \author * Main contributors (see contributors.h for copyright, address and affiliation details) * - Karsten Suehring <suehring@hhi.de> ************************************************************************ */ #include "contributors.h" #include <stdlib.h> #include <assert.h> #include <string.h> #ifdef WIN32 #include <io.h> #else #include <unistd.h> #endif #include "global.h" #include "mbuffer.h" #include "image.h" #include "memalloc.h" FrameStore* out_buffer; StorablePicture *pending_output = NULL; int pending_output_state = FRAME; int recovery_flag = 0; extern int non_conforming_stream; void write_out_picture(StorablePicture *p, int p_out); /*! ************************************************************************ * \brief * checks if the System is big- or little-endian * \return * 0, little-endian (e.g. Intel architectures) * 1, big-endian (e.g. SPARC, MIPS, PowerPC) ************************************************************************ */ int testEndian() { short s; byte *p; p=(byte*)&s; s=1; return (*p==0); } /*! ************************************************************************ * \brief * Convert image plane to temporary buffer for file writing * \param imgX * Pointer to image plane * \param buf * Buffer for file output * \param size_x * horizontal size * \param size_y * vertical size * \param symbol_size_in_bytes * number of bytes used per pel * \param crop_left * pixels to crop from left * \param crop_right * pixels to crop from right * \param crop_top * pixels to crop from top * \param crop_bottom * pixels to crop from bottom ************************************************************************ */ void img2buf (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int symbol_size_in_bytes, int crop_left, int crop_right, int crop_top, int crop_bottom) { int i,j; int twidth = size_x - crop_left - crop_right; int theight = size_y - crop_top - crop_bottom; int size = 0; unsigned char ui8; unsigned short tmp16, ui16; unsigned long tmp32, ui32; if (( sizeof(char) == sizeof (imgpel)) && ( sizeof(char) == symbol_size_in_bytes)) { // imgpel == pixel_in_file == 1 byte -> simple copy for(i=0;i<theight;i++) memcpy(buf+crop_left+(i*twidth),&(imgX[i+crop_top][crop_left]), twidth); } else { // sizeof (imgpel) > sizeof(char) if (testEndian()) { // big endian switch (symbol_size_in_bytes) { case 1: { for(i=crop_top;i<size_y-crop_bottom;i++) for(j=crop_left;j<size_x-crop_right;j++) { ui8 = (unsigned char) (imgX[i][j]); buf[(j-crop_left+((i-crop_top)*(twidth)))] = ui8; } break; } case 2: { for(i=crop_top;i<size_y-crop_bottom;i++) for(j=crop_left;j<size_x-crop_right;j++) { tmp16 = (unsigned short) (imgX[i][j]); ui16 = (tmp16 >> 8) | ((tmp16&0xFF)<<8); memcpy(buf+((j-crop_left+((i-crop_top)*(twidth)))*2),&(ui16), 2); } break; } case 4: { for(i=crop_top;i<size_y-crop_bottom;i++) for(j=crop_left;j<size_x-crop_right;j++) { tmp32 = (unsigned long) (imgX[i][j]); ui32 = ((tmp32&0xFF00)<<8) | ((tmp32&0xFF)<<24) | ((tmp32&0xFF0000)>>8) | ((tmp32&0xFF000000)>>24); memcpy(buf+((j-crop_left+((i-crop_top)*(twidth)))*4),&(ui32), 4); } break; } default: { error ("writing only to formats of 8, 16 or 32 bit allowed on big endian architecture", 500); break; } } } else { // little endian if (sizeof (imgpel) < symbol_size_in_bytes) { // this should not happen. we should not have smaller imgpel than our source material. size = sizeof (imgpel); // clear buffer memset (buf, 0, (twidth*theight*symbol_size_in_bytes)); } else { size = symbol_size_in_bytes; } if ((crop_top || crop_bottom || crop_left || crop_right) || (size != 1)) { for(i=crop_top;i<size_y-crop_bottom;i++) { int ipos = (i-crop_top)*(twidth); for(j=crop_left;j<size_x-crop_right;j++) { memcpy(buf+((j-crop_left+(ipos))*symbol_size_in_bytes),&(imgX[i][j]), size); } } } else { for(i=0;i<size_y;i++) { for(j=0;j<size_x;j++) { *(buf++)=(char) imgX[i][j]; } } } } } } #ifdef PAIR_FIELDS_IN_OUTPUT void clear_picture(StorablePicture *p); /*! ************************************************************************ * \brief * output the pending frame buffer * \param p_out * Output file ************************************************************************ */ void flush_pending_output(int p_out) { if (pending_output_state!=FRAME) { write_out_picture(pending_output, p_out); } if (pending_output->imgY) { free_mem2Dpel (pending_output->imgY); pending_output->imgY=NULL; } if (pending_output->imgUV) { free_mem3Dpel (pending_output->imgUV, 2); pending_output->imgUV=NULL; } pending_output_state = FRAME; } /*! ************************************************************************ * \brief * Writes out a storable picture * If the picture is a field, the output buffers the picture and tries * to pair it with the next field. * \param p * Picture to be written * \param p_out * Output file ************************************************************************ */ void write_picture(StorablePicture *p, int p_out, int real_structure) { int i, add; if (real_structure==FRAME) { flush_pending_output(p_out); write_out_picture(p, p_out); return; } if (real_structure==pending_output_state) { flush_pending_output(p_out); write_picture(p, p_out, real_structure); return; } if (pending_output_state == FRAME) { pending_output->size_x = p->size_x; pending_output->size_y = p->size_y; pending_output->size_x_cr = p->size_x_cr; pending_output->size_y_cr = p->size_y_cr; pending_output->chroma_format_idc = p->chroma_format_idc; pending_output->frame_mbs_only_flag = p->frame_mbs_only_flag; pending_output->frame_cropping_flag = p->frame_cropping_flag; if (pending_output->frame_cropping_flag) { pending_output->frame_cropping_rect_left_offset = p->frame_cropping_rect_left_offset; pending_output->frame_cropping_rect_right_offset = p->frame_cropping_rect_right_offset; pending_output->frame_cropping_rect_top_offset = p->frame_cropping_rect_top_offset; pending_output->frame_cropping_rect_bottom_offset = p->frame_cropping_rect_bottom_offset; } get_mem2Dpel (&(pending_output->imgY), pending_output->size_y, pending_output->size_x); get_mem3Dpel (&(pending_output->imgUV), 2, pending_output->size_y_cr, pending_output->size_x_cr); clear_picture(pending_output); // copy first field if (real_structure == TOP_FIELD) { add = 0; } else { add = 1; } for (i=0; i<pending_output->size_y; i+=2) { memcpy(pending_output->imgY[(i+add)], p->imgY[(i+add)], p->size_x * sizeof(imgpel)); } for (i=0; i<pending_output->size_y_cr; i+=2) { memcpy(pending_output->imgUV[0][(i+add)], p->imgUV[0][(i+add)], p->size_x_cr * sizeof(imgpel)); memcpy(pending_output->imgUV[1][(i+add)], p->imgUV[1][(i+add)], p->size_x_cr * sizeof(imgpel)); } pending_output_state = real_structure; } else { if ( (pending_output->size_x!=p->size_x) || (pending_output->size_y!= p->size_y) || (pending_output->frame_mbs_only_flag != p->frame_mbs_only_flag) || (pending_output->frame_cropping_flag != p->frame_cropping_flag) || ( pending_output->frame_cropping_flag && ( (pending_output->frame_cropping_rect_left_offset != p->frame_cropping_rect_left_offset) ||(pending_output->frame_cropping_rect_right_offset != p->frame_cropping_rect_right_offset) ||(pending_output->frame_cropping_rect_top_offset != p->frame_cropping_rect_top_offset) ||(pending_output->frame_cropping_rect_bottom_offset != p->frame_cropping_rect_bottom_offset) ) ) ) { flush_pending_output(p_out); write_picture (p, p_out, real_structure); return; } // copy second field if (real_structure == TOP_FIELD) { add = 0; } else { add = 1; } for (i=0; i<pending_output->size_y; i+=2) { memcpy(pending_output->imgY[(i+add)], p->imgY[(i+add)], p->size_x * sizeof(imgpel)); } for (i=0; i<pending_output->size_y_cr; i+=2) { memcpy(pending_output->imgUV[0][(i+add)], p->imgUV[0][(i+add)], p->size_x_cr * sizeof(imgpel)); memcpy(pending_output->imgUV[1][(i+add)], p->imgUV[1][(i+add)], p->size_x_cr * sizeof(imgpel)); } flush_pending_output(p_out); } } #else /*! ************************************************************************ * \brief * Writes out a storable picture without doing any output modifications * \param p * Picture to be written * \param p_out * Output file * \param real_structure * real picture structure ************************************************************************ */ void write_picture(StorablePicture *p, int p_out, int real_structure) { write_out_picture(p, p_out); } #endif /*! ************************************************************************ * \brief * Writes out a storable picture * \param p * Picture to be written * \param p_out * Output file ************************************************************************ */ void write_out_picture(StorablePicture *p, int p_out) { int SubWidthC [4]= { 1, 2, 2, 1}; int SubHeightC [4]= { 1, 2, 1, 1}; int crop_left, crop_right, crop_top, crop_bottom; int symbol_size_in_bytes = img->pic_unit_bitsize_on_disk/8; Boolean rgb_output = (Boolean) (active_sps->vui_seq_parameters.matrix_coefficients==0); unsigned char *buf; if (p->non_existing) return; if (p->frame_cropping_flag) { crop_left = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_left_offset; crop_right = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_right_offset; crop_top = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_top_offset; crop_bottom = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_bottom_offset; } else { crop_left = crop_right = crop_top = crop_bottom = 0; } //printf ("write frame size: %dx%d\n", p->size_x-crop_left-crop_right,p->size_y-crop_top-crop_bottom ); // KS: this buffer should actually be allocated only once, but this is still much faster than the previous version buf = malloc (p->size_x*p->size_y*symbol_size_in_bytes); if (NULL==buf) { no_mem_exit("write_out_picture: buf"); } if(rgb_output) { crop_left = p->frame_cropping_rect_left_offset; crop_right = p->frame_cropping_rect_right_offset; crop_top = ( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_top_offset; crop_bottom = ( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_bottom_offset; img2buf (p->imgUV[1], buf, p->size_x_cr, p->size_y_cr, symbol_size_in_bytes, crop_left, crop_right, crop_top, crop_bottom); write(p_out, buf, (p->size_y_cr-crop_bottom-crop_top)*(p->size_x_cr-crop_right-crop_left)*symbol_size_in_bytes); if (p->frame_cropping_flag) { crop_left = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_left_offset; crop_right = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_right_offset; crop_top = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_top_offset; crop_bottom = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_bottom_offset; } else { crop_left = crop_right = crop_top = crop_bottom = 0; } } img2buf (p->imgY, buf, p->size_x, p->size_y, symbol_size_in_bytes, crop_left, crop_right, crop_top, crop_bottom); write(p_out, buf, (p->size_y-crop_bottom-crop_top)*(p->size_x-crop_right-crop_left)*symbol_size_in_bytes); if (p->chroma_format_idc!=YUV400) { crop_left = p->frame_cropping_rect_left_offset; crop_right = p->frame_cropping_rect_right_offset; crop_top = ( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_top_offset; crop_bottom = ( 2 - p->frame_mbs_only_flag ) * p->frame_cropping_rect_bottom_offset; img2buf (p->imgUV[0], buf, p->size_x_cr, p->size_y_cr, symbol_size_in_bytes, crop_left, crop_right, crop_top, crop_bottom); write(p_out, buf, (p->size_y_cr-crop_bottom-crop_top)*(p->size_x_cr-crop_right-crop_left)* symbol_size_in_bytes); if (!rgb_output) { img2buf (p->imgUV[1], buf, p->size_x_cr, p->size_y_cr, symbol_size_in_bytes, crop_left, crop_right, crop_top, crop_bottom); write(p_out, buf, (p->size_y_cr-crop_bottom-crop_top)*(p->size_x_cr-crop_right-crop_left)*symbol_size_in_bytes); } } else { if (input->write_uv) { int i,j; imgpel cr_val = (imgpel) (1<<(img->bitdepth_luma - 1)); get_mem3Dpel (&(p->imgUV), 1, p->size_y/2, p->size_x/2); for (j=0; j<p->size_y/2; j++) for (i=0; i<p->size_x/2; i++) p->imgUV[0][j][i]=cr_val; // fake out U=V=128 to make a YUV 4:2:0 stream img2buf (p->imgUV[0], buf, p->size_x/2, p->size_y/2, symbol_size_in_bytes, crop_left/2, crop_right/2, crop_top/2, crop_bottom/2); write(p_out, buf, symbol_size_in_bytes * (p->size_y-crop_bottom-crop_top)/2 * (p->size_x-crop_right-crop_left)/2 ); write(p_out, buf, symbol_size_in_bytes * (p->size_y-crop_bottom-crop_top)/2 * (p->size_x-crop_right-crop_left)/2 ); free_mem3Dpel(p->imgUV, 1); p->imgUV=NULL; } } free(buf); // fsync(p_out); } /*! ************************************************************************ * \brief * Initialize output buffer for direct output ************************************************************************ */ void init_out_buffer() { out_buffer = alloc_frame_store(); #ifdef PAIR_FIELDS_IN_OUTPUT pending_output = calloc (sizeof(StorablePicture), 1); if (NULL==pending_output) no_mem_exit("init_out_buffer"); pending_output->imgUV = NULL; pending_output->imgY = NULL; #endif } /*! ************************************************************************ * \brief * Uninitialize output buffer for direct output ************************************************************************ */ void uninit_out_buffer() { free_frame_store(out_buffer); out_buffer=NULL; #ifdef PAIR_FIELDS_IN_OUTPUT flush_pending_output(p_out); free (pending_output); #endif } /*! ************************************************************************ * \brief * Initialize picture memory with (Y:0,U:128,V:128) ************************************************************************ */ void clear_picture(StorablePicture *p) { int i,j; for(i=0;i<p->size_y;i++) { for (j=0; j<p->size_x; j++) p->imgY[i][j] = (imgpel) img->dc_pred_value_luma; } for(i=0;i<p->size_y_cr;i++) { for (j=0; j<p->size_x_cr; j++) p->imgUV[0][i][j] = (imgpel) img->dc_pred_value_chroma; } for(i=0;i<p->size_y_cr;i++) { for (j=0; j<p->size_x_cr; j++) p->imgUV[1][i][j] = (imgpel) img->dc_pred_value_chroma; } } /*! ************************************************************************ * \brief * Write out not paired direct output fields. A second empty field is generated * and combined into the frame buffer. * \param fs * FrameStore that contains a single field * \param p_out * Output file ************************************************************************ */ void write_unpaired_field(FrameStore* fs, int p_out) { StorablePicture *p; assert (fs->is_used<3); if(fs->is_used &1) { // we have a top field // construct an empty bottom field p = fs->top_field; fs->bottom_field = alloc_storable_picture(BOTTOM_FIELD, p->size_x, 2*p->size_y, p->size_x_cr, 2*p->size_y_cr); fs->bottom_field->chroma_format_idc = p->chroma_format_idc; clear_picture(fs->bottom_field); dpb_combine_field_yuv(fs); write_picture (fs->frame, p_out, TOP_FIELD); } if(fs->is_used &2) { // we have a bottom field // construct an empty top field p = fs->bottom_field; fs->top_field = alloc_storable_picture(TOP_FIELD, p->size_x, 2*p->size_y, p->size_x_cr, 2*p->size_y_cr); fs->top_field->chroma_format_idc = p->chroma_format_idc; clear_picture(fs->top_field); fs ->top_field->frame_cropping_flag = fs->bottom_field->frame_cropping_flag; if(fs ->top_field->frame_cropping_flag) { fs ->top_field->frame_cropping_rect_top_offset = fs->bottom_field->frame_cropping_rect_top_offset; fs ->top_field->frame_cropping_rect_bottom_offset = fs->bottom_field->frame_cropping_rect_bottom_offset; fs ->top_field->frame_cropping_rect_left_offset = fs->bottom_field->frame_cropping_rect_left_offset; fs ->top_field->frame_cropping_rect_right_offset = fs->bottom_field->frame_cropping_rect_right_offset; } dpb_combine_field_yuv(fs); write_picture (fs->frame, p_out, BOTTOM_FIELD); } fs->is_used=3; } /*! ************************************************************************ * \brief * Write out unpaired fields from output buffer. * \param p_out * Output file ************************************************************************ */ void flush_direct_output(int p_out) { write_unpaired_field(out_buffer, p_out); free_storable_picture(out_buffer->frame); out_buffer->frame = NULL; free_storable_picture(out_buffer->top_field); out_buffer->top_field = NULL; free_storable_picture(out_buffer->bottom_field); out_buffer->bottom_field = NULL; out_buffer->is_used = 0; } /*! ************************************************************************ * \brief * Write a frame (from FrameStore) * \param fs * FrameStore containing the frame * \param p_out * Output file ************************************************************************ */ void write_stored_frame( FrameStore *fs,int p_out) { // make sure no direct output field is pending flush_direct_output(p_out); if (fs->is_used<3) { write_unpaired_field(fs, p_out); } else { if (fs->recovery_frame) recovery_flag = 1; if ((!non_conforming_stream) || recovery_flag) write_picture(fs->frame, p_out, FRAME); } fs->is_output = 1; } /*! ************************************************************************ * \brief * Directly output a picture without storing it in the DPB. Fields * are buffered before they are written to the file. * \param p * Picture for output * \param p_out * Output file ************************************************************************ */ void direct_output(StorablePicture *p, int p_out) { if (p->structure==FRAME) { // we have a frame (or complementary field pair) // so output it directly flush_direct_output(p_out); write_picture (p, p_out, FRAME); if (-1!=p_ref && !input->silent) find_snr(snr, p, p_ref); free_storable_picture(p); return; } if (p->structure == TOP_FIELD) { if (out_buffer->is_used &1) flush_direct_output(p_out); out_buffer->top_field = p; out_buffer->is_used |= 1; } if (p->structure == BOTTOM_FIELD) { if (out_buffer->is_used &2) flush_direct_output(p_out); out_buffer->bottom_field = p; out_buffer->is_used |= 2; } if (out_buffer->is_used == 3) { // we have both fields, so output them dpb_combine_field_yuv(out_buffer); write_picture (out_buffer->frame, p_out, FRAME); if (-1!=p_ref && !input->silent) find_snr(snr, out_buffer->frame, p_ref); free_storable_picture(out_buffer->frame); out_buffer->frame = NULL; free_storable_picture(out_buffer->top_field); out_buffer->top_field = NULL; free_storable_picture(out_buffer->bottom_field); out_buffer->bottom_field = NULL; out_buffer->is_used = 0; } }