/*!
************************************************************************
* \file output.c
*
* \brief
* Output an image and Trance support
*
* \author
* Main contributors (see contributors.h for copyright, address and affiliation details)
* - Karsten Suehring
************************************************************************
*/
#include "contributors.h"
#include
#include
#include
#ifdef WIN32
#include
#else
#include
#endif
#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 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 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 for(j=crop_left;j {
ui8 = (unsigned char) (imgX[i][j]);
buf[(j-crop_left+((i-crop_top)*(twidth)))] = ui8;
}
break;
}
case 2:
{
for(i=crop_top;i for(j=crop_left;j {
tmp16 = (unsigned short) (imgX[i][j]);
ui16 = (tmp16 >> 8) | ((tmp16&0xFF) memcpy(buf+((j-crop_left+((i-crop_top)*(twidth)))*2),&(ui16), 2);
}
break;
}
case 4:
{
for(i=crop_top;i for(j=crop_left;j {
tmp32 = (unsigned long) (imgX[i][j]);
ui32 = ((tmp32&0xFF00)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 for(j=crop_left;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 = (input->rgb_input_flag && input->yuv_format==3);
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
if (NULL == (buf = malloc (p->size_x*p->size_y*symbol_size_in_bytes))) 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 (active_sps->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;isize_y;i++)
memset(p->imgY[i], img->dc_pred_value, p->size_x*sizeof(imgpel));
for(i=0;isize_y_cr;i++)
memset(p->imgUV[0][i], img->dc_pred_value ,p->size_x_cr*sizeof(imgpel));
for(i=0;isize_y_cr;i++)
memset(p->imgUV[1][i], img->dc_pred_value ,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 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);
clear_picture(fs->bottom_field);
dpb_combine_field(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);
dpb_combine_field(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 {
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(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;
}
}
