path: root/encoder/ixheaace_write_adts_adif.c

/******************************************************************************
 *                                                                            *
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
 */

#include "ixheaac_type_def.h"
#include "ixheaac_constants.h"
#include "ixheaace_psy_const.h"
#include "ixheaace_tns.h"
#include "ixheaace_tns_params.h"
#include "ixheaace_rom.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_bitbuffer.h"
#include "ixheaace_aac_constants.h"
#include "ixheaace_write_adts_adif.h"

#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"
#include "ixheaace_common_utils.h"

static VOID ia_enhaacplus_enc_putbit(ixheaace_bitstream_params *pstr_bitstream, UWORD32 data,
                                       WORD32 num_bit) {
  WORD32 num, max_num, curr_num;
  WORD32 num_used, idx;
  unsigned long bits;
  WORD32 current_bitstream_bit;
  UWORD8 *bitstream_data;

  if (num_bit == 0) return;

  current_bitstream_bit = pstr_bitstream->current_bit;
  bitstream_data = pstr_bitstream->data;

  /*
      Functionality of Writing bits to the bitstream is split into 3 stages.
  */

  /*
      Stage #1: Write remainder bits to the partially filled byte
  */

  num = 0;
  num_used = current_bitstream_bit & 7;
  max_num = BYTE_NUMBIT - num_used;
  curr_num = MIN(num_bit, max_num);
  bits = data >> (num_bit - curr_num);

  idx = (current_bitstream_bit >> 3);

  if (num_used == 0) bitstream_data[idx] = 0;

  bitstream_data[idx] |= (bits & ((1 << curr_num) - 1)) << (max_num - curr_num);
  current_bitstream_bit += curr_num;
  num += curr_num;

  /*
      Stage #2:
      At this point, (num + num_used), will be a multiple of 8
      Now the bytes can be written directly to bitstream_data[], as long
      as (num + 8) < num_bit
  */

  while ((num + 8) < num_bit) {
    num += 8;
    current_bitstream_bit += 8;
    bits = data >> (num_bit - num);
    bitstream_data[++idx] = (UWORD8)bits;
  }

  /*
      Stage #3: Write remainder bits from the data
  */
  if (num < num_bit) {
    curr_num = num_bit - num;
    num_used = current_bitstream_bit & 7;
    max_num = BYTE_NUMBIT - num_used;
    idx = current_bitstream_bit >> 3;
    if (num_used == 0) bitstream_data[idx] = 0;
    bitstream_data[idx] |= (data & ((1 << curr_num) - 1)) << (max_num - curr_num);
    current_bitstream_bit += curr_num;
  }

  pstr_bitstream->current_bit = current_bitstream_bit;
  pstr_bitstream->num_bit = current_bitstream_bit;
}

static WORD16 ia_enhaacplus_enc_get_sample_rate_index(WORD32 sample_rate) {
  if (92017 <= sample_rate) {
    return 0;
  }
  if (75132 <= sample_rate) {
    return 1;
  }
  if (55426 <= sample_rate) {
    return 2;
  }
  if (46009 <= sample_rate) {
    return 3;
  }
  if (37566 <= sample_rate) {
    return 4;
  }
  if (27713 <= sample_rate) {
    return 5;
  }
  if (23004 <= sample_rate) {
    return 6;
  }
  if (18783 <= sample_rate) {
    return 7;
  }
  if (13856 <= sample_rate) {
    return 8;
  }
  if (11502 <= sample_rate) {
    return 9;
  }
  if (9391 <= sample_rate) {
    return 10;
  }
  return 11;
}

WORD32 ia_enhaacplus_enc_write_pce(WORD32 samp_rate, WORD32 ch_mask, WORD32 num_core_coder_chans,
                                   ixheaace_bit_buf_handle pstr_bit_stream_handle) {
  UWORD32 object_type = 0;
  UWORD8 buffer[200];
  ixheaace_bitstream_params bitstream_temp;
  ixheaace_bitstream_params *pstr_bitstream = &bitstream_temp;
  WORD32 write_flag = 1;
  WORD32 start_bits = pstr_bit_stream_handle->cnt_bits, end_bits;
  pstr_bitstream->data = buffer;
  pstr_bitstream->num_bit = 8;
  pstr_bitstream->current_bit = 0;

  object_type = 01;

  if (write_flag) {
    WORD32 i;
    WORD32 num_front_chan_ele, num_side_chan_ele, num_back_chan_ele, num_lfe_chan_ele;

    /* element instance tag can be anything... writing 0 */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4);

    /* object type --> LC / LTP / any other */
    ixheaace_write_bits(pstr_bit_stream_handle, object_type, 2);

    /* sampling freq index */
    ixheaace_write_bits(pstr_bit_stream_handle,
                        ia_enhaacplus_enc_get_sample_rate_index(samp_rate), 4);

    /*  num_front_channel_elements --> only this present for mono / stereo */
    num_front_chan_ele = 0;

    if (ch_mask & 0x3) {
      num_front_chan_ele++; /*Front Left and Right Present*/
    }
    if (ch_mask & 0x4) {
      num_front_chan_ele++; /*Front Center Present*/
    }
    ixheaace_write_bits(pstr_bit_stream_handle, num_front_chan_ele, 4);

    /*	num_side_channel_elements 4 */
    num_side_chan_ele = 0;

    if (ch_mask & 0xC0) {
      num_side_chan_ele++; /*Back Left and Right Present*/
    }
    ixheaace_write_bits(pstr_bit_stream_handle, num_side_chan_ele, 4);

    /*	num_back_channel_elements 4  */
    num_back_chan_ele = 0;

    if (ch_mask & 0x30) {
      num_back_chan_ele++; /*Back Left and Right of center Present*/
    }
    ixheaace_write_bits(pstr_bit_stream_handle, num_back_chan_ele, 4);

    /*	num_lfe_channel_elements 2  */
    num_lfe_chan_ele = 0;

    if (ch_mask & 0x8) {
      num_lfe_chan_ele++; /*LFE channel Present*/
    }
    ixheaace_write_bits(pstr_bit_stream_handle, num_lfe_chan_ele, 2);

    /*	num_assoc_data_elements 3  */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 3);

    /*	num_valid_cc_elements 4 */
    ixheaace_write_bits(pstr_bit_stream_handle, num_core_coder_chans, 4);

    /* mono mix down is zero */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);

    /* mono_mixdown_element_number 4 if mono_mixdown_present == 1 */

    /* stereo_mixdown_present is zero */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);

    /* stereo_mixdown_element_number 4 if stereo_mixdown_present == 1 */

    /*	matrix_mixdown_idx_present is zero */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);

    {
      /* stereo --> 1 mono --> 0 */
      if (ch_mask & 0x4) {
        ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);
        /* element tag select */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4);
      }
      if (ch_mask & 0x3) {
        if ((ch_mask & 0x3) == 0x3) {
          /* stereo channel */
          ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1);
        } else {
          /* mono channel */
          ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);
        }

        /* element tag select */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4);
      }
    }

    for (i = 0; i < num_side_chan_ele; i++) {
      if ((ch_mask & 0xC0) == 0xC0) {
        /* stereo channel */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1);
      } else {
        /* mono channel */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);
      }

      /* element tag select */
      ixheaace_write_bits(pstr_bit_stream_handle, 0x02, 4);
    }

    for (i = 0; i < num_back_chan_ele; i++) {
      if ((ch_mask & 0x30) == 0x30) {
        /* stereo channel */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1);
      } else {
        /* mono channel */
        ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 1);
      }

      /* element tag select */
      ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 4);
    }

    for (i = 0; i < num_lfe_chan_ele; i++) {
      /* element tag select */
      ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 4);
    }

    /* loop for independent coupling elements */
    for (i = 0; i < num_core_coder_chans; i++) {
      /* It is independent coupling channel */
      ixheaace_write_bits(pstr_bit_stream_handle, 0x01, 1);

      /* element tag select */
      ixheaace_write_bits(pstr_bit_stream_handle, num_core_coder_chans - i - 1, 4);
    }

    /* byte align the stream */
    ixheaace_write_bits(pstr_bit_stream_handle, 0,
                        (UWORD8)((8 - (pstr_bit_stream_handle->cnt_bits % 8)) % 8));
    /* comment field types --> do not quite know what this is */
    ixheaace_write_bits(pstr_bit_stream_handle, 0x00, 8);
  }

  end_bits = pstr_bit_stream_handle->cnt_bits;

  return (end_bits - start_bits);
}

WORD32 ia_enhaacplus_enc_write_ADTS_header(pUWORD8 buffer, WORD32 bytes_used, WORD32 samp_rate,
                                           WORD32 num_ch) {
  WORD32 bits = 56;
  UWORD32 object_type = 0;
  ixheaace_bitstream_params bitstream_temp;
  ixheaace_bitstream_params *pstr_bitstream = &bitstream_temp;
  WORD32 write_flag = 1;
  pstr_bitstream->data = buffer;
  pstr_bitstream->num_bit = 8;

  pstr_bitstream->current_bit = 0;
  ;
  object_type = 01;

  if (write_flag) {
    /* Fixed ADTS header */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0xFFFF, 12); /* 12 bit Syncword */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 1 /*aacStateStruct->aacConfigSturct.mpegVersion*/,
                             1);                    /* ID == 0 for MPEG4 AAC, 1 for MPEG2 AAC */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* layer == 0 */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 1, 1); /* protection absent */
    ia_enhaacplus_enc_putbit(pstr_bitstream, object_type, 2); /* profile */
    ia_enhaacplus_enc_putbit(
        pstr_bitstream,
        ia_enhaacplus_enc_get_sample_rate_index(samp_rate) /*aacStateStruct->sampleRateIdx*/,
        4);                                         /* sampling rate */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* private bit */
    ia_enhaacplus_enc_putbit(pstr_bitstream, num_ch /*aacStateStruct->aacConfigSturct.ch*/,
                             3);                    /* ch. aacConfigSturct (must be > 0) */
                                                    /* simply using num_channels only works for
                                                    6 channels or less, else a channel
     configuration should be written */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* original/copy */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* home */

    /* Variable ADTS header */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* copyr. id. bit */
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 1); /* copyr. id. start */
    ia_enhaacplus_enc_putbit(pstr_bitstream, /*aacStateStruct->*/ bytes_used + 7, 13);
    ia_enhaacplus_enc_putbit(pstr_bitstream, 0x7FF, 11); /* buffer fullness (0x7FF for VBR) */

    ia_enhaacplus_enc_putbit(pstr_bitstream, 0, 2); /* raw data blocks (0+1=1) */
  }

  /*
   * MPEG2 says byte_aligment() here, but ADTS always is multiple of 8 bits
   * MPEG4 has no byte_alignment() here
   */
  return bits / 8;
}