LibImportExport Namespace Reference

Namespaces
namespace	Test

Functions
std::optional< LibFileFormats::AcidizerTags >	GetAcidizerTags (SNDFILE &file, const std::vector< std::string > &trustedDistributors)
	Get the Acidizer tags from a file if from a trusted distributor. More...
	TEST_CASE ("GetAcidizerTags")

Detailed Description

---

Audacity: A Digital Audio Editor

GetAcidizerTags.cpp

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

LibsndfileTagger.h

Matthieu Hodgkinson

---

Audacity: A Digital Audio Editor

GetAcidizerTagsTests.cpp

Matthieu Hodgkinson

Function Documentation

GetAcidizerTags()

std::optional< LibFileFormats::AcidizerTags > IMPORT_EXPORT_API LibImportExport::GetAcidizerTags	(	SNDFILE &	file,
		const std::vector< std::string > &	trustedDistributors
	)

Get the Acidizer tags from a file if from a trusted distributor.

Acidizer tags are looked for in the header ( https://exiftool.org/TagNames/RIFF.html#Acidizer). Metadata with incorrect BPM values are nevertheless very common, so the function will return non-null only if the distributor is trusted. The distributor is looked for as the "DistributedBy" RIFF info tag (https://exiftool.org/TagNames/RIFF.html#Info).

Definition at line 21 of file GetAcidizerTags.cpp.

{
   SF_LOOP_INFO loopInfo;
   if (
      sf_command(&file, SFC_GET_LOOP_INFO, &loopInfo, sizeof(loopInfo)) ==
      SF_FALSE)
      return {};
 
   if (
      loopInfo.loop_mode == SF_LOOP_BACKWARD ||
      loopInfo.loop_mode == SF_LOOP_ALTERNATING)
      // Don't know what that is:
      return {};
 
   if (loopInfo.loop_mode == SF_LOOP_NONE)
      return LibFileFormats::AcidizerTags::OneShot {};
 
   if (loopInfo.num_beats != 0)
   {
      // Forward loop with number of beats set: all files like these I have seen
      // so far were correctly tagged.
      SF_INFO info;
      std::memset(&info, 0, sizeof(info));
      sf_command(&file, SFC_GET_CURRENT_SF_INFO, &info, sizeof(info));
      if (info.samplerate == 0 || info.frames == 0)
         return {};
      const auto duration = 1. * info.frames / info.samplerate;
      return LibFileFormats::AcidizerTags::Loop { 60. * loopInfo.num_beats /
                                                  duration };
   }
 
   // There is loop info, but in some unexpected combination. We don't trust it
   // unless it is from a trusted distributor.
   SF_CHUNK_INFO info;
   constexpr std::array<char, 4> listId = { 'L', 'I', 'S', 'T' };
   std::copy(listId.begin(), listId.end(), info.id);
   std::fill(info.id + sizeof(listId), info.id + sizeof(info.id), '\0');
   info.id_size = sizeof(listId);
   auto chunkIt = sf_get_chunk_iterator(&file, &info);
   while (chunkIt)
   {
      if (sf_get_chunk_size(chunkIt, &info) != SF_ERR_NO_ERROR)
         break;
      constexpr std::array<char, 4> INFO = { 'I', 'N', 'F', 'O' };
      constexpr std::array<char, 4> IDST = { 'I', 'D', 'S', 'T' };
      // Another 4 bytes after INFO and IDST that indicates the size of the data
      constexpr auto dataPos = sizeof(INFO) + sizeof(IDST) + 4;
      if (info.datalen < dataPos)
         // Not the expected data
         continue;
      const auto chars = std::make_unique<char[]>(info.datalen);
      info.data = chars.get();
      if (sf_get_chunk_data(chunkIt, &info) != SF_ERR_NO_ERROR)
         break;
      chunkIt = sf_next_chunk_iterator(chunkIt);
 
      auto pos = 0;
      const auto firstFour =
         std::string { chars.get() + pos, chars.get() + pos + sizeof(INFO) };
      if (firstFour != std::string { INFO.data(), INFO.size() })
         continue;
 
      pos += sizeof(INFO);
      const auto nextFour =
         std::string { chars.get() + pos, chars.get() + pos + sizeof(IDST) };
      if (nextFour != std::string { IDST.data(), IDST.size() })
         continue;
 
      // Ignore trailing nulls, which could be the result of byte-padding for
      // word alignment:
      const auto charsEnd = std::find_if(
         chars.get() + dataPos, chars.get() + info.datalen,
         [](const char c) { return c == '\0'; });
      const auto distributor = std::string { chars.get() + 12, charsEnd };
      const auto isTrusted =
         std::find(
            trustedDistributors.begin(), trustedDistributors.end(),
            distributor) != trustedDistributors.end();
      if (isTrusted)
         // Later we may want to get the key, too, but for now we're only
         // interested in BPM.
         return LibFileFormats::AcidizerTags::Loop { loopInfo.bpm };
   }
 
   // No luck:
   return {};
}

References LibFileFormats::AcidizerTags::Loop::bpm, and staffpad::vo::copy().

Referenced by PCMImportFileHandle::Import(), and TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

TEST_CASE()

LibImportExport::TEST_CASE

(

"GetAcidizerTags"

)

Definition at line 27 of file GetAcidizerTagsTests.cpp.

{
   SECTION("returns null if")
   {
      SECTION("there is no loop info")
      {
         Test::LibsndfileTagger tagger;
         const auto actual = GetAcidizerTags(tagger.ReopenInReadMode(), {});
         REQUIRE(!actual.has_value());
      }
      SECTION("tempo is set but the distributor isn't whitelisted")
      {
         Test::LibsndfileTagger tagger;
         tagger.AddAcidizerTags(AcidizerTags::Loop { 120. });
         tagger.AddDistributorInfo("Distributor Zen");
         const auto actual = GetAcidizerTags(
            tagger.ReopenInReadMode(),
            { "foo", "Distributor Z", "Distributor Zen 2" });
         REQUIRE(!actual.has_value());
      }
   }
 
   SECTION("returns valid info if")
   {
      SECTION("OneShot is set")
      {
         Test::LibsndfileTagger tagger;
         tagger.AddAcidizerTags(AcidizerTags::OneShot {});
         const auto actual = GetAcidizerTags(tagger.ReopenInReadMode(), {});
         REQUIRE(actual.has_value());
         REQUIRE(actual->isOneShot);
      }
      SECTION("Beats is set")
      {
         // 20 beats in 10 seconds -> 120 bpm.
         Test::LibsndfileTagger tagger { 10. };
         constexpr auto numBeats = 20;
         tagger.AddAcidizerTags(Test::AcidizerTags::Beats { numBeats });
         auto& file = tagger.ReopenInReadMode();
         const auto actual = GetAcidizerTags(file, {});
         REQUIRE(actual.has_value());
         SF_INFO info;
         sf_command(&file, SFC_GET_CURRENT_SF_INFO, &info, sizeof(SF_INFO));
         const auto durationAfterClose = 1. * info.frames / info.samplerate;
         const auto expectedBpm = numBeats * 60 / durationAfterClose;
         REQUIRE(actual->bpm == Approx(expectedBpm));
         REQUIRE(actual->isOneShot == false);
      };
      SECTION("Tempo is set and the distributor is whitelisted")
      {
         Test::LibsndfileTagger tagger;
         tagger.AddAcidizerTags(AcidizerTags::Loop { 120. });
         tagger.AddDistributorInfo("Trusted Distributor");
         const auto actual = GetAcidizerTags(
            tagger.ReopenInReadMode(), { "Trusted Distributor" });
         REQUIRE(actual.has_value());
         REQUIRE(actual->bpm == 120.);
         REQUIRE(actual->isOneShot == false);
      }
   }
}

References LibImportExport::Test::LibsndfileTagger::AddAcidizerTags(), LibImportExport::Test::LibsndfileTagger::AddDistributorInfo(), GetAcidizerTags(), and LibImportExport::Test::LibsndfileTagger::ReopenInReadMode().

Here is the call graph for this function: