mpegaudiodec.c

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

  {
    if (!s->lsf)
    {
      is_tab = is_table;
      sf_max = 7;
    }
    else 
    {
      is_tab = is_table_lsf[g1->scalefac_compress & 1];
      sf_max = 16;
    }
    tab0 = g0->sb_hybrid + 576;
    tab1 = g1->sb_hybrid + 576;
    non_zero_found_short[0] = 0;
    non_zero_found_short[1] = 0;
    non_zero_found_short[2] = 0;
    k = (13 - g1->short_start) * 3 + g1->long_end - 3;
    for (i = 12; i >= g1->short_start; i--)
    {
      /* for last band, use previous scale factor */
      if (i != 11)
        k -= 3;
      len = band_size_short[s->sample_rate_index][i];
      for (l = 2; l >= 0; l--)
      {
        tab0 -= len;
        tab1 -= len;
        if (!non_zero_found_short[l])
        {
          /* test if non zero band. if so, stop doing i-stereo */
          for (j = 0; j < len; j++)
          {
            if (tab1[j] != 0)
            {
              non_zero_found_short[l] = 1;
              goto found1;
            }
          }
          sf = g1->scale_factors[k + l];
          if (sf >= sf_max)
            goto found1;
          v1 = is_tab[0][sf];
          v2 = is_tab[1][sf];
          for (j = 0; j < len; j++)
          {
            tmp0 = tab0[j];
            MULT6(tab0[j], tmp0, v1);
            MULT6(tab1[j], tmp0, v2);
          }
        }
        else 
        {
found1:
          if (s->mode_ext & MODE_EXT_MS_STEREO)
          {
            /* lower part of the spectrum : do ms stereo if enabled */
            for (j = 0; j < len; j++)
            {
              tmp0 = tab0[j];
              tmp1 = tab1[j];
              MULT6(tab0[j], tmp0 + tmp1, ISQRT2);
              MULT6(tab1[j], tmp0 - tmp1, ISQRT2);
            }
          }
        }
      }
    }
    non_zero_found = non_zero_found_short[0] | 
                     non_zero_found_short[1] | 
                     non_zero_found_short[2];
    for (i = g1->long_end - 1; i >= 0; i--)
    {
      len = band_size_long[s->sample_rate_index][i];
      tab0 -= len;
      tab1 -= len;
      /* test if non zero band. if so, stop doing i-stereo */
      if (!non_zero_found)
      {
        for (j = 0; j < len; j++)
        {
          if (tab1[j] != 0)
          {
            non_zero_found = 1;
            goto found2;
          }
        }
        /* for last band, use previous scale factor */
        k = (i == 21)
            ? 20
            : i;
        sf = g1->scale_factors[k];
        if (sf >= sf_max)
          goto found2;
        v1 = is_tab[0][sf];
        v2 = is_tab[1][sf];
        for (j = 0; j < len; j++)
        {
          tmp0 = tab0[j];
          MULT6(tab0[j], tmp0, v1);
          MULT6(tab1[j], tmp0, v2);
        }              
      }
      else 
      {
found2:
        if (s->mode_ext & MODE_EXT_MS_STEREO)
        {
          /* lower part of the spectrum : do ms stereo if enabled */
          for (j = 0; j < len; j++)
          {
            tmp0 = tab0[j];
            tmp1 = tab1[j];
            MULT6(tab0[j], tmp0 + tmp1, ISQRT2);
            MULT6(tab1[j], tmp0 - tmp1, ISQRT2);
          }
        }
      }
    }
  }
  else if (s->mode_ext & MODE_EXT_MS_STEREO)
  {
    /* ms stereo ONLY */
    /* NOTE: the 1/s q r t(2) normalization factor is included in the global gain */
    tab0 = g0->sb_hybrid;
    tab1 = g1->sb_hybrid;
    for (i = 0; i < 576; i++)
    {
      tmp0 = tab0[i];
      tmp1 = tab1[i];
      tab0[i] = tmp0 + tmp1;
      tab1[i] = tmp0 - tmp1;
    }
  }
}

static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
{       
  int32_t *ptr, *p0, *p1, *csa;
  int n, tmp0, tmp1, i, j;

  /* we antialias only "long" bands */
  if (g->block_type == 2)
  {
    if (!g->switch_point)
      return;
    /* XXX: check this for 8000Hz case */
    n = 1;
  }
  else 
  {
    n = SBLIMIT - 1;
  }
  ptr = g->sb_hybrid + 18;
  for (i = n; i > 0; i--)
  {
    p0 = ptr - 1;
    p1 = ptr;
    csa = &csa_table[0][0];
    for (j = 0; j < 8; j++)
    {
      tmp0 = *p0;
      tmp1 = *p1;
      #ifdef USE_INT_MULTC
        INT_CMULT(*p0, *p1, tmp0, tmp1, csa[0], csa[1]);
//printf("%d %d, ", *p0, *p1);
      #else
        *p0 = FRAC_RND(MUL64(tmp0, csa[0]) - MUL64(tmp1, csa[1]));
        *p1 = FRAC_RND(MUL64(tmp0, csa[1]) + MUL64(tmp1, csa[0]));
//printf("%d %d\n", *p0, *p1);
      #endif
      p0--;
      p1++;
      csa += 2;
    }
    ptr += 18;
  }
}

/* main layer3 decoding function */
static int mp_decode_layer3(MPADecodeContext *s)
{       
  int nb_granules, main_data_begin, private_bits;
  int gr, ch, blocksplit_flag, i, j, k, n, bits_pos, bits_left;
  GranuleDef granules[2][2], *g;
  int exponents[576];

  // does not help: memset(granules, 0, sizeof(struct GranuleDef) * 4);

  /* read side info */
  if (s->lsf)
  {
    main_data_begin = get_bits(&s->gb, 8);
    dprintf("0 seekback: %x\n", main_data_begin);
    if (s->nb_channels == 2)
      private_bits = get_bits(&s->gb, 2);
    else
      private_bits = get_bits(&s->gb, 1);
    nb_granules = 1;
  }
  else 
  {
    main_data_begin = get_bits(&s->gb, 9);
    dprintf("1 seekback: %x\n", main_data_begin);
    if (s->nb_channels == 2)
      private_bits = get_bits(&s->gb, 3);
    else
      private_bits = get_bits(&s->gb, 5);
    nb_granules = 2;
    for (ch = 0; ch < s->nb_channels; ch++)
    {
      granules[ch][0].scfsi = 0;                      /* all scale factors are transmitted */
      granules[ch][1].scfsi = get_bits(&s->gb, 4);
    }
  }
  for (gr = 0; gr < nb_granules; gr++)
  {
    for (ch = 0; ch < s->nb_channels; ch++)
    {
      dprintf("gr=%d ch=%d: side_info\n", gr, ch);
      g = &granules[ch][gr];
      g->part2_3_length = get_bits(&s->gb, 12);
      g->big_values = get_bits(&s->gb, 9);
      g->global_gain = get_bits(&s->gb, 8);
      /* if MS stereo only is selected, we precompute the 1/s q r t(2) renormalization factor */
      if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) == MODE_EXT_MS_STEREO)
        g->global_gain -= 2;
      if (s->lsf)
        g->scalefac_compress = get_bits(&s->gb, 9);
      else
        g->scalefac_compress = get_bits(&s->gb, 4);
      blocksplit_flag = get_bits(&s->gb, 1);
      if (blocksplit_flag)
      {
        g->block_type = get_bits(&s->gb, 2);
        if (g->block_type == 0)
          return - 1;
        g->switch_point = get_bits(&s->gb, 1);
        for (i = 0; i < 2; i++)
                 g->table_select[i] = get_bits(&s->gb, 5);
        for (i = 0; i < 3; i++)
                 g->subblock_gain[i] = get_bits(&s->gb, 3);
        /* compute huffman coded region sizes */
        if (g->block_type == 2)
          g->region_size[0] = (36 / 2);
        else 
        {
          if (s->sample_rate_index <= 2)
            g->region_size[0] = (36 / 2);
          else if (s->sample_rate_index != 8)
            g->region_size[0] = (54 / 2);
          else
            g->region_size[0] = (108 / 2);
        }
        g->region_size[1] = (576 / 2);
      }
      else 
      {
        int region_address1, region_address2, l;

        g->block_type = 0;
        g->switch_point = 0;
        for (i = 0; i < 3; i++)
          g->table_select[i] = get_bits(&s->gb, 5);
        /* compute huffman coded region sizes */
        region_address1 = get_bits(&s->gb, 4);
        region_address2 = get_bits(&s->gb, 3);
        dprintf("region1=%d region2=%d\n", 
        region_address1, region_address2);
        g->region_size[0] = band_index_long[s->sample_rate_index][region_address1 + 1] >> 1;
        l = region_address1 + region_address2 + 2;
        /* should not overflow */
        if (l > 22)
          l = 22;
        g->region_size[1] = band_index_long[s->sample_rate_index][l] >> 1;
      }
      /* convert region offsets to region sizes and truncate size to big_values */
      g->region_size[2] = (576 / 2);
      j = 0;
      for (i = 0; i < 3; i++)
      {
        k = g->region_size[i];
        if (k > g->big_values)
          k = g->big_values;
        g->region_size[i] = k - j;
        j = k;
      }
      /* compute band indexes */
      if (g->block_type == 2)
      {
        if (g->switch_point)
        {
          /* if switched mode, we handle the 36 first samples as
            long blocks.  For 8000Hz, we handle the 48 first
            exponents as long blocks (XXX: check this!) */
          if (s->sample_rate_index <= 2)
            g->long_end = 8;
          else if (s->sample_rate_index != 8)
            g->long_end = 6;
          else
            g->long_end = 4;                          /* 8000 Hz */

          if (s->sample_rate_index != 8)
            g->short_start = 3;
          else
            g->short_start = 2;
        }
        else 
        {
          g->long_end = 0;
          g->short_start = 0;
        }
      }
      else 
      {
        g->short_start = 13;
        g->long_end = 22;
      }
      g->preflag = 0;
      if (!s->lsf)
        g->preflag = get_bits(&s->gb, 1);
      g->scalefac_scale = get_bits(&s->gb, 1);
      g->count1table_select = get_bits(&s->gb, 1);
      dprintf("block_type=%d switch_point=%d\n", 
      g->block_type, g->switch_point);
    }
  }
  /* now we get bits from the main_data_begin offset */
  dprintf("seekback: %x\n", main_data_begin);
  seek_to_maindata(s, main_data_begin);
  for (gr = 0; gr < nb_granules; gr++)
  {
    for (ch = 0; ch < s->nb_channels; ch++)
    {
      g = &granules[ch][gr];
      bits_pos = get_bits_count(&s->gb);
      if (!s->lsf)
      {
        uint32_t *sc; 
        int slen, slen1, slen2;

        /* MPEG1 scale factors */
        slen1 = slen_table[0][g->scalefac_compress];
        slen2 = slen_table[1][g->scalefac_compress];
        dprintf("slen1=%d slen2=%d\n", slen1, slen2);
        if (g->block_type == 2)
        {
          n = g->switch_point ? 17 : 18;
          j = 0;
          for (i = 0; i < n; i++)
            g->scale_factors[j++] = get_bitsz(&s->gb, slen1);
          for (i = 0; i < 18; i++)
            g->scale_factors[j++] = get_bitsz(&s->gb, slen2);
          for (i = 0; i < 3; i++)
            g->scale_factors[j++] = 0;
        }
        else 
        {
          sc = granules[ch][0].scale_factors;
          j = 0;
          for (k = 0; k < 4; k++)
          {
            n = (k == 0
                ? 6
                : 5);
            if ((g->scfsi & (0x8 >> k)) == 0)
            {
              slen = (k < 2) ? slen1 : slen2;
              for (i = 0; i < n; i++)
                g->scale_factors[j++] = get_bitsz(&s->gb, slen);
            }
            else 
            {
              /* simply copy from last granule */
              for (i = 0; i < n; i++)
              {
                g->scale_factors[j] = sc[j];
                j++;
              }
            }
          }
          g->scale_factors[j++] = 0;
        }
#if defined(DEBUG)
        {
          printf("scfsi=%x gr=%d ch=%d scale_factors:\n", 
          g->scfsi, gr, ch);
          for (i = 0; i < j; i++)
            printf(" %d", g->scale_factors[i]);
          printf("\n");
        }
#endif
      }
      else 
      {
        int tindex, tindex2, slen[4], sl, sf;

        /* LSF scale factors */
        if (g->block_type == 2)
        {
          tindex = g->switch_point ? 2 : 1;
        }
        else 
        {
          tindex = 0;
        }
        sf = g->scalefac_compress;
        if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1)
        {
          /* intensity stereo case */
          sf >>= 1;

          if (sf < 180)
          {
            lsf_sf_expand(slen, sf, 6, 6, 0);
            tindex2 = 3;
          }
          else if (sf < 244)
          {
            lsf_sf_expand(slen, sf - 180, 4, 4, 0);
            tindex2 = 4;
          }
          else 
          {
            lsf_sf_expand(slen, sf - 244, 3, 0, 0);
            tindex2 = 5;
          }
        }
        else 
        {
          /* normal case */
          if (sf < 400)