cWebshotsPicture.cpp

Go to the documentation of this file.

/*
    cWebshots - Webshots files handling classes
    Copyright (C) 2005  Hervé "Setaou" BRY <uwc at apinc dot org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "cWebshots.h"

#include <cstdio>
#include <cstring>
#include <sstream>

using namespace std;

namespace cWebshots
{

        //----------------------------------------------------------
        // Class cWebshotsPicture
        //----------------------------------------------------------

        //------------------------------------
        // Constructors / Destructors
        //------------------------------------

        cWebshotsPicture::cWebshotsPicture(void)
        {
                AdditionDate = 0;
                DailyDate = 0;
                ID = 0;

                JPGFile_Size = 0;
                BMPThumbnail_Size = 0;
        }

        cWebshotsPicture::~cWebshotsPicture(void)
        {
                if (JPGFile_Size > 0)
                        delete[] JPGFile;

                if (BMPThumbnail_Size > 0)
                        delete[] BMPThumbnail;
        }


        cWebshotsPicture::cWebshotsPicture(const cWebshotsPicture& source)
        {
                *this = source;
        }

        //------------------------------------
        // Operators
        //------------------------------------

        cWebshotsPicture& cWebshotsPicture::operator=(const cWebshotsPicture& source)
        {
                if (&source != this)
                {
                        // Delete the current picture/thumbnail
                        if (JPGFile_Size > 0)
                                delete[] JPGFile;
                        if (BMPThumbnail_Size > 0)
                                delete[] BMPThumbnail;

                        JPGFile_Size = 0;
                        BMPThumbnail_Size = 0;

                        // Copy the source
                        ID = source.ID;
                        Original_Filename = source.Original_Filename;
                        Title = source.Title;
                        Caption = source.Caption;
                        Credits = source.Credits;

                        Category = source.Category;
                        Album = source.Album;
                        AlbumID = source.AlbumID;

                        Source = source.Source;
                        DailyDate = source.DailyDate;
                        AdditionDate = source.AdditionDate;

                        JPGFile_Size = source.JPGFile_Size;
                        BMPThumbnail_Size = source.BMPThumbnail_Size;

                        if (JPGFile_Size > 0)
                        {
                                JPGFile = new char[JPGFile_Size];
                                memcpy(JPGFile, source.JPGFile, JPGFile_Size);
                        }
                        if (BMPThumbnail_Size > 0)
                        {
                                BMPThumbnail = new char[BMPThumbnail_Size];
                                memcpy(BMPThumbnail, source.BMPThumbnail, BMPThumbnail_Size);
                        }
                }

                return *this;
        }

        //------------------------------------
        // Public data access
        //------------------------------------

        char *cWebshotsPicture::PicturePtr() const
        {
                return JPGFile;
        }

        long cWebshotsPicture::PictureSize() const
        {
                return JPGFile_Size;
        }

        char *cWebshotsPicture::ThumbnailPtr() const
        {
                return BMPThumbnail;
        }

        long cWebshotsPicture::ThumbnailSize() const
        {
                return BMPThumbnail_Size;
        }

        //------------------------------------
        // Load procedures
        //------------------------------------

        void cWebshotsPicture::LoadFromFile(string File)
        {
                ifstream in_file;
                long File_Type;

                // Clear everything
                Clear();

                // Open the file for reading
                in_file.open(File.c_str(), ios_base::in | ios_base::binary);

                if (in_file.is_open())
                {
                        in_file.read((char *)&File_Type, 4);

                        switch (File_Type)
                        {
                        // JPG File / WB1 File
                        case WB1_File_Marker:
                        case JFIF_File_Marker: 
                        case EXIF_File_Marker:
                                        LoadWB1(in_file);
                                        LoadMetaDataTXT(File);

                                        // If the picture has no original filename (eg. JPEG), uses the filename
                                        if (Original_Filename.length() == 0)
                                                Original_Filename = GetFileName(File);
                                break;

                        // Unsupported file format
                        default:
                                Exceptions::UnknownFormat Err("The file \"" + File + "\" cannot be opened as a Webshots picture.");
                                throw Err;
                        }

                        in_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + File + "\" for reading.");
                        throw Err;
                }
        };

        void cWebshotsPicture::LoadWB1(ifstream &in_file)
        {
                char *File;
                unsigned long Size;

                // Get the size of the file
                in_file.seekg(0, ios_base::end);
                Size = (unsigned long)(in_file.tellg()) + 1;
                in_file.seekg(0);

                // Load the file into a buffer
                File = new char[Size];

                try
                {
                        in_file.read(File, Size);

                        // Load the picture
                        LoadFromMemory(File,Size);
                }
                catch (...)
                {
                        delete[] File;
                        throw;
                }

                delete[] File;
        }

        void cWebshotsPicture::LoadFromMemory(const char *data, long size)
        {
                char Key[8];
                char KeyVal;
                long File_Type;
                int i;

                // Clear the existing picture before we load the new one
                Clear();

                // Get the type of the file
                memcpy(&File_Type,data,4);

                switch (File_Type)
                {
                // Encrypted header
                case WB1_File_Marker:
                        // Get the key
                        memcpy(Key,data,8);
                        if (Key[4] == '0')
                                KeyVal = (char)0xA4;
                        else if (Key[4] == '1')
                                KeyVal = (char)0xF2;
                        
                        // Load the file into the buffer
                        JPGFile_Size = size - 8;
                        JPGFile = new char[JPGFile_Size];
                        memcpy(JPGFile,data + 8,size - 8);

                        // Decrypt the file
                        for (i = 0; i < 100; i++)
                        {
                                JPGFile[i] = (JPGFile[i + 100] ^ (~JPGFile[i])) ^ KeyVal;
                        }
                        break;

                // Header not encrypted
                case JFIF_File_Marker:
                case EXIF_File_Marker:
                        JPGFile_Size = size;
                        JPGFile = new char[JPGFile_Size];
                        memcpy(JPGFile,data,size);
                        break;

                // Unknown format
                default:
                        Exceptions::UnknownFormat Err("The file has an unknown format.");
                        throw Err;
                }
        };

        void cWebshotsPicture::LoadMetaDataTXT(string file)
        {
                cWebshotsTXT txt;
                int index;
                string test;

                txt.Load(test = GetDirectory(file));
                index = txt.IndexFromFileName(test = GetFileName(file));

                if (index != cWebshotsTXT::IndexNotFound)
                {
                        ID = txt.Picture(index).id;
                        Original_Filename = txt.Picture(index).url_photo;
                        Title = txt.Picture(index).title;
                        Caption = txt.Picture(index).caption;
                        Credits = txt.Picture(index).credit;
                        Source = txt.Picture(index).source;
                }

                Category = txt.Album.topic_name;
                Album = txt.Album.title;
                AlbumID = txt.Album.id;
        }

        //------------------------------------
        // Save procedures
        //------------------------------------

        void cWebshotsPicture::SaveToFile(string file, Webshots_Formats format) const
        {
                // Open the file
                ofstream out_file(file.c_str(), ios_base::out | ios_base::binary | ios::trunc);

                // If the file is open
                if (out_file.is_open())
                {
                        // Write the picture
                        if (format == WB1)
                        {
                                char Header[100];
                                int i;
                                char KeyVal = 0xA4;

                                // Make the encrypted header using the WWBB0000 key
                                for (i = 0; i < 100; i++)
                                        Header[i] = ~(JPGFile[i] ^ KeyVal ^ JPGFile[i + 100]);

                                out_file << "WWBB0000";

                                out_file.write(Header, 100);
                                out_file.write(JPGFile + 100,JPGFile_Size - 100);
                        }
                        else // format == JPG
                                out_file.write(JPGFile,JPGFile_Size);

                        out_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + file + "\" for writing.");
                        throw Err;
                }
        };

        //------------------------------------
        // Clear procedures
        //------------------------------------

        void cWebshotsPicture::Clear()
        {
                if (JPGFile_Size > 0)
                {
                        delete[] JPGFile;
                        JPGFile_Size = 0;
                }

                if (BMPThumbnail_Size > 0)
                {
                        delete[] BMPThumbnail;
                        BMPThumbnail_Size = 0;
                }

                ID = 0;
                Original_Filename.clear();
                Title.clear();
                Caption.clear();
                Credits.clear();
                Category.clear();
                Album.clear();
                Source.clear();
                DailyDate = 0;
                AdditionDate = 0;
                AlbumID.clear();
        }
}

---