faw周りの更新。

VCECore/rgy_faw.cpp

@@ -45,6 +45,22 @@ decltype(rgy_memmem_fawstart1_c)* get_memmem_fawstart1_func() {
  return rgy_memmem_fawstart1_c;
 }
 
+static const std::array<uint8_t, 2> AACSYNC_BYTES = { 0xff, 0xf0 };
+
+static size_t rgy_find_aacsync_c(const void *data_, const size_t data_size) {
+ const uint16_t target = *(const uint16_t *)AACSYNC_BYTES.data();
+ const size_t target_size = AACSYNC_BYTES.size();
+ const uint8_t *data = (const uint8_t *)data_;
+ if (data_size < target_size) {
+ return RGY_MEMMEM_NOT_FOUND;
+ }
+ for (size_t i = 0; i <= data_size - target_size; i++) {
+ if ((*(const uint16_t *)(data + i) & target) == target) {
+ return i;
+ }
+ }
+ return RGY_MEMMEM_NOT_FOUND;
+}
 
 //16bit音声 -> 8bit音声
 void rgy_convert_audio_16to8(uint8_t *dst, const short *src, const size_t n) {
@@ -163,10 +179,10 @@ void RGYAACHeader::parse(const uint8_t *buf) {
 
 RGYFAWBitstream::RGYFAWBitstream() :
  buffer(),
- bufferOffset(0),
  bufferLength(0),
+ bufferOffset(0),
  bytePerWholeSample(0),
- inputSamples(0),
+ inputLengthByte(0),
  outSamples(0),
  aacHeader() {
 
@@ -182,10 +198,10 @@ void RGYFAWBitstream::parseAACHeader(const uint8_t *buf) {
  aacHeader.parse(buf);
 }
 
-int RGYFAWBitstream::aacChannels() const {
+uint32_t RGYFAWBitstream::aacChannels() const {
  return aacHeader.channel;
 }
-int RGYFAWBitstream::aacFrameSize() const {
+uint32_t RGYFAWBitstream::aacFrameSize() const {
  return aacHeader.aac_frame_length;
 }
 
@@ -226,13 +242,13 @@ void RGYFAWBitstream::append(const uint8_t *input, const size_t inputLength) {
  memcpy(buffer.data() + bufferOffset + bufferLength, input, inputLength);
  }
  bufferLength += inputLength;
- inputSamples += inputLength / bytePerWholeSample;
+ inputLengthByte += inputLength;
 }
 
 void RGYFAWBitstream::clear() {
  bufferLength = 0;
  bufferOffset = 0;
- inputSamples = 0;
+ inputLengthByte = 0;
  outSamples = 0;
 }
 
@@ -483,3 +499,127 @@ void RGYFAWDecoder::fin(std::vector<uint8_t>& output, RGYFAWBitstream& input) {
  addSilent(output, input);
  }
 }
+
+RGYFAWEncoder::RGYFAWEncoder() :
+ wavheader(),
+ fawmode(),
+ delaySamples(0),
+ inputAACPosByte(0),
+ outputFAWPosByte(0),
+ bufferIn(),
+ bufferTmp() {
+
+}
+
+RGYFAWEncoder::~RGYFAWEncoder() {
+
+}
+
+int RGYFAWEncoder::init(const RGYWAVHeader *data, const RGYFAWMode mode, const int delayMillisec) {
+ wavheader = *data;
+ fawmode = mode;
+ bufferTmp.setBytePerSample(wavheader.number_of_channels * wavheader.bits_per_sample / 8);
+ delaySamples = delayMillisec * (int)wavheader.sample_rate / 1000;
+ inputAACPosByte += delaySamples * bufferTmp.bytePerSample();
+ return 0;
+}
+
+int RGYFAWEncoder::encode(std::vector<uint8_t>& output, const uint8_t *input, const size_t inputLength) {
+ output.clear();
+ bufferTmp.clear();
+
+ if (fawmode == RGYFAWMode::Unknown) {
+ return -1;
+ }
+
+ bufferIn.append(input, inputLength);
+
+ const auto ret = rgy_find_aacsync_c(bufferIn.data(), bufferIn.size());
+ if (ret == RGY_MEMMEM_NOT_FOUND) {
+ return 0;
+ }
+ bufferIn.addOffset(ret);
+ return encode(output);
+}
+
+int RGYFAWEncoder::encode(std::vector<uint8_t>& output) {
+ if (bufferIn.size() < AAC_HEADER_MIN_SIZE) {
+ return 0;
+ }
+ bufferIn.parseAACHeader(bufferIn.data());
+ auto aacBlockSize = bufferIn.aacFrameSize();
+ if (aacBlockSize > bufferIn.size()) {
+ return 0;
+ }
+ auto ret0 = rgy_find_aacsync_c(bufferIn.data() + aacBlockSize, bufferIn.size() - aacBlockSize);
+ while (ret0 != RGY_MEMMEM_NOT_FOUND) {
+ ret0 += aacBlockSize;
+ if (inputAACPosByte < outputFAWPosByte) {
+ ; // このブロックを破棄
+ } else {
+ if (outputFAWPosByte < inputAACPosByte) {
+ const auto offsetBytes = inputAACPosByte - outputFAWPosByte;
+ const auto origSize = bufferTmp.size();
+ bufferTmp.append(nullptr, (size_t)offsetBytes);
+ memset(bufferTmp.data() + origSize, 0, (size_t)offsetBytes);
+ outputFAWPosByte = inputAACPosByte;
+ }
+ // outputWavPosSample == inputAACPosSample
+ encodeBlock(bufferIn.data(), aacBlockSize);
+ }
+ inputAACPosByte += AAC_BLOCK_SAMPLES * bufferTmp.bytePerSample();
+
+ bufferIn.addOffset(ret0);
+ if (bufferIn.size() < AAC_HEADER_MIN_SIZE) {
+ break;
+ }
+ bufferIn.parseAACHeader(bufferIn.data());
+ aacBlockSize = bufferIn.aacFrameSize();
+ if (aacBlockSize > bufferIn.size()) {
+ break;
+ }
+ ret0 = rgy_find_aacsync_c(bufferIn.data() + aacBlockSize, bufferIn.size() - aacBlockSize);
+ }
+
+ output.resize(bufferTmp.size());
+ memcpy(output.data(), bufferTmp.data(), bufferTmp.size());
+ bufferTmp.clear();
+ return 0;
+}
+
+void RGYFAWEncoder::encodeBlock(const uint8_t *data, const size_t dataLength) {
+ const uint32_t checksumCalc = faw_checksum_calc(data, dataLength);
+
+ bufferTmp.append(fawstart1.data(), fawstart1.size());
+ outputFAWPosByte += fawstart1.size();
+
+ bufferTmp.append(data, dataLength);
+ outputFAWPosByte += dataLength;
+
+ bufferTmp.append((const uint8_t *)&checksumCalc, sizeof(checksumCalc));
+ outputFAWPosByte += sizeof(checksumCalc);
+
+ bufferTmp.append(fawfin1.data(), fawfin1.size());
+ outputFAWPosByte += fawfin1.size();
+}
+
+int RGYFAWEncoder::fin(std::vector<uint8_t>& output) {
+ output.clear();
+ bufferIn.append(AACSYNC_BYTES.data(), AACSYNC_BYTES.size());
+ auto ret = encode(output);
+ if (outputFAWPosByte < inputAACPosByte) {
+ // 残りのbyteを0で調整
+ const auto offsetBytes = inputAACPosByte - outputFAWPosByte;
+ output.resize(output.size() + (size_t)offsetBytes, 0);
+ }
+ if (delaySamples < 0) {
+ // 負のdelayの場合、wavの長さを合わせるために0で埋める
+ const auto offsetBytes = -1 * delaySamples * bufferTmp.bytePerSample();
+ output.resize(output.size() + offsetBytes, 0);
+ }
+ //最終出力は4byte少ない (先頭に4byte入れたためと思われる)
+ if (output.size() > 4) {
+ output.resize(output.size() - 4);
+ }
+ return ret;
+}

VCECore/rgy_faw.h

@@ -70,6 +70,7 @@ enum class RGYFAWMode {
  Mix
 };
 
+static const int AAC_HEADER_MIN_SIZE = 7;
 static const uint32_t AAC_BLOCK_SAMPLES = 1024;
 
 struct RGYAACHeader {
@@ -78,12 +79,12 @@ struct RGYAACHeader {
  int profile; // 00 ... main, 01 ... lc, 10 ... ssr
  int samplerate;
  bool private_bit;
- int channel;
+ uint32_t channel;
  bool original;
  bool home;
  bool copyright;
  bool copyright_start;
- int aac_frame_length; // AACヘッダを含む
+ uint32_t aac_frame_length; // AACヘッダを含む
  int adts_buffer_fullness;
  int no_raw_data_blocks_in_frame;
 
@@ -98,7 +99,7 @@ class RGYFAWBitstream {
  size_t bufferLength;
 
  int bytePerWholeSample; // channels * bits per sample
- uint64_t inputSamples;
+ uint64_t inputLengthByte;
  uint64_t outSamples;
 
  RGYAACHeader aacHeader;
@@ -111,8 +112,9 @@ class RGYFAWBitstream {
  uint8_t *data() { return buffer.data() + bufferOffset; }
  const uint8_t *data() const { return buffer.data() + bufferOffset; }
  size_t size() const { return bufferLength; }
- uint64_t inputSampleStart() const { return inputSamples - bufferLength / bytePerWholeSample; }
- uint64_t inputSampleFin() const { return inputSamples; }
+ uint64_t inputLength() const { return inputLengthByte; }
+ uint64_t inputSampleStart() const { return (inputLengthByte - bufferLength) / bytePerWholeSample; }
+ uint64_t inputSampleFin() const { return inputLengthByte / bytePerWholeSample; }
  uint64_t outputSamples() const { return outSamples; }
  int bytePerSample() const { return bytePerWholeSample; }
 
@@ -124,8 +126,8 @@ class RGYFAWBitstream {
  void clear();
 
  void parseAACHeader(const uint8_t *buffer);
- int aacChannels() const;
- int aacFrameSize() const;
+ uint32_t aacChannels() const;
+ uint32_t aacFrameSize() const;
 };
 
 class RGYFAWDecoder {
@@ -162,4 +164,26 @@ class RGYFAWDecoder {
  void fin(std::vector<uint8_t>& output, RGYFAWBitstream& input);
 };
 
+class RGYFAWEncoder {
+private:
+ RGYWAVHeader wavheader;
+ RGYFAWMode fawmode;
+ int delaySamples;
+
+ int64_t inputAACPosByte;
+ int64_t outputFAWPosByte;
+ RGYFAWBitstream bufferIn;
+ RGYFAWBitstream bufferTmp;
+public:
+ RGYFAWEncoder();
+ ~RGYFAWEncoder();
+
+ int init(const RGYWAVHeader *data, const RGYFAWMode mode, const int delayMillisec);
+ int encode(std::vector<uint8_t>& output, const uint8_t *data, const size_t dataLength);
+ int fin(std::vector<uint8_t>& output);
+private:
+ int encode(std::vector<uint8_t>& output);
+ void encodeBlock(const uint8_t *data, const size_t dataLength);
+};
+
 #endif //__RGY_FAW_H__

VCECore/rgy_memmem.h

@@ -38,7 +38,7 @@ size_t rgy_memmem_c(const void *data_, const size_t data_size, const void *targe
 size_t rgy_memmem_avx2(const void *data_, const size_t data_size, const void *target_, const size_t target_size);
 size_t rgy_memmem_avx512bw(const void *data_, const size_t data_size, const void *target_, const size_t target_size);
 
-static const auto RGY_MEMMEM_NOT_FOUND = std::numeric_limits<decltype(rgy_memmem_c(nullptr,0,nullptr,0))>::max();
+static const auto RGY_MEMMEM_NOT_FOUND = std::numeric_limits<decltype(rgy_memmem_c(nullptr, 0, nullptr, 0))>::max();
 
 decltype(rgy_memmem_c)* get_memmem_func();
 
@@ -134,7 +134,6 @@ static RGY_FORCEINLINE size_t rgy_memmem_avx2_imp(const void *data_, const size_
  }
  return RGY_MEMMEM_NOT_FOUND;
 }
-
 #endif //#if defined(_M_IX86) || defined(_M_X64) || defined(__x86_64)
 
 #elif defined(RGY_MEMMEM_AVX512) 
@@ -188,7 +187,7 @@ static RGY_FORCEINLINE size_t rgy_memmem_avx512_imp(const void *data_, const siz
  const __m512i r1 = _mm512_loadu_si512((const __m512i*)(data + i + target_size - 1));
  uint64_t mask = _mm512_mask_cmpeq_epi8_mask(_mm512_cmpeq_epi8_mask(r0, target_first), r1, target_last);
  while (mask != 0) {
- const int64_t j = (int64_t)CTZ64(mask);
+ const auto j = CTZ64(mask);
  if (memcmp(data + i + j + 1, target + 1, target_size - 2) == 0) {
  const auto ret = i + j;
  return ret;
@@ -204,7 +203,7 @@ static RGY_FORCEINLINE size_t rgy_memmem_avx512_imp(const void *data_, const siz
  const __m512i r1 = _mm512_loadu_si512_exact(data + i + target_size - 1, data_fin);
  uint64_t mask = _mm512_mask_cmpeq_epi8_mask(_mm512_cmpeq_epi8_mask(r0, target_first), r1, target_last);
  while (mask != 0) {
- const int64_t j = (int64_t)CTZ64(mask);
+ const auto j = CTZ64(mask);
  if (memcmp(data + i + j + 1, target + 1, target_size - 2) == 0) {
  const auto ret = i + j;
  return ret;

VCECore/rgy_wav_parser.cpp

@@ -81,3 +81,32 @@ uint32_t RGYWAVHeader::parseHeader(const uint8_t *data) {
 
  return (uint32_t)(data_ptr - data);
 }
+
+std::vector<uint8_t> RGYWAVHeader::createHeader() {
+ std::vector<uint8_t> buffer(WAVE_HEADER_SIZE);
+ auto head = buffer.data();
+
+ static const char * const RIFF_HEADER = "RIFF";
+ static const char * const WAVE_HEADER = "WAVE";
+ static const char * const FMT_CHUNK = "fmt ";
+ static const char * const DATA_CHUNK = "data";
+ const int32_t FMT_SIZE = 16;
+ const int16_t FMT_ID = 1;
+ const int size = bits_per_sample / 8;
+
+ memcpy(head + 0, RIFF_HEADER, strlen(RIFF_HEADER));
+ *(int32_t*)(head + 4) = data_size + WAVE_HEADER_SIZE - 8;
+ memcpy(head + 8, WAVE_HEADER, strlen(WAVE_HEADER));
+ memcpy(head + 12, FMT_CHUNK, strlen(FMT_CHUNK));
+ *(int32_t*)(head + 16) = FMT_SIZE;
+ *(int16_t*)(head + 20) = FMT_ID;
+ *(int16_t*)(head + 22) = (int16_t)number_of_channels;
+ *(int32_t*)(head + 24) = sample_rate;
+ *(int32_t*)(head + 28) = sample_rate * number_of_channels * size;
+ *(int16_t*)(head + 32) = (int16_t)(size * number_of_channels);
+ *(int16_t*)(head + 34) = (int16_t)(size * 8);
+ memcpy(head + 36, DATA_CHUNK, strlen(DATA_CHUNK));
+ *(int32_t*)(head + 40) = data_size;
+ //計44byte(WAVE_HEADER_SIZE)
+ return buffer;
+}

VCECore/rgy_wav_parser.h

@@ -29,6 +29,9 @@
 #define __RGY_WAV_PARSER_H__
 
 #include <cstdint>
+#include <vector>
+
+static const uint32_t WAVE_HEADER_SIZE = 44;
 
 struct RGYWAVHeader {
  char file_id[5]; // "RIFF"
@@ -46,6 +49,7 @@ struct RGYWAVHeader {
  uint32_t data_size; // samples * number of channels * bits per sample / 8 (Actual number of bytes)
 
  uint32_t parseHeader(const uint8_t *data);
+ std::vector<uint8_t> createHeader();
 };
 
 #endif //__RGY_WAV_PARSER_H__

VCEEnc/VCEEnc_readme.txt

@@ -181,7 +181,7 @@ Radeon RX550
 今後の更新で設定ファイルの互換性がなくなるかもしれません。
 
 【どうでもいいメモ】
-2023.06.xx (8.14)
+2023.06.07 (8.14)
 [VCEEncC]
 - SAR比使用時の出力を改善。
 - 複数のデバイスからGPUを選択する際、OpenCLの初期化に失敗したデバイスの優先度を落とすように。