header.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

/*
 * header.c
 * Copyright (C) 2000-2003 Michel Lespinasse <[e-mail]>
 * Copyright (C) 2003      Regis Duchesne <[e-mail]>
 * Copyright (C) 1999-2000 Aaron Holtzman <[e-mail]>
 *
 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
 * See http://libmpeg2.sourceforge.net/ for updates.
 *
 * mpeg2dec is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * mpeg2dec is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#ifdef MAE_HW
#include "inttypes.h"
#endif
#include <stdlib.h> /* defines NULL */
#include <string.h> /* memcmp */

#include "mpeg2.h"
#include "attributes.h"
#include "mpeg2_internal.h"
#ifdef MAE_HW
//#include "mai_types.h"
#include "mae_interface.h"
#include "mai_types.h" /* for MAITimeStamp in driverif.h */
#include "driverif.h"
#endif /* MAE_HW */

#ifdef TRACE_BUILD
#include "mai_osal.h"
/* enable these TIME printfs to assist in timestamp/PTS debugging */
#define DPRINTF(_args_)      MAIOSDebugPrint _args_
#define TIMEPRINTF(_args_)   MAIOSDebugPrint _args_
#define TIMEPRINTF2(_args_)  /* MAIOSDebugPrint _args_ */
#else
#define DPRINTF(_args_)
#define TIMEPRINTF(_args_)
#define TIMEPRINTF2(_args_)
#endif

#define SEQ_EXT 2
#define SEQ_DISPLAY_EXT 4
#define QUANT_MATRIX_EXT 8
#define COPYRIGHT_EXT 0x10
#define PIC_DISPLAY_EXT 0x80
#define PIC_CODING_EXT 0x100

#ifdef MAE_HW        
extern wrap_context *pWrapContext;

#ifdef USE_CMODELIF
extern int nDMVUpdate;
#else /* MAE driver */
extern int nDMVUpdate, nDMVUpdate1, nDMVUpdate2;
extern int prog_frame; // KK - rev2
#endif

#endif /* MAE_HW */

/* default intra quant matrix, in zig-zag order */
static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
    8,
    16, 16,
    19, 16, 19,
    22, 22, 22, 22,
    22, 22, 26, 24, 26,
    27, 27, 27, 26, 26, 26,
    26, 27, 27, 27, 29, 29, 29,
    34, 34, 34, 29, 29, 29, 27, 27,
    29, 29, 32, 32, 34, 34, 37,
    38, 37, 35, 35, 34, 35,
    38, 38, 40, 40, 40,
    48, 48, 46, 46,
    56, 56, 58,
    69, 69,
    83
};

uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
    /* Zig-Zag scan pattern */
     0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
};

// $PP
uint8_t my_mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
    /* Zig-Zag scan pattern */
     0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
};

uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
    /* Alternate scan pattern */
     0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
    41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
    51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
    53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
};

uint8_t my_mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
    /* Alternate scan pattern */
     0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
    41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
    51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
    53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
};

void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec)
{
  DPRINTF((M_TEXT("mpeg2_header_state_init()\n")));
  if (mpeg2dec->sequence.width != (unsigned)-1) {
    int i;
    
    mpeg2dec->sequence.width = (unsigned)-1;
    if (!mpeg2dec->custom_fbuf)
#ifndef MAE_HW
      for (i = mpeg2dec->alloc_index_user;
      i < mpeg2dec->alloc_index; i++) {
        mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
        mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
        mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
      }
#else
      if(mpeg2dec->bUseMAE)
      {
        // We are using kernel memory, don't try to fee it here!!
      }
      else
      {
        for (i = mpeg2dec->alloc_index_user;
        i < mpeg2dec->alloc_index; i++) {
          mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
          mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
          mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
        }
      }
#endif
      if (mpeg2dec->convert_start)
        for (i = 0; i < 3; i++) {
          mpeg2_free (mpeg2dec->yuv_buf[i][0]);
          mpeg2_free (mpeg2dec->yuv_buf[i][1]);
          mpeg2_free (mpeg2dec->yuv_buf[i][2]);
        }
        if (mpeg2dec->decoder.convert_id)
          mpeg2_free (mpeg2dec->decoder.convert_id);
  }
  
  mpeg2dec->decoder.coding_type = I_TYPE;
  mpeg2dec->decoder.convert = NULL;
  mpeg2dec->decoder.convert_id = NULL;
  mpeg2dec->picture = mpeg2dec->pictures;
#ifdef NO_PERF
  // @@@ libmpeg2 patch - begin
  memset(&mpeg2dec->fbuf_alloc[0].fbuf, 0, sizeof(mpeg2_fbuf_t));
  memset(&mpeg2dec->fbuf_alloc[1].fbuf, 0, sizeof(mpeg2_fbuf_t));
  memset(&mpeg2dec->fbuf_alloc[2].fbuf, 0, sizeof(mpeg2_fbuf_t));
  // @@@ libmpeg2 patch - end
#endif //#ifdef NO_PERF
  mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
  mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
  mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
  mpeg2dec->first = 1;
  mpeg2dec->alloc_index = 0;
  mpeg2dec->alloc_index_user = 0;
  mpeg2dec->first_decode_slice = 1;
  mpeg2dec->nb_decode_slices = 0xb0 - 1;
  mpeg2dec->convert = NULL;
  mpeg2dec->convert_start = NULL;
  mpeg2dec->custom_fbuf = 0;
  mpeg2dec->yuv_index = 0;
}

void mpeg2_reset_info (mpeg2_info_t * info)
{
  info->current_picture = info->current_picture_2nd = NULL;
  info->display_picture = info->display_picture_2nd = NULL;
  info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
}

static void info_user_data (mpeg2dec_t * mpeg2dec)
{
  if (mpeg2dec->user_data_len) {
    mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
    mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
  }
}

int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
{
  uint8_t * buffer = mpeg2dec->chunk_start;
  mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
  static unsigned int frame_period[16] = {
    0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
      /* unofficial: xing 15 fps */
      1800000,
      /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
      5400000, 2700000, 2250000, 1800000, 0, 0
  };
  static unsigned int frameperiod[9] = {0, 24, 24, 25, 30, 30, 50, 60, 60};
  int i;
  
  if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */
    return 1;
  
  i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
  if (! (sequence->display_width = sequence->picture_width = i >> 12))
    return 1;
  if (! (sequence->display_height = sequence->picture_height = i & 0xfff))
    return 1;
  sequence->width = (sequence->picture_width + 15) & ~15;
  sequence->height = (sequence->picture_height + 15) & ~15;
  sequence->chroma_width = sequence->width >> 1;
  sequence->chroma_height = sequence->height >> 1;
  
  sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
    SEQ_VIDEO_FORMAT_UNSPECIFIED);
  
#if defined(MAE_HW)
  prog_frame = 1; // KK - rev2
#endif
  
  /* HWG050524+ read pixel aspect ratio code - will be translated in finalize_sequence() */
  sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */
  sequence->pixel_height = 0; /* aspect ratio */
  /* HWG050524- */
  
  sequence->frame_period = frame_period[buffer[3] & 15];
  if (!frameperiod[buffer[3] & 15]) /* invalid frame period */
    return 1;
  sequence->uiFramePeriod = 1000/(frameperiod[buffer[3] & 15]);
  
  sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
  
  sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
  
  if (buffer[7] & 4)
    sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
  
  mpeg2dec->copy_matrix = 3;
  if (buffer[7] & 2)
  {
    for (i = 0; i < 64; i++)
      // $PP
      // store INTRA quant matrix in zig-zag scan order
      mpeg2dec->MAE_New_Quant_Matrix[0][my_mpeg2_scan_norm[i]] =
      mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = (buffer[i+7] << 7) | (buffer[i+8] >> 1);
    
    buffer += 64;
  }
  else
    for (i = 0; i < 64; i++)
      // $PP
      // store INTRA quant matrix in zig-zag scan order
      mpeg2dec->MAE_New_Quant_Matrix[0][my_mpeg2_scan_norm[i]] =
      mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = default_intra_quantizer_matrix[i];
    
    if (buffer[7] & 1)
    {
      for (i = 0; i < 64; i++)
        // $PP
        // store INTER quant matrix in zig zag order
        mpeg2dec->MAE_New_Quant_Matrix[1][my_mpeg2_scan_norm[i]] =
        mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =buffer[i+8];
    }
    else
    {
      // $PP
      // store INTER quant matrix in zig zag order
      memset (mpeg2dec->MAE_New_Quant_Matrix[1], 16, 64);
      
      memset (mpeg2dec->new_quantizer_matrix[1], 16, 64);
    }
    
    sequence->profile_level_id = 0x80;
    sequence->colour_primaries = 0;
    sequence->transfer_characteristics = 0;
    sequence->matrix_coefficients = 0;
    
    mpeg2dec->ext_state = SEQ_EXT;
    mpeg2dec->state = STATE_SEQUENCE;
    mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
    
    return 0;
}

static int sequence_ext (mpeg2dec_t * mpeg2dec)
{
  uint8_t * buffer = mpeg2dec->chunk_start;
  mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
  uint32_t flags;
  
  if (!(buffer[3] & 1))
    return 1;
  
  sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
  
  sequence->display_width = sequence->picture_width +=
    ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
  sequence->display_height = sequence->picture_height +=
    (buffer[2] << 7) & 0x3000;
  sequence->width = (sequence->picture_width + 15) & ~15;
  sequence->height = (sequence->picture_height + 15) & ~15;
  flags = sequence->flags | SEQ_FLAG_MPEG2;
  
  if (!(buffer[1] & 8))
  {
    flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
    
#if defined(MAE_HW)
    prog_frame = 0; // KK - rev2
#endif
    
    sequence->height = (sequence->height + 31) & ~31;
  }
  
  if (buffer[5] & 0x80)
    flags |= SEQ_FLAG_LOW_DELAY;
  sequence->flags = flags;
  sequence->chroma_width = sequence->width;
  sequence->chroma_height = sequence->height;
  switch (buffer[1] & 6) {
  case 0: /* invalid */
    return 1;
  case 2: /* 4:2:0 */
    sequence->chroma_height >>= 1;
  case 4: /* 4:2:2 */
    sequence->chroma_width >>= 1;
  }
  
  sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
  
  sequence->vbv_buffer_size |= buffer[4] << 21;
  
  sequence->frame_period =
    sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
  
  //$PP
  sequence->uiFramePeriod = (sequence->uiFramePeriod * ((buffer[5]&31)+1)) / (((buffer[5]>>2)&3)+1);
  mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
  
  return 0;
}

static int sequence_display_ext (mpeg2dec_t * mpeg2dec)
{
  uint8_t * buffer = mpeg2dec->chunk_start;
  mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
  uint32_t flags;
  
  flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
    ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
  if (buffer[0] & 1) {
    flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
    sequence->colour_primaries = buffer[1];
    sequence->transfer_characteristics = buffer[2];
    sequence->matrix_coefficients = buffer[3];
    buffer += 3;
  }
  
  if (!(buffer[2] & 2)) /* missing marker_bit */
    return 1;
  
  sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
  sequence->display_height =
    ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
  
  return 0;
}

static inline void finalize_sequence (mpeg2_sequence_t * sequence)
{
  int width;
  int height;
  
  sequence->byte_rate *= 50;
  /* HWG050524+ translate pixel aspect ratio code to actual ratio (i.e. 1:1) */
  if (sequence->flags & SEQ_FLAG_MPEG2)
  {
    switch (sequence->pixel_width) {
    case 1:   /* square pixels */
      sequence->pixel_width = sequence->pixel_height = 1; return;
    case 2:   /* 4:3 aspect ratio */
      width = 4; height = 3;  break;
    case 3:   /* 16:9 aspect ratio */
      width = 16; height = 9; break;
    case 4:   /* 2.21:1 aspect ratio */
      width = 221; height = 100;  break;
    default:  /* illegal */
      width = height = 0; break;
    }
    width *= sequence->display_height;
    height *= sequence->display_width;
  }
  else
  {
    if (sequence->byte_rate == 50 * 0x3ffff) 
      sequence->byte_rate = 0;        /* mpeg-1 VBR */ 
    
    switch (sequence->pixel_width) {
    case 0: case 15:  /* illegal */
      sequence->pixel_width = sequence->pixel_height = 0;   return;
    case 1: /* square pixels */
      sequence->pixel_width = sequence->pixel_height = 1;   return;
    case 3: /* 720x576 16:9 */