output.c

此code含H.264解码需要的 lib和 src

/*!
 ************************************************************************
 * \file output.c
 *
 * \brief
 *    Output an image and Trance support
 *
 * \author
 *    Main contributors (see contributors.h for copyright, address and affiliation details)
 *    - Karsten Suehring               <[e-mail]>
 ************************************************************************
 */

//#include "contributors.h"

#include <stdlib.h>
#include <assert.h>
#include <string.h>

#if defined(WIN32) || defined(UNDER_CE)
//#include <io.h>
#else
#include <unistd.h>
#endif

#include "global.h"
#include "mbuffer.h"
#include "image.h"
#include "memalloc.h"
#include "sei.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
//    buf += crop_left;
//    for(i = 0; i < theight; i++) 
//    {
//      memcpy(buf, &(imgX[i + crop_top][crop_left]), twidth);
//      buf += 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
//      {
//        imgpel *cur_pixel = &(imgX[0][0]);;
//        for(i = 0; i < size_y * size_x; i++)
//        {          
//          *(buf++)=(char) *(cur_pixel++);
//        }
//      }
//    }
//  }
//}


//#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

extern FILE *fpic_mem;

/*!
 ************************************************************************
 * \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);
    memory_operation[memory_operation_size].action = DISPLAY;
    memory_operation[memory_operation_size].memory_start = p->pic_mem_idx;
	memory_operation[memory_operation_size].frame_field = real_structure == FRAME ? IS_FRAME :IS_FIELD;
    memory_operation_size++;

	if (real_structure == FRAME) 
	{
		//fprintf(fpic_mem, "display mem[%d,%d] for frame, POC(%d,%d)\n", p->pic_mem_idx, p->pic_mem_idx+1, p->top_poc, p->bottom_poc);	
	}
	else
	{
		//fprintf(fpic_mem, "display mem[%d] for field, POC(%d)\n", p->pic_mem_idx, p->structure == TOP_FIELD ? p->top_poc : p->bottom_poc);

	}