diff --git a/include/srla.h b/include/srla.h
index 6885e14..d37ae21 100644
--- a/include/srla.h
+++ b/include/srla.h
@@ -42,7 +42,7 @@ struct SRLAHeader {
     uint32_t num_samples;                           /* 1チャンネルあたり総サンプル数  */
     uint32_t sampling_rate;                         /* サンプリングレート             */
     uint16_t bits_per_sample;                       /* サンプルあたりビット数         */
-    uint32_t num_samples_per_block;                 /* ブロックあたりサンプル数   */
+    uint32_t max_num_samples_per_block;             /* ブロックあたり最大サンプル数   */
     uint8_t preset;                                 /* パラメータプリセット         */
 };
 
diff --git a/include/srla_encoder.h b/include/srla_encoder.h
index e273503..c612aa7 100644
--- a/include/srla_encoder.h
+++ b/include/srla_encoder.h
@@ -9,7 +9,7 @@ struct SRLAEncodeParameter {
     uint16_t num_channels; /* 入力波形のチャンネル数 */
     uint16_t bits_per_sample; /* 入力波形のサンプルあたりビット数 */
     uint32_t sampling_rate; /* 入力波形のサンプリングレート */
-    uint32_t num_samples_per_block; /* ブロックあたりサンプル数 */
+    uint32_t max_num_samples_per_block; /* ブロックあたり最大サンプル数 */
     uint8_t preset; /* エンコードパラメータプリセット */
 };
 
diff --git a/libs/srla_decoder/src/srla_decoder.c b/libs/srla_decoder/src/srla_decoder.c
index f78003c..5c120d0 100644
--- a/libs/srla_decoder/src/srla_decoder.c
+++ b/libs/srla_decoder/src/srla_decoder.c
@@ -109,9 +109,9 @@ SRLAApiResult SRLADecoder_DecodeHeader(
     /* サンプルあたりビット数 */
     ByteArray_GetUint16BE(data_pos, &u16buf);
     tmp_header.bits_per_sample = u16buf;
-    /* ブロックあたりサンプル数 */
+    /* ブロックあたり最大サンプル数 */
     ByteArray_GetUint32BE(data_pos, &u32buf);
-    tmp_header.num_samples_per_block = u32buf;
+    tmp_header.max_num_samples_per_block = u32buf;
     /* パラメータプリセット */
     ByteArray_GetUint8(data_pos, &u8buf);
     tmp_header.preset = u8buf;
@@ -156,8 +156,8 @@ static SRLAError SRLADecoder_CheckHeaderFormat(const struct SRLAHeader *header)
     if (header->bits_per_sample == 0) {
         return SRLA_ERROR_INVALID_FORMAT;
     }
-    /* ブロックあたりサンプル数 */
-    if (header->num_samples_per_block == 0) {
+    /* ブロックあたり最大サンプル数 */
+    if (header->max_num_samples_per_block == 0) {
         return SRLA_ERROR_INVALID_FORMAT;
     }
     /* パラメータプリセット */
diff --git a/libs/srla_encoder/src/srla_encoder.c b/libs/srla_encoder/src/srla_encoder.c
index 41a80ed..c42526b 100644
--- a/libs/srla_encoder/src/srla_encoder.c
+++ b/libs/srla_encoder/src/srla_encoder.c
@@ -77,8 +77,8 @@ SRLAApiResult SRLAEncoder_EncodeHeader(
     if (header->bits_per_sample == 0) {
         return SRLA_APIRESULT_INVALID_FORMAT;
     }
-    /* ブロックあたりサンプル数 */
-    if (header->num_samples_per_block == 0) {
+    /* ブロックあたり最大サンプル数 */
+    if (header->max_num_samples_per_block == 0) {
         return SRLA_APIRESULT_INVALID_FORMAT;
     }
     /* パラメータプリセット */
@@ -108,8 +108,8 @@ SRLAApiResult SRLAEncoder_EncodeHeader(
     ByteArray_PutUint32BE(data_pos, header->sampling_rate);
     /* サンプルあたりビット数 */
     ByteArray_PutUint16BE(data_pos, header->bits_per_sample);
-    /* ブロックあたりサンプル数 */
-    ByteArray_PutUint32BE(data_pos, header->num_samples_per_block);
+    /* ブロックあたり最大サンプル数 */
+    ByteArray_PutUint32BE(data_pos, header->max_num_samples_per_block);
     /* パラメータプリセット */
     ByteArray_PutUint8(data_pos, header->preset);
 
@@ -154,7 +154,7 @@ static SRLAError SRLAEncoder_ConvertParameterToHeader(
     tmp_header.sampling_rate = parameter->sampling_rate;
     tmp_header.bits_per_sample = parameter->bits_per_sample;
     tmp_header.preset = parameter->preset;
-    tmp_header.num_samples_per_block = parameter->num_samples_per_block;
+    tmp_header.max_num_samples_per_block = parameter->max_num_samples_per_block;
 
     /* 成功終了 */
     (*header) = tmp_header;
@@ -374,12 +374,12 @@ SRLAApiResult SRLAEncoder_SetEncodeParameter(
     }
 
     /* エンコーダの容量を越えてないかチェック */
-    if ((encoder->max_num_samples_per_block < parameter->num_samples_per_block)
+    if ((encoder->max_num_samples_per_block < parameter->max_num_samples_per_block)
         || (encoder->max_num_channels < parameter->num_channels)) {
         return SRLA_APIRESULT_INSUFFICIENT_BUFFER;
     }
-    /* ブロックあたりサンプル数のセット */
-    tmp_header.num_samples_per_block = parameter->num_samples_per_block;
+    /* ブロックあたり最大サンプル数のセット */
+    tmp_header.max_num_samples_per_block = parameter->max_num_samples_per_block;
 
     /* ヘッダ設定 */
     encoder->header = tmp_header;
@@ -890,7 +890,7 @@ SRLAApiResult SRLAEncoder_EncodeBlock(
     }
 
     /* エンコードサンプル数チェック */
-    if (num_samples > header->num_samples_per_block) {
+    if (num_samples > header->max_num_samples_per_block) {
         return SRLA_APIRESULT_INSUFFICIENT_BUFFER;
     }
 
@@ -1000,7 +1000,7 @@ SRLAApiResult SRLAEncoder_EncodeWhole(
 
         /* エンコードサンプル数の確定 */
         num_encode_samples
-            = SRLAUTILITY_MIN(header->num_samples_per_block, num_samples - progress);
+            = SRLAUTILITY_MIN(header->max_num_samples_per_block, num_samples - progress);
 
         /* サンプル参照位置のセット */
         for (ch = 0; ch < header->num_channels; ch++) {
diff --git a/test/srla_decoder/srla_decoder_test.cpp b/test/srla_decoder/srla_decoder_test.cpp
index f4f33d1..73d28cb 100644
--- a/test/srla_decoder/srla_decoder_test.cpp
+++ b/test/srla_decoder/srla_decoder_test.cpp
@@ -13,15 +13,15 @@ extern "C" {
 /* 有効なヘッダをセット */
 #define SRLA_SetValidHeader(p_header)\
     do {\
-        struct SRLAHeader *header__p       = p_header;\
-        header__p->format_version           = SRLA_FORMAT_VERSION;\
-        header__p->codec_version            = SRLA_CODEC_VERSION;\
-        header__p->num_channels             = 1;\
-        header__p->sampling_rate            = 44100;\
-        header__p->bits_per_sample          = 16;\
-        header__p->num_samples              = 8192;\
-        header__p->num_samples_per_block    = 1024;\
-        header__p->preset                   = 0;\
+        struct SRLAHeader *header__p            = p_header;\
+        header__p->format_version               = SRLA_FORMAT_VERSION;\
+        header__p->codec_version                = SRLA_CODEC_VERSION;\
+        header__p->num_channels                 = 1;\
+        header__p->sampling_rate                = 44100;\
+        header__p->bits_per_sample              = 16;\
+        header__p->num_samples                  = 8192;\
+        header__p->max_num_samples_per_block    = 1024;\
+        header__p->preset                       = 0;\
     } while (0);
 
 /* ヘッダにある情報からエンコードパラメータを作成 */
@@ -32,7 +32,7 @@ extern "C" {
         param__p->num_channels = header__p->num_channels;\
         param__p->sampling_rate = header__p->sampling_rate;\
         param__p->bits_per_sample = header__p->bits_per_sample;\
-        param__p->num_samples_per_block = header__p->num_samples_per_block;\
+        param__p->max_num_samples_per_block = header__p->max_num_samples_per_block;\
         param__p->preset = header__p->preset;\
     } while (0);
 
@@ -86,7 +86,7 @@ TEST(SRLADecoderTest, DecodeHeaderTest)
         EXPECT_EQ(header.sampling_rate, tmp_header.sampling_rate);
         EXPECT_EQ(header.bits_per_sample, tmp_header.bits_per_sample);
         EXPECT_EQ(header.num_samples, tmp_header.num_samples);
-        EXPECT_EQ(header.num_samples_per_block, tmp_header.num_samples_per_block);
+        EXPECT_EQ(header.max_num_samples_per_block, tmp_header.max_num_samples_per_block);
         EXPECT_EQ(header.preset, tmp_header.preset);
     }
 
@@ -162,7 +162,7 @@ TEST(SRLADecoderTest, DecodeHeaderTest)
         EXPECT_EQ(SRLA_APIRESULT_OK, SRLADecoder_DecodeHeader(data, sizeof(data), &getheader));
         EXPECT_EQ(SRLA_ERROR_INVALID_FORMAT, SRLADecoder_CheckHeaderFormat(&getheader));
 
-        /* 異常なブロックあたりサンプル数 */
+        /* 異常なブロックあたり最大サンプル数 */
         memcpy(data, valid_data, sizeof(valid_data));
         memset(&getheader, 0xCD, sizeof(getheader));
         ByteArray_WriteUint32BE(&data[24], 0);
@@ -322,12 +322,12 @@ TEST(SRLADecoderTest, DecodeBlockTest)
         SRLADecoder_SetValidConfig(&config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * header.num_channels * header.num_samples_per_block * header.bits_per_sample) / 8;
+        sufficient_size = (2 * header.num_channels * header.max_num_samples_per_block * header.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < header.num_channels; ch++) {
-            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.num_samples_per_block);
+            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.max_num_samples_per_block);
         }
 
         /* デコーダ作成 */
@@ -336,7 +336,7 @@ TEST(SRLADecoderTest, DecodeBlockTest)
 
         /* ヘッダセット前にデコーダしようとする */
         EXPECT_EQ(SRLA_APIRESULT_PARAMETER_NOT_SET,
-                SRLADecoder_DecodeBlock(decoder, data, sufficient_size, output, header.num_channels, header.num_samples_per_block, &output_size, &out_num_samples));
+                SRLADecoder_DecodeBlock(decoder, data, sufficient_size, output, header.num_channels, header.max_num_samples_per_block, &output_size, &out_num_samples));
 
         /* ヘッダをセット */
         EXPECT_EQ(SRLA_APIRESULT_OK, SRLADecoder_SetHeader(decoder, &header));
@@ -367,13 +367,13 @@ TEST(SRLADecoderTest, DecodeBlockTest)
         SRLADecoder_SetValidConfig(&decoder_config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * header.num_channels * header.num_samples_per_block * header.bits_per_sample) / 8;
+        sufficient_size = (2 * header.num_channels * header.max_num_samples_per_block * header.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < header.num_channels; ch++) {
-            input[ch] = (int32_t *)malloc(sizeof(int32_t) * header.num_samples_per_block);
-            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.num_samples_per_block);
+            input[ch] = (int32_t *)malloc(sizeof(int32_t) * header.max_num_samples_per_block);
+            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.max_num_samples_per_block);
         }
 
         /* エンコーダデコーダ作成 */
@@ -384,7 +384,7 @@ TEST(SRLADecoderTest, DecodeBlockTest)
 
         /* 入力に無音セット */
         for (ch = 0; ch < header.num_channels; ch++) {
-            memset(input[ch], 0, sizeof(int32_t) * header.num_samples_per_block);
+            memset(input[ch], 0, sizeof(int32_t) * header.max_num_samples_per_block);
         }
 
         /* ヘッダを元にパラメータを設定 */
@@ -393,7 +393,7 @@ TEST(SRLADecoderTest, DecodeBlockTest)
         /* 入力データをエンコード */
         EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_SetEncodeParameter(encoder, &parameter));
         EXPECT_EQ(SRLA_APIRESULT_OK,
-                SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+                SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
 
         /* エンコードデータを簡易チェック */
         EXPECT_TRUE(output_size > SRLA_HEADER_SIZE);
@@ -404,13 +404,13 @@ TEST(SRLADecoderTest, DecodeBlockTest)
         EXPECT_EQ(SRLA_APIRESULT_OK, SRLADecoder_SetHeader(decoder, &tmp_header));
         EXPECT_EQ(SRLA_APIRESULT_OK,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
 
         /* 出力チェック */
         EXPECT_EQ(output_size - SRLA_HEADER_SIZE, decode_output_size);
-        EXPECT_EQ(header.num_samples_per_block, out_num_samples);
+        EXPECT_EQ(header.max_num_samples_per_block, out_num_samples);
         for (ch = 0; ch < header.num_channels; ch++) {
-            EXPECT_EQ(0, memcmp(input[ch], output[ch], sizeof(int32_t) * header.num_samples_per_block));
+            EXPECT_EQ(0, memcmp(input[ch], output[ch], sizeof(int32_t) * header.max_num_samples_per_block));
         }
 
         /* 領域の開放 */
@@ -441,13 +441,13 @@ TEST(SRLADecoderTest, DecodeBlockTest)
         SRLADecoder_SetValidConfig(&decoder_config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * header.num_channels * header.num_samples_per_block * header.bits_per_sample) / 8;
+        sufficient_size = (2 * header.num_channels * header.max_num_samples_per_block * header.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < header.num_channels; ch++) {
-            input[ch] = (int32_t *)malloc(sizeof(int32_t) * header.num_samples_per_block);
-            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.num_samples_per_block);
+            input[ch] = (int32_t *)malloc(sizeof(int32_t) * header.max_num_samples_per_block);
+            output[ch] = (int32_t *)malloc(sizeof(int32_t) * header.max_num_samples_per_block);
         }
 
         /* エンコーダデコーダ作成 */
@@ -458,7 +458,7 @@ TEST(SRLADecoderTest, DecodeBlockTest)
 
         /* 入力に無音セット */
         for (ch = 0; ch < header.num_channels; ch++) {
-            memset(input[ch], 0, sizeof(int32_t) * header.num_samples_per_block);
+            memset(input[ch], 0, sizeof(int32_t) * header.max_num_samples_per_block);
         }
 
         /* ヘッダを元にパラメータを設定 */
@@ -466,7 +466,7 @@ TEST(SRLADecoderTest, DecodeBlockTest)
 
         /* 入力データをエンコード */
         EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_SetEncodeParameter(encoder, &parameter));
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
 
         /* エンコードデータを簡易チェック */
         EXPECT_TRUE(output_size > SRLA_HEADER_SIZE);
@@ -478,52 +478,52 @@ TEST(SRLADecoderTest, DecodeBlockTest)
 
         /* 不正な引数 */
         EXPECT_EQ(SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLADecoder_DecodeBlock(NULL, data, output_size, output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                SRLADecoder_DecodeBlock(NULL, data, output_size, output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         EXPECT_EQ(SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLADecoder_DecodeBlock(decoder, NULL, output_size, output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                SRLADecoder_DecodeBlock(decoder, NULL, output_size, output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         EXPECT_EQ(SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLADecoder_DecodeBlock(decoder, data, output_size, NULL, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                SRLADecoder_DecodeBlock(decoder, data, output_size, NULL, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         EXPECT_EQ(SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLADecoder_DecodeBlock(decoder, data, output_size, output, header.num_channels, tmp_header.num_samples_per_block, NULL, &out_num_samples));
+                SRLADecoder_DecodeBlock(decoder, data, output_size, output, header.num_channels, tmp_header.max_num_samples_per_block, NULL, &out_num_samples));
         EXPECT_EQ(SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLADecoder_DecodeBlock(decoder, data, output_size, output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, NULL));
+                SRLADecoder_DecodeBlock(decoder, data, output_size, output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, NULL));
 
         /* データサイズ不足 */
         EXPECT_EQ(SRLA_APIRESULT_INSUFFICIENT_DATA,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE - 1,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
 
         /* データを一部破壊した場合にエラーを返すか */
 
         /* 同期コード（データ先頭16bit）破壊 */
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
         data[SRLA_HEADER_SIZE] ^= 0xFF;
         EXPECT_EQ(SRLA_APIRESULT_INVALID_FORMAT,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
         data[SRLA_HEADER_SIZE + 1] ^= 0xFF;
         EXPECT_EQ(SRLA_APIRESULT_INVALID_FORMAT,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         /* ブロックデータタイプ不正: データ破損検知 */
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
         data[SRLA_HEADER_SIZE + 8] = 0xC0;
         EXPECT_EQ(SRLA_APIRESULT_DETECT_DATA_CORRUPTION,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         /* ブロックチャンネルあたりサンプル数不正: データ破損検知 */
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
         data[SRLA_HEADER_SIZE + 9] ^= 0xFF;
         EXPECT_EQ(SRLA_APIRESULT_DETECT_DATA_CORRUPTION,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
         /* データの末尾1byteがビット反転: データ破損検知 */
-        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.num_samples_per_block, data, sufficient_size, &output_size));
+        EXPECT_EQ(SRLA_APIRESULT_OK, SRLAEncoder_EncodeWhole(encoder, input, header.max_num_samples_per_block, data, sufficient_size, &output_size));
         data[output_size - 1] ^= 0xEF; /* note: Fletcherは0xFFのビット反転の破損を検知できない（mod 255の都合上） */
         EXPECT_EQ(SRLA_APIRESULT_DETECT_DATA_CORRUPTION,
                 SRLADecoder_DecodeBlock(decoder, data + SRLA_HEADER_SIZE, output_size - SRLA_HEADER_SIZE,
-                    output, header.num_channels, tmp_header.num_samples_per_block, &decode_output_size, &out_num_samples));
+                    output, header.num_channels, tmp_header.max_num_samples_per_block, &decode_output_size, &out_num_samples));
 
         /* 領域の開放 */
         for (ch = 0; ch < header.num_channels; ch++) {
diff --git a/test/srla_encode_decode/main.cpp b/test/srla_encode_decode/main.cpp
index ae115e7..4bd220a 100644
--- a/test/srla_encode_decode/main.cpp
+++ b/test/srla_encode_decode/main.cpp
@@ -242,7 +242,7 @@ static int32_t SRLAEncodeDecodeTest_ExecuteTestCase(const struct EncodeDecodeTes
     /* エンコード・デコードコンフィグ作成 */
     /* FIXME: 仮値 */
     encoder_config.max_num_channels          = num_channels;
-    encoder_config.max_num_samples_per_block = test_case->encode_parameter.num_samples_per_block;
+    encoder_config.max_num_samples_per_block = test_case->encode_parameter.max_num_samples_per_block;
     encoder_config.max_num_parameters        = 32;
     decoder_config.max_num_channels          = num_channels;
     decoder_config.max_num_parameters        = 32;
diff --git a/test/srla_encoder/srla_encoder_test.cpp b/test/srla_encoder/srla_encoder_test.cpp
index a3e93d4..9e2fd3c 100644
--- a/test/srla_encoder/srla_encoder_test.cpp
+++ b/test/srla_encoder/srla_encoder_test.cpp
@@ -11,26 +11,26 @@ extern "C" {
 /* 有効なヘッダをセット */
 #define SRLA_SetValidHeader(p_header)\
     do {\
-        struct SRLAHeader *header__p       = p_header;\
-        header__p->format_version           = SRLA_FORMAT_VERSION;\
-        header__p->codec_version            = SRLA_CODEC_VERSION;\
-        header__p->num_channels             = 1;\
-        header__p->sampling_rate            = 44100;\
-        header__p->bits_per_sample          = 16;\
-        header__p->num_samples              = 1024;\
-        header__p->num_samples_per_block    = 32;\
-        header__p->preset                   = 0;\
+        struct SRLAHeader *header__p            = p_header;\
+        header__p->format_version               = SRLA_FORMAT_VERSION;\
+        header__p->codec_version                = SRLA_CODEC_VERSION;\
+        header__p->num_channels                 = 1;\
+        header__p->sampling_rate                = 44100;\
+        header__p->bits_per_sample              = 16;\
+        header__p->num_samples                  = 1024;\
+        header__p->max_num_samples_per_block    = 32;\
+        header__p->preset                       = 0;\
     } while (0);
 
 /* 有効なエンコードパラメータをセット */
 #define SRLAEncoder_SetValidEncodeParameter(p_parameter)\
     do {\
         struct SRLAEncodeParameter *param__p = p_parameter;\
-        param__p->num_channels          = 1;\
-        param__p->bits_per_sample       = 16;\
-        param__p->sampling_rate         = 44100;\
-        param__p->num_samples_per_block = 1024;\
-        param__p->preset                = 0;\
+        param__p->num_channels              = 1;\
+        param__p->bits_per_sample           = 16;\
+        param__p->sampling_rate             = 44100;\
+        param__p->max_num_samples_per_block = 1024;\
+        param__p->preset                    = 0;\
     } while (0);
 
 /* 有効なコンフィグをセット */
@@ -95,9 +95,9 @@ TEST(SRLAEncoderTest, EncodeHeaderTest)
         header.bits_per_sample = 0;
         EXPECT_EQ(SRLA_APIRESULT_INVALID_FORMAT, SRLAEncoder_EncodeHeader(&header, data, sizeof(data)));
 
-        /* 異常なブロックあたりサンプル数 */
+        /* 異常なブロックあたり最大サンプル数 */
         SRLA_SetValidHeader(&header);
-        header.num_samples_per_block = 0;
+        header.max_num_samples_per_block = 0;
         EXPECT_EQ(SRLA_APIRESULT_INVALID_FORMAT, SRLAEncoder_EncodeHeader(&header, data, sizeof(data)));
 
         /* 異常なプリセット */
@@ -264,12 +264,12 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         SRLAEncoder_SetValidConfig(&config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * parameter.num_channels * parameter.num_samples_per_block * parameter.bits_per_sample) / 8;
+        sufficient_size = (2 * parameter.num_channels * parameter.max_num_samples_per_block * parameter.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < parameter.num_channels; ch++) {
-            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.num_samples_per_block);
+            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.max_num_samples_per_block);
         }
 
         /* エンコーダ作成 */
@@ -279,11 +279,11 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         /* 無効な引数を渡す */
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLAEncoder_EncodeBlock(NULL, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(NULL, input, parameter.max_num_samples_per_block,
                     data, sufficient_size, &output_size));
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLAEncoder_EncodeBlock(encoder, NULL, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, NULL, parameter.max_num_samples_per_block,
                     data, sufficient_size, &output_size));
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
@@ -291,15 +291,15 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
                     data, sufficient_size, &output_size));
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     NULL, sufficient_size, &output_size));
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     data, 0, &output_size));
         EXPECT_EQ(
                 SRLA_APIRESULT_INVALID_ARGUMENT,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     data, sufficient_size, NULL));
 
         /* 領域の開放 */
@@ -323,14 +323,14 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         SRLAEncoder_SetValidConfig(&config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * parameter.num_channels * parameter.num_samples_per_block * parameter.bits_per_sample) / 8;
+        sufficient_size = (2 * parameter.num_channels * parameter.max_num_samples_per_block * parameter.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < parameter.num_channels; ch++) {
-            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.num_samples_per_block);
+            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.max_num_samples_per_block);
             /* 無音セット */
-            memset(input[ch], 0, sizeof(int32_t) * parameter.num_samples_per_block);
+            memset(input[ch], 0, sizeof(int32_t) * parameter.max_num_samples_per_block);
         }
 
         /* エンコーダ作成 */
@@ -340,7 +340,7 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         /* パラメータセット前にエンコード: エラー */
         EXPECT_EQ(
                 SRLA_APIRESULT_PARAMETER_NOT_SET,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     data, sufficient_size, &output_size));
 
         /* パラメータ設定 */
@@ -351,7 +351,7 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         /* 1ブロックエンコード */
         EXPECT_EQ(
                 SRLA_APIRESULT_OK,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     data, sufficient_size, &output_size));
 
         /* 領域の開放 */
@@ -377,14 +377,14 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         SRLAEncoder_SetValidConfig(&config);
 
         /* 十分なデータサイズ */
-        sufficient_size = (2 * parameter.num_channels * parameter.num_samples_per_block * parameter.bits_per_sample) / 8;
+        sufficient_size = (2 * parameter.num_channels * parameter.max_num_samples_per_block * parameter.bits_per_sample) / 8;
 
         /* データ領域確保 */
         data = (uint8_t *)malloc(sufficient_size);
         for (ch = 0; ch < parameter.num_channels; ch++) {
-            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.num_samples_per_block);
+            input[ch] = (int32_t *)malloc(sizeof(int32_t) * parameter.max_num_samples_per_block);
             /* 無音セット */
-            memset(input[ch], 0, sizeof(int32_t) * parameter.num_samples_per_block);
+            memset(input[ch], 0, sizeof(int32_t) * parameter.max_num_samples_per_block);
         }
 
         /* エンコーダ作成 */
@@ -399,7 +399,7 @@ TEST(SRLAEncoderTest, EncodeBlockTest)
         /* 1ブロックエンコード */
         EXPECT_EQ(
                 SRLA_APIRESULT_OK,
-                SRLAEncoder_EncodeBlock(encoder, input, parameter.num_samples_per_block,
+                SRLAEncoder_EncodeBlock(encoder, input, parameter.max_num_samples_per_block,
                     data, sufficient_size, &output_size));
 
         /* ブロック先頭の同期コードがあるので2バイトよりは大きいはず */
diff --git a/tools/srla_codec/srla_codec.c b/tools/srla_codec/srla_codec.c
index dd45e4f..b75bfab 100644
--- a/tools/srla_codec/srla_codec.c
+++ b/tools/srla_codec/srla_codec.c
@@ -9,7 +9,7 @@
 #include <sys/stat.h>
 
 /* デフォルトのブロックサンプル数 */
-#define DEFALUT_NUM_BLOCK_SAMPLES 4096
+#define DEFALUT_MAX_NUM_BLOCK_SAMPLES 4096
 #define PRE_TOSTRING(arg) #arg
 #define TOSTRING(arg) PRE_TOSTRING(arg)
 
@@ -24,7 +24,7 @@ static struct CommandLineParserSpecification command_line_spec[] = {
         COMMAND_LINE_PARSER_FALSE, NULL, COMMAND_LINE_PARSER_FALSE },
     { 'm', "mode", "Specify compress mode: 0(fast), ..., 3(high compression) (default:0)",
         COMMAND_LINE_PARSER_TRUE, NULL, COMMAND_LINE_PARSER_FALSE },
-    { 'b', "block-size", "Specify number of block samples (default:" TOSTRING(DEFALUT_NUM_BLOCK_SAMPLES) ")",
+    { 'b', "max-block-size", "Specify max number of block samples (default:" TOSTRING(DEFALUT_MAX_NUM_BLOCK_SAMPLES) ")",
         COMMAND_LINE_PARSER_TRUE, NULL, COMMAND_LINE_PARSER_FALSE },
     { 'c', "no-checksum-check", "Whether to NOT check checksum at decoding (default:no)",
         COMMAND_LINE_PARSER_FALSE, NULL, COMMAND_LINE_PARSER_FALSE },
@@ -36,7 +36,7 @@ static struct CommandLineParserSpecification command_line_spec[] = {
 };
 
 /* エンコード 成功時は0、失敗時は0以外を返す */
-static int do_encode(const char *in_filename, const char *out_filename, uint32_t encode_preset_no, uint32_t num_block_samples)
+static int do_encode(const char *in_filename, const char *out_filename, uint32_t encode_preset_no, uint32_t max_num_block_samples)
 {
     FILE *out_fp;
     struct WAVFile *in_wav;
@@ -52,7 +52,7 @@ static int do_encode(const char *in_filename, const char *out_filename, uint32_t
 
     /* エンコーダ作成 */
     config.max_num_channels = SRLA_MAX_NUM_CHANNELS;
-    config.max_num_samples_per_block = num_block_samples;
+    config.max_num_samples_per_block = max_num_block_samples;
     config.max_num_parameters = SRLA_MAX_COEFFICIENT_ORDER;
     if ((encoder = SRLAEncoder_Create(&config, NULL, 0)) == NULL) {
         fprintf(stderr, "Failed to create encoder handle. \n");
@@ -71,7 +71,7 @@ static int do_encode(const char *in_filename, const char *out_filename, uint32_t
     parameter.num_channels = (uint16_t)num_channels;
     parameter.bits_per_sample = (uint16_t)in_wav->format.bits_per_sample;
     parameter.sampling_rate = in_wav->format.sampling_rate;
-    parameter.num_samples_per_block = num_block_samples;
+    parameter.max_num_samples_per_block = max_num_block_samples;
     /* プリセットの反映 */
     parameter.preset = (uint8_t)encode_preset_no;
     if ((ret = SRLAEncoder_SetEncodeParameter(encoder, &parameter)) != SRLA_APIRESULT_OK) {
@@ -111,7 +111,7 @@ static int do_encode(const char *in_filename, const char *out_filename, uint32_t
         header.sampling_rate = parameter.sampling_rate;
         header.bits_per_sample = parameter.bits_per_sample;
         header.preset = parameter.preset;
-        header.num_samples_per_block = parameter.num_samples_per_block;
+        header.max_num_samples_per_block = parameter.max_num_samples_per_block;
         if ((ret = SRLAEncoder_EncodeHeader(&header, data_pos, buffer_size))
                 != SRLA_APIRESULT_OK) {
             fprintf(stderr, "Failed to encode header! ret:%d \n", ret);
@@ -126,7 +126,7 @@ static int do_encode(const char *in_filename, const char *out_filename, uint32_t
             uint32_t ch, write_size;
             const int32_t *input_ptr[SRLA_MAX_NUM_CHANNELS];
             /* エンコードサンプル数の確定 */
-            const uint32_t num_encode_samples = SRLACODEC_MIN(num_block_samples, num_samples - progress);
+            const uint32_t num_encode_samples = SRLACODEC_MIN(max_num_block_samples, num_samples - progress);
 
             /* サンプル参照位置のセット */
             for (ch = 0; ch < (uint32_t)num_channels; ch++) {
@@ -337,7 +337,7 @@ int main(int argc, char** argv)
     } else if (CommandLineParser_GetOptionAcquired(command_line_spec, "encode") == COMMAND_LINE_PARSER_TRUE) {
         /* エンコード */
         uint32_t encode_preset_no = 0;
-        uint32_t num_block_samples = DEFALUT_NUM_BLOCK_SAMPLES;
+        uint32_t max_num_block_samples = DEFALUT_MAX_NUM_BLOCK_SAMPLES;
         /* エンコードプリセット番号取得 */
         if (CommandLineParser_GetOptionAcquired(command_line_spec, "mode") == COMMAND_LINE_PARSER_TRUE) {
             char *e;
@@ -353,21 +353,21 @@ int main(int argc, char** argv)
             }
         }
         /* ブロックあたりサンプル数の取得 */
-        if (CommandLineParser_GetOptionAcquired(command_line_spec, "block-size") == COMMAND_LINE_PARSER_TRUE) {
+        if (CommandLineParser_GetOptionAcquired(command_line_spec, "max-block-size") == COMMAND_LINE_PARSER_TRUE) {
             char *e;
             const char *lstr = CommandLineParser_GetArgumentString(command_line_spec, "block-size");
-            num_block_samples = (uint32_t)strtol(lstr, &e, 10);
+            max_num_block_samples = (uint32_t)strtol(lstr, &e, 10);
             if (*e != '\0') {
                 fprintf(stderr, "%s: invalid number of block samples. (irregular character found in %s at %s)\n", argv[0], lstr, e);
                 return 1;
             }
-            if ((num_block_samples == 0) || (num_block_samples >= (1U << 16))) {
+            if ((max_num_block_samples == 0) || (max_num_block_samples >= (1U << 16))) {
                 fprintf(stderr, "%s: number of block samples is out of range. \n", argv[0]);
                 return 1;
             }
         }
         /* 一括エンコード実行 */
-        if (do_encode(input_file, output_file, encode_preset_no, num_block_samples) != 0) {
+        if (do_encode(input_file, output_file, encode_preset_no, max_num_block_samples) != 0) {
             fprintf(stderr, "%s: failed to encode %s. \n", argv[0], input_file);
             return 1;
         }