DdsSubfile complete

Source/BinaryData.cpp

@@ -173,7 +173,7 @@ namespace LOTRO_DAT {
         return (header == 0x7801 || header == 0x789C || header == 0x78DA);
     }
 
-    void BinaryData::DecompressData(unsigned int offset) {
+    BinaryData BinaryData::DecompressData(unsigned int offset) const {
         const unsigned max_unpacked_size = 1024 * 1024 * 40; // Setting 40 MB as a maximum unpacked data;
 
         BinaryData decompressed(max_unpacked_size);
@@ -186,11 +186,26 @@ namespace LOTRO_DAT {
 		}
 
 		decompressed.size_ = (unsigned int)new_size;
-		*this = decompressed;
-		return;
+		return decompressed;
 	}
 
-    BinaryData BinaryData::CutData(long long first, long long last) {
+    BinaryData BinaryData::CompressData(unsigned int offset) const {
+        const unsigned max_file_size = 1024 * 1024 * 40; // Setting 40 MB as a maximum packed data;
+
+        BinaryData compressed(max_file_size);
+
+        uLongf new_size = max_file_size;
+        int res = compress2(compressed.data_, &new_size, data_ + offset, size_ - offset, 9);
+
+        if (res != 0) {
+            throw DatException("Bad BinaryData::CompressData() - compress failed!", DATA_EXCEPTION);
+        }
+
+        compressed.size_ = (unsigned int)new_size;
+        return compressed;
+    }
+
+    BinaryData BinaryData::CutData(long long first, long long last) const {
         if (last < 0)
             last = size();
 

Source/BinaryData.h

@@ -42,13 +42,14 @@ namespace LOTRO_DAT
 
         BinaryData& operator=(const BinaryData& data);
 
-        BinaryData CutData(long long first = 0, long long last = -1);
+        BinaryData CutData(long long first = 0, long long last = -1) const;
 
 		bool WriteToFile(const char *filename) const;
 		bool WriteToFile(const std::string &filename) const;
 
         bool CheckCompression() const;
-		void DecompressData(unsigned int offset = 0);
+		BinaryData DecompressData(unsigned int offset = 0) const;
+        BinaryData CompressData(unsigned int offset = 0) const;
 
     private:
         unsigned char *data_;

Source/DatFile.h

@@ -54,8 +54,8 @@ namespace LOTRO_DAT
 
     class DatFile
     {
-        friend class Subfile;
         friend class SubDirectory;
+        friend class Subfile;
     public:
         DatFile();
         explicit DatFile(const char* filename, int dat_id);
@@ -84,6 +84,8 @@ namespace LOTRO_DAT
 
         long long files_number() const;
 
+        void ReadData(BinaryData &data, long long size, long long offset = 0, long long data_offset = 0);
+
     private:
         FILE *file_handler_;
         SubDirectory *root_directory_;
@@ -94,7 +96,6 @@ namespace LOTRO_DAT
         void MakeDirectories();
         void MakeDictionary();
 
-        void ReadData(BinaryData &data, long long size, long long offset = 0, long long data_offset = 0);
         void WriteData(const BinaryData &data, long long size, long long offset = 0, long long data_offset = 0);
 
         long long constant1_;

Source/Subfile.cpp

@@ -77,12 +77,11 @@ namespace LOTRO_DAT {
         throw DatException("Bad Subfile::PrepareAsText() - function is not implemented for this type.", EXPORT_EXCEPTION);
     }
 
-    BinaryData& Subfile::MakeFromBinary(const BinaryData &data) {
+    BinaryData Subfile::MakeFromBinary(const BinaryData &data) {
         throw DatException("Bad Subfile::MakeFromBinary() - function is not implemented fot this type.", EXPORT_EXCEPTION);
     }
 
-    BinaryData& Subfile::MakeFromText(const std::string &text, const std::string &args, const std::string &args_order) {
+    BinaryData Subfile::MakeFromText(const std::string &text, const std::string &args, const std::string &args_order) {
         throw DatException("Bad Subfile::MakeFromText() - function is not implemented for this type.", EXPORT_EXCEPTION);
     }
-
 };

Source/Subfile.h

@@ -28,8 +28,8 @@ namespace LOTRO_DAT
         virtual bool PrepareAsBinary(BinaryData &data);
         virtual bool PrepareAsText(std::string &text, std::string &args, std::string &args_order);
 
-        virtual BinaryData& MakeFromBinary(const BinaryData &data);
-        virtual BinaryData& MakeFromText(const std::string &text, const std::string &args, const std::string &args_order);
+        virtual BinaryData MakeFromBinary(const BinaryData &data);
+        virtual BinaryData MakeFromText(const std::string &text, const std::string &args, const std::string &args_order);
 
         long long fragments_count() const;
         long long unknown1() const;
@@ -40,7 +40,7 @@ namespace LOTRO_DAT
         long long version() const;
         long long block_size() const;
 
-	private:
+	protected:
 		long long fragments_count_;
         long long unknown1_;
         long long file_id_;
@@ -50,11 +50,7 @@ namespace LOTRO_DAT
         long long version_;
         long long block_size_;
 
-        bool compressed_;
-
         DatFile *dat_;
-
-		BinaryData GetFileData(long long offset = 8) const;
     };
 }
 };

Source/Subfiles/DdsSubfile.cpp

@@ -1,558 +1,152 @@
-/*
-//
+///
 // Created by Иван_Архипов on 24.11.2017.
 //
 
 #include "DdsSubfile.h"
 
-//
-// Created by Иван_Архипов on 01.11.2017.
-//
-
-#include "Subfile.h"
-#include "BinaryData.h"
-#include "DatFile.h"
-#include "Common/DatException.h"
-#include "Database.h"
-#include "Common/CommonFunctions.h"
+#include "../BinaryData.h"
+#include "../DatFile.h"
+#include "../Common/DatException.h"
+#include "../Database.h"
+#include "../Common/CommonFunctions.h"
 
 #include <algorithm>
 
-const long long MAXSIZE = 50ll * 1024ll * 1024ll; // Setting maximal file size 50 MB; Files with size more than 50 mb
-// will be recognized as incorrect and passed.
-// This should be done because
-
-LOTRO_DAT::Subfile::Subfile() {
-    ext_ = UNKNOWN;
-    compressed_ = false;
-}
-
-LOTRO_DAT::Subfile::Subfile(DatFile *dat, long long fragments_count, long long unknown1, long long file_id, long long file_offset,
-                            long long file_size, long long timestamp, long long version, long long block_size) :
-        dat_(dat), fragments_count_(fragments_count), unknown1_(unknown1), file_id_(file_id), file_offset_(file_offset),
-        file_size_(file_size), timestamp_(timestamp), version_(version), block_size_(block_size) {
-
-    if (file_size_ > MAXSIZE)
-        throw DatException("Bad Subfile::Subfile() - File size is too much... Maybe it's incorrect..?", SUBFILE_EXCEPTION);
-    ext_ = GetExtension();
-
-    BinaryData header(20);
-    dat_->ReadData(header, 10, file_offset_ + 8);
-    compressed_ = header.CheckCompression();
-}
-
-long long LOTRO_DAT::Subfile::fragments_count() const {
-    return fragments_count_;
-}
-
-long long LOTRO_DAT::Subfile::unknown1() const {
-    return unknown1_;
-}
-
-long long LOTRO_DAT::Subfile::file_id() const {
-    return file_id_;
-}
-
-long long LOTRO_DAT::Subfile::file_offset() const {
-    return file_offset_;
-}
-
-long long LOTRO_DAT::Subfile::file_size() const {
-    return file_size_;
-}
-
-long long LOTRO_DAT::Subfile::timestamp() const {
-    return timestamp_;
-}
 
-long long LOTRO_DAT::Subfile::version() const {
-    return version_;
-}
+namespace LOTRO_DAT {
+    DdsSubfile::DdsSubfile() {}
 
-long long LOTRO_DAT::Subfile::block_size() const {
-    return block_size_;
-}
-
-LOTRO_DAT::FILE_TYPE LOTRO_DAT::Subfile::GetExtension() const {
-    // Text check based on file_id
-    if ((file_id_ >> 24ll) == 0x25ll)
-        return TEXT;
-
-    // Font check based on file_id
-    if ((file_id_ >> 24ll) == 0x42ll)
-        return FONT;
-
-    BinaryData header(64);
-    try {
-        dat_->ReadData(header, 64, (unsigned) file_offset_ + 8);
-    } catch (DatException &e) {
-        if (e.type() == READ_EXCEPTION) {
-            std::string err =
-                    "Bad Subfile::getExtension() - unable to read header of file with id = " + std::to_string(file_id()) +
-                    " and offset = " + std::to_string(file_offset());
-            throw DatException(err.c_str(), SUBFILE_EXCEPTION);
-        } else
-            throw e;
+    DdsSubfile::DdsSubfile(DatFile *dat, long long fragments_count, long long unknown1,
+                                      long long file_id, long long file_offset, long long file_size,
+                                      long long timestamp,
+                                      long long version, long long block_size)
+            : Subfile(dat, fragments_count, unknown1, file_id, file_offset, file_size, timestamp, version, block_size) {
+        BinaryData header(20);
+        dat_->ReadData(header, 10, file_offset_ + 8);
+        compressed_ = header.CheckCompression();
     }
 
-    // jpeg / dds check
-    if ((file_id_ >> 24ll) == 0x41ll) {
-        long long soi = header.ToNumber<2>(24);
-        long long marker = header.ToNumber<2>(26);
-
-        //auto markerSize = header.ToNumber<short>(28);
-        //auto four = header.ToNumber<int>(30);
-
-        if (soi == 0xD8FFll && marker == 0xE0FFll || marker == 0xE1FFll)
-            return JPG;
+    FILE_TYPE DdsSubfile::FileType() const {
         return DDS;
     }
 
-    // Ogg and Wav check
-    if (header[8] == 0x4F && header[9] == 0x67 && header[10] == 0x67 && header[11] == 0x53)
-        return OGG;
-    if (header[8] == 0x52 && header[9] == 0x49 && header[10] == 0x46 && header[11] == 0x46)
-        return WAV;
-
-    return UNKNOWN;
-}
-
-std::string LOTRO_DAT::Subfile::ExtensionToString(LOTRO_DAT::FILE_TYPE ext) const {
-    switch (ext)
-    {
-        case LOTRO_DAT::TEXT:
-            return ".txt";
-        case LOTRO_DAT::JPG:
-            return ".jpg";
-        case LOTRO_DAT::DDS:
-            return ".dds";
-        case LOTRO_DAT::WAV:
-            return ".wav";
-        case LOTRO_DAT::OGG:
-            return ".ogg";
-        case LOTRO_DAT::FONT:
-            return ".fontbin";
-        case LOTRO_DAT::UNKNOWN:
-            return ".unk";
-        default:
-            return "";
-    }
-}
-
-bool LOTRO_DAT::Subfile::PatchBinaryFile(const LOTRO_DAT::BinaryData &file) {
-    LOTRO_DAT::BinaryData data;
-
-    // Making data for placing in .dat, depending on file extension
-    switch (ext_)
-    {
-        case LOTRO_DAT::TEXT:
-            throw LOTRO_DAT::DatException("Bad Subfile::PatchBinaryFile() - trying to patch text file");
-        case LOTRO_DAT::JPG:
-            data = MakeFromJPG(file); break;
-        case LOTRO_DAT::DDS:
-            data = MakeFromDDS(file); break;
-        case LOTRO_DAT::WAV:
-            data = MakeFromWAV(file); break;
-        case LOTRO_DAT::OGG:
-            data = MakeFromOGG(file); break;
-        case LOTRO_DAT::FONT:
-            data = MakeFromFont(file); break;
-        case LOTRO_DAT::UNKNOWN:
-            data = MakeFromUnk(file); break;
-        default:
-            break;
-    }
-
-    if (block_size() >= data.size() + 8) {
-        dat_->WriteData(data, data.size(), file_offset() + 8);
-        return true;
-    }
-    throw DatException("Bad Subfile::PatchBinaryFile() - new data size is bigger, than block_size. This is not implemented yet"
-            , IMPORT_EXCEPTION);
-    return true;
-}
-
-bool LOTRO_DAT::Subfile::ExportFile(const char *filename) const {
-    try {
-        BinaryData data;
-
-        switch (ext_)
-        {
-            case LOTRO_DAT::TEXT:
-                return false;
-            case LOTRO_DAT::JPG:
-                data = PrepareAsJPG(); break;
-            case LOTRO_DAT::DDS:
-                data = PrepareAsDDS(); break;
-            case LOTRO_DAT::WAV:
-                data = PrepareAsWAV(); break;
-            case LOTRO_DAT::OGG:
-                data = PrepareAsOGG(); break;
-            case LOTRO_DAT::FONT:
-                data = PrepareAsFont(); break;
-            case LOTRO_DAT::UNKNOWN:
-                data = PrepareAsUnk(); break;
-            default:
-                break;
-        }
-
-        std::string s = std::string(filename) + std::string(ExtensionToString(ext_));
-        return data.WriteToFile(s);
-    }
-    catch (DatException &e) {
-        fprintf(stderr, "Caught exception while unpacking the file with id %lld and offset %lld. Continuing without this file...\n", file_id(), file_offset());
-        fprintf(stderr, "%s\n", e.what());
-        return false;
-    }
-}
-
-bool LOTRO_DAT::Subfile::ExportFile(Database *db) const {
-    try {
-        BinaryData data;
-        switch (ext_)
-        {
-            case LOTRO_DAT::TEXT:
-                return ExportFileAsTXT(db);
-            case LOTRO_DAT::JPG:
-                data = PrepareAsJPG(); break;
-            case LOTRO_DAT::DDS:
-                data = PrepareAsDDS(); break;
-            case LOTRO_DAT::WAV:
-                data = PrepareAsWAV(); break;
-            case LOTRO_DAT::OGG:
-                data = PrepareAsOGG(); break;
-            case LOTRO_DAT::FONT:
-                data = PrepareAsFont(); break;
-            case LOTRO_DAT::UNKNOWN:
-                data = PrepareAsUnk(); break;
-            default:
-                break;
-        }
-
-        db->PushBinaryFile(file_id_, data);
-        return true;
-    }
-    catch (DatException &e) {
-        fprintf(stderr, "Caught exception while unpacking the file with id %lld and offset %lld. Continuing without this file...\n", file_id(), file_offset());
-        fprintf(stderr, "%s\n", e.what());
-        return false;
-    }
-}
-
-bool LOTRO_DAT::Subfile::ExportFileAsTXT(Database *db) const {
-    if (db == nullptr) {
-        return false;
-    }
-
-    if (file_size() == 10) // File is empty, nothing to do;
-        return false;
-
-    BinaryData data = GetFileData();
-
-    long long offset = 9; // first 4 bytes - file_id, then 4 bytes - unknown, then 1 byte - unknown
-
-    long long text_fragment_num = data.ToNumber<1>(offset);
-    if ((text_fragment_num & 0x80) != 0) {
-        text_fragment_num = (((text_fragment_num ^ 0x80) << 8) | data.ToNumber<1>(offset + 1));
-        offset += 1;
+    std::string DdsSubfile::Extension() const {
+        return ".dds";
     }
-    offset += 1;
-
-    for (long long i = 0; i < text_fragment_num; i++) {
-        long long fragment_id = data.ToNumber<8>(offset);
-        offset += 8;
 
-        long long num_pieces = data.ToNumber<4>(offset);
-        offset += 4;
+    bool DdsSubfile::PrepareAsBinary(BinaryData &data) {
+        if (compressed_)
+            data = data.DecompressData(4);
 
-        std::vector<std::u16string> text_pieces;
-        std::vector<long long> arg_references;
-        std::vector<std::vector<BinaryData> > arg_strings;
+        BinaryData ddsData(data.size() - 24 + 128);
+        for (int i = 0; i < 128; i++)
+            ddsData[i] = 0;
 
-        for (long long j = 0; j < num_pieces; j++) {
-            long long piece_size = data.ToNumber<1>(offset);
-            if ((piece_size & 128) != 0) {
-                piece_size = (((piece_size ^ 128) << 8) | data.ToNumber<1>(offset + 1));
-                offset += 1;
-            }
-            offset += 1;
+        memcpy(ddsData.data() + 128, data.data() + 24, data.size() - 24);
 
-            BinaryData piece_data = data.CutData(offset, offset + piece_size * 2);
-            std::u16string piece;
+        ddsData[0] = 0x44; // D
+        ddsData[1] = 0x44; // D
+        ddsData[2] = 0x53; // S
+        ddsData[3] = 0x20;
+        ddsData[4] = 0x7C;
 
-            for (long long k = 0; k < piece_size; k++) {
-                char16_t c = char16_t(((short(piece_data[2 * k + 1])) << 8) | (short(piece_data[2 * k])));
-                piece += c;
-            }
+        ddsData[8] = 7;
+        ddsData[9] = 0x10;
 
-            text_pieces.push_back(piece);
-            offset += piece_size * 2;
-        }
+        // width, height
+        ddsData[12] = data[12];
+        ddsData[13] = data[13];
+        ddsData[14] = data[14];
+        ddsData[15] = data[15];
 
-        long long num_references = data.ToNumber<4>(offset);
-        offset += 4;
+        ddsData[16] = data[8];
+        ddsData[17] = data[9];
+        ddsData[18] = data[10];
+        ddsData[19] = data[11];
 
-        for (long long j = 0; j < num_references; j++) {
-            arg_references.emplace_back(data.ToNumber<4>(offset));
-            offset += 4;
-        }
+        long long compression = data.ToNumber<4>(0x10);
 
-        long long num_arg_strings = data.ToNumber<1>(offset);
-        offset += 1;
+        switch (compression) {
+            case 20:        // 14 00 00 00 - 888 (R8G8B8)
+                ddsData[0x4C] = 0x20;  // ?
+                ddsData[0x50] = 0x40;  // compressed or not
 
-        for (long long j = 0; j < num_arg_strings; j++) {
-            long long num_args = data.ToNumber<4>(offset);
-            offset += 4;
-
-            arg_strings.emplace_back();
-            for (long long k = 0; k < num_args; k++) {
-                long long string_size = data.ToNumber<1>(offset);
-                if ((string_size & 0x80) != 0) {
-                    string_size = (((string_size ^ 0x80) << 8) | data.ToNumber<1>(offset + 1));
-                    offset += 1;
-                }
-                offset += 1;
-
-                arg_strings[j].emplace_back(data.CutData(offset, offset + string_size * 2));
-                offset += string_size * 2;
-            }
+                ddsData[0x58] = 0x18;  // bytes per pixel
+                ddsData[0x5E] = 0xFF;
+                ddsData[0x61] = 0xFF;
+                ddsData[0x64] = 0xFF;
+                break;
+            case 21:        // 15 00 00 00 - 8888 (R8G8B8A8)
+                ddsData[0x4C] = 0x20;  // ?
+                ddsData[0x50] = 0x40;  // compressed or not
+
+                ddsData[0x58] = 0x20;  // bytes per pixel
+                ddsData[0x5E] = 0xFF;
+                ddsData[0x61] = 0xFF;
+                ddsData[0x64] = 0xFF;
+                ddsData[0x6B] = 0xFF;
+                break;
+            case 28:        // 1C 00 00 00 - 332 (?)
+                ddsData[0x4C] = 0x20;  // ?
+                ddsData[0x50] = 0x40;  // compressed or not
+
+                ddsData[0x58] = 0x08;  // bytes per pixel
+                ddsData[0x5E] = 0xFF;
+                ddsData[0x61] = 0xFF;
+                ddsData[0x64] = 0xFF;
+                break;
+            case 827611204: // 44 58 54 31 - DXT1
+                ddsData[76] = 32;
+                ddsData[80] = 4;
+
+                ddsData[84] = 68;
+                ddsData[85] = 88;
+                ddsData[86] = 84;
+                ddsData[87] = 49;
+                break;
+            case 861165636: // 44 58 54 33 - DXT3
+                ddsData[22] = 1;
+                ddsData[76] = 32;
+                ddsData[80] = 4;
+
+                ddsData[84] = 68;
+                ddsData[85] = 88;
+                ddsData[86] = 84;
+                ddsData[87] = 51;
+
+                ddsData[108] = 8;
+                ddsData[109] = 16;
+                ddsData[110] = 64;
+                break;
+            case 894720068: // 44 58 54 35 - DXT5
+                ddsData[10] = 8;
+                ddsData[22] = 1;
+                ddsData[28] = 1;
+                ddsData[76] = 32;
+                ddsData[80] = 4;
+
+                ddsData[84] = 68;
+                ddsData[85] = 88;
+                ddsData[86] = 84;
+                ddsData[87] = 53;
+
+                ddsData[88] = 32;
+                ddsData[94] = 255;
+                ddsData[97] = 255;
+                ddsData[100] = 255;
+                ddsData[107] = 255;
+                ddsData[109] = 16;
+                break;
+            default:
+                throw DatException("Bad DdsSubfile::PrepareAsBinary() - unknown header format.", EXPORT_EXCEPTION);
         }
-
-        std::u16string text = u"[";
-        for (int i = 0; i + 1 < text_pieces.size(); i++)
-            text += text_pieces[i] + u"<--DO_NOT_TOUCH!-->";
-        text += text_pieces[text_pieces.size() - 1] + u"]";
-
-        std::string arguments;
-        for (int i = 0; i + 1 < arg_references.size(); i++)
-            arguments += std::to_string(arg_references[i]) + "-";
-        if (arg_references.size() >= 1)
-            arguments += std::to_string(arg_references[arg_references.size() - 1]);
-
-        db->PushTextFile(file_id(), fragment_id, text.c_str(), arguments.c_str());
-    }
-    return true;
-}
-
-LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::GetFileData(long long offset) const {
-    BinaryData mfile_id(4);
-    dat_->ReadData(mfile_id, 4, file_offset() + 8);
-    if (file_id() != mfile_id.ToNumber<4>(0))
-        throw DatException("Bad Subfile::GetFileData() - file_id doesn't match to dictionary", READ_EXCEPTION);
-
-    BinaryData data((unsigned)(file_size()));
-    if (block_size() >= file_size() + 8) {
-        dat_->ReadData(data, file_size(), file_offset() + offset);
-        return data;
+        data = ddsData;
+        return true;
     }
 
-    BinaryData fragments_count(4);
-    dat_->ReadData(fragments_count, 4, file_offset());
-
-    long long fragments_number = fragments_count.ToNumber<4>(0);
 
-    long long current_block_size = block_size() - offset - 8 * fragments_number;
-
-    dat_->ReadData(data, current_block_size , file_offset() + offset);
-
-    BinaryData FragmentsDictionary(8 * unsigned(fragments_number));
-    dat_->ReadData(FragmentsDictionary, 8 * unsigned(fragments_number), file_offset() + block_size() - 8 * fragments_number);
-
-
-    for (long long i = 0; i < fragments_number; i++) {
-        long long fragment_size = FragmentsDictionary.ToNumber<4>(8 * i);
-        long long fragment_offset = FragmentsDictionary.ToNumber<4>(8 * i + 4);
-        dat_->ReadData(data, std::min(fragment_size, file_size() - current_block_size), fragment_offset, current_block_size );
-        current_block_size += fragment_size;
+    BinaryData DdsSubfile::MakeFromBinary(const BinaryData &data) {
+        return data.CutData(128).CompressData();
     }
 
-    return data;
-}
-
-LOTRO_DAT::Subfile *LOTRO_DAT::Subfile::initialize(LOTRO_DAT::DatFile *dat, long long file_off) {
-    return nullptr;
-}
-
-bool LOTRO_DAT::Subfile::PatchBinaryFile(LOTRO_DAT::Database *db) {
-    return false;
-}
-
-bool LOTRO_DAT::Subfile::PatchTextFile(std::string text, std::string args, std::string args_order) {
-    return false;
-}
-
-bool LOTRO_DAT::Subfile::PatchTextFile(LOTRO_DAT::Database *db) {
-    return false;
-}
-
-bool LOTRO_DAT::Subfile::PrepareAsBinary(LOTRO_DAT::BinaryData &data) {
-    return false;
-}
-
-bool LOTRO_DAT::Subfile::PrepareAsText(std::string &text, std::string &args, std::string &args_order) {
-    return false;
-}
-
-LOTRO_DAT::BinaryData &LOTRO_DAT::Subfile::MakeFromBinary(const LOTRO_DAT::BinaryData &data) {
-    return <#initializer#>;
-}
-
-LOTRO_DAT::BinaryData &
-LOTRO_DAT::Subfile::MakeFromText(const std::string &text, const std::string &args, const std::string &args_order) {
-    return <#initializer#>;
-}
-
-*/
-/*
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsJPG() const {
-    return GetFileData().CutData(24);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsDDS() const {
-    BinaryData data = GetFileData();
-    if (compressed_)
-        data.DecompressData(4);
-
-    BinaryData ddsData(data.size() - 24 + 128);
-    for (int i = 0; i < 128; i++)
-        ddsData[i] = 0;
-
-    memcpy(ddsData.data() + 128, data.data() + 24, data.size() - 24);
-
-    ddsData[0] = 0x44; // D
-    ddsData[1] = 0x44; // D
-    ddsData[2] = 0x53; // S
-    ddsData[3] = 0x20;
-    ddsData[4] = 0x7C;
-
-    ddsData[8] = 7;
-    ddsData[9] = 0x10;
-
-    // width, height
-    ddsData[12] = data[12];
-    ddsData[13] = data[13];
-    ddsData[14] = data[14];
-    ddsData[15] = data[15];
-
-    ddsData[16] = data[8];
-    ddsData[17] = data[9];
-    ddsData[18] = data[10];
-    ddsData[19] = data[11];
-
-    long long compression = data.ToNumber<4>(0x10);
-
-    switch (compression) {
-        case 20:        // 14 00 00 00 - 888 (R8G8B8)
-            ddsData[0x4C] = 0x20;  // ?
-            ddsData[0x50] = 0x40;  // compressed or not
-
-            ddsData[0x58] = 0x18;  // bytes per pixel
-            ddsData[0x5E] = 0xFF;
-            ddsData[0x61] = 0xFF;
-            ddsData[0x64] = 0xFF;
-            break;
-        case 21:        // 15 00 00 00 - 8888 (R8G8B8A8)
-            ddsData[0x4C] = 0x20;  // ?
-            ddsData[0x50] = 0x40;  // compressed or not
-
-            ddsData[0x58] = 0x20;  // bytes per pixel
-            ddsData[0x5E] = 0xFF;
-            ddsData[0x61] = 0xFF;
-            ddsData[0x64] = 0xFF;
-            ddsData[0x6B] = 0xFF;
-            break;
-        case 28:        // 1C 00 00 00 - 332 (?)
-            ddsData[0x4C] = 0x20;  // ?
-            ddsData[0x50] = 0x40;  // compressed or not
-
-            ddsData[0x58] = 0x08;  // bytes per pixel
-            ddsData[0x5E] = 0xFF;
-            ddsData[0x61] = 0xFF;
-            ddsData[0x64] = 0xFF;
-            break;
-        case 827611204: // 44 58 54 31 - DXT1
-            ddsData[76] = 32;
-            ddsData[80] = 4;
-
-            ddsData[84] = 68;
-            ddsData[85] = 88;
-            ddsData[86] = 84;
-            ddsData[87] = 49;
-            break;
-        case 861165636: // 44 58 54 33 - DXT3
-            ddsData[22] = 1;
-            ddsData[76] = 32;
-            ddsData[80] = 4;
-
-            ddsData[84] = 68;
-            ddsData[85] = 88;
-            ddsData[86] = 84;
-            ddsData[87] = 51;
-
-            ddsData[108] = 8;
-            ddsData[109] = 16;
-            ddsData[110] = 64;
-            break;
-        case 894720068: // 44 58 54 35 - DXT5
-            ddsData[10] = 8;
-            ddsData[22] = 1;
-            ddsData[28] = 1;
-            ddsData[76] = 32;
-            ddsData[80] = 4;
-
-            ddsData[84] = 68;
-            ddsData[85] = 88;
-            ddsData[86] = 84;
-            ddsData[87] = 53;
-
-            ddsData[88] = 32;
-            ddsData[94] = 255;
-            ddsData[97] = 255;
-            ddsData[100] = 255;
-            ddsData[107] = 255;
-            ddsData[109] = 16;
-            break;
-    }
-	return ddsData;
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsOGG() const {
-    return GetFileData().CutData(8);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsFont() const {
-    return GetFileData();
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsWAV() const {
-    return GetFileData().CutData(8);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::PrepareAsUnk() const {
-    return GetFileData();
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromJPG(const LOTRO_DAT::BinaryData &file) const {
-    return GetFileData().CutData(0, 24) + file;
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromDDS(const LOTRO_DAT::BinaryData &file) const {
-    throw LOTRO_DAT::DatException("Bad Subfile::MakeFromDDS() - not implemented yet", IMPORT_EXCEPTION);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromOGG(const LOTRO_DAT::BinaryData &file) const {
-    throw LOTRO_DAT::DatException("Bad Subfile::MakeFromOGG() - not implemented yet", IMPORT_EXCEPTION);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromFont(const LOTRO_DAT::BinaryData &file) const {
-    throw LOTRO_DAT::DatException("Bad Subfile::MakeFromFont() - not implemented yet", IMPORT_EXCEPTION);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromWAV(const LOTRO_DAT::BinaryData &file) const {
-    throw LOTRO_DAT::DatException("Bad Subfile::MakeFromWAV() - not implemented yet", IMPORT_EXCEPTION);
-}
-
-const LOTRO_DAT::BinaryData LOTRO_DAT::Subfile::MakeFromUnk(const LOTRO_DAT::BinaryData &file) const {
-    throw LOTRO_DAT::DatException("Bad Subfile::MakeFromUnk() - not implemented yet", IMPORT_EXCEPTION);
-}
- */
+};

Source/Subfiles/DdsSubfile.h

@@ -9,19 +9,19 @@
 
 namespace LOTRO_DAT {
     class DdsSubfile : Subfile {
+    public:
         DdsSubfile();
         DdsSubfile(DatFile *dat, long long fragments_count, long long unknown1, long long file_id, long long file_offset,
-                                 long long file_size, long long timestamp, long long version, long long block_size) override;
+                                 long long file_size, long long timestamp, long long version, long long block_size);
 
         FILE_TYPE FileType() const override;
-        std::string GetExtension() const override;
+        std::string Extension() const override;
 
         bool PrepareAsBinary(BinaryData &data) override;
-        bool PrepareAsText(std::string &text, std::string &args, std::string &args_order) override;
-
-        BinaryData& MakeFromBinary(const BinaryData &data) override;
-        BinaryData& MakeFromText(const std::string &text, const std::string &args, const std::string &args_order) override;
+        BinaryData MakeFromBinary(const BinaryData &data) override;
 
+    private:
+        bool compressed_;
     };
 };