| /*! | |
| ************************************************************************ | |
| * \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> | |
| #include "global.h" | |
| #include "image.h" | |
| void write_out_picture(StorablePicture *p, int p_out); | |
| FrameStore* out_buffer; | |
| /*! | |
| ************************************************************************ | |
| * \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; | |
| } | |
| for(i=crop_top;i<size_y-crop_bottom;i++) | |
| for(j=crop_left;j<size_x-crop_right;j++) | |
| { | |
| memcpy(buf+((j-crop_left+((i-crop_top)*(twidth)))*symbol_size_in_bytes),&(imgX[i][j]), size); | |
| } | |
| } | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \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); | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \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_size_on_disk/8; | |
| Boolean rgb_output = (Boolean) (input->rgb_input_flag != 0 && input->yuv_format==3); | |
| unsigned char *buf; | |
| if (p->non_existing) | |
| return; | |
| if (p_out == -1) | |
| 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); | |
| } | |
| } | |
| free(buf); | |
| // fsync(p_out); | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Initialize output buffer for direct output | |
| ************************************************************************ | |
| */ | |
| void init_out_buffer() | |
| { | |
| out_buffer = alloc_frame_store(); | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Uninitialize output buffer for direct output | |
| ************************************************************************ | |
| */ | |
| void uninit_out_buffer() | |
| { | |
| free_frame_store(out_buffer); | |
| out_buffer=NULL; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Initialize picture memory with (Y:0,U:128,V:128) | |
| ************************************************************************ | |
| */ | |
| void clear_picture(StorablePicture *p) | |
| { | |
| int i; | |
| for(i=0;i<p->size_y;i++) | |
| memset(p->imgY[i], img->dc_pred_value_luma, p->size_x*sizeof(imgpel)); | |
| for(i=0;i<p->size_y_cr;i++) | |
| memset(p->imgUV[0][i], img->dc_pred_value_chroma, p->size_x_cr*sizeof(imgpel)); | |
| for(i=0;i<p->size_y_cr;i++) | |
| memset(p->imgUV[1][i], img->dc_pred_value_chroma, p->size_x_cr*sizeof(imgpel)); | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \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, p->size_y, p->size_x_cr, 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, p->size_y, p->size_x_cr, p->size_y_cr); | |
| clear_picture(fs->top_field); | |
| 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 | |
| { | |
| 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); | |
| 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); | |
| 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 | |
| * For adaptive frame/field coding remove dangling top field from direct | |
| * output frame version instead. | |
| * \param p | |
| * Picture for output | |
| * \param p_out | |
| * Output file | |
| ************************************************************************ | |
| */ | |
| void direct_output_paff(StorablePicture *p, int p_out) | |
| { | |
| printf("Warning!!! Frame can't fit in DPB. Displayed out of sequence.\n"); | |
| 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; | |
| direct_output(p, p_out); | |
| } |