// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2004-2018 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

 * 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., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

/*

  File:      asfvideo.cpp

  Author(s): Abhinav Badola for GSoC 2012 (AB) <mail.abu.to@gmail.com>

  History:   08-Aug-12, AB: created

  Credits:   See header file

 */

// *****************************************************************************

// included header files

#include "config.h"

#ifdef EXV_ENABLE_VIDEO

#include "error.hpp"

#include "tags.hpp"

#include "tags_int.hpp"

#include "asfvideo.hpp"

#include "futils.hpp"

#include "basicio.hpp"

#include "types.hpp"

#include "riffvideo.hpp"

#include "convert.hpp"

// + standard includes

#include <cmath>

#include <cstring>

#include <ctype.h>

#include <cassert>

// *****************************************************************************

// class member definitions

namespace Exiv2 {

    namespace Internal {

    /*!

      Tag Look-up list for ASF Type Video Files

      Associates the GUID of a Tag with its Tag Name(i.e. Human Readable Form)

      Tags have been diferentiated into Various Categories.

      The categories have been listed above the Tag Groups

     */

    extern const TagVocabulary GUIDReferenceTags[] =  {

        /// Top-level ASF object GUIDS

        {   "75B22630-668E-11CF-A6D9-00AA0062CE6C", "Header" },

        {   "75B22636-668E-11CF-A6D9-00AA0062CE6C", "Data" },

        {   "33000890-E5B1-11CF-89F4-00A0C90349CB", "Simple_Index" },

        {   "D6E229D3-35DA-11D1-9034-00A0C90349BE", "Index" },

        {   "FEB103F8-12AD-4C64-840F-2A1D2F7AD48C", "Media_Index" },

        {   "3CB73FD0-0C4A-4803-953D-EDF7B6228F0C", "Timecode_Index" },

        /// Header Object GUIDs

        {   "8CABDCA1-A947-11CF-8EE4-00C00C205365", "File_Properties" },

        {   "B7DC0791-A9B7-11CF-8EE6-00C00C205365", "Stream_Properties" },

        {   "5FBF03B5-A92E-11CF-8EE3-00C00C205365", "Header_Extension" },

        {   "86D15240-311D-11D0-A3A4-00A0C90348F6", "Codec_List" },

        {   "1EFB1A30-0B62-11D0-A39B-00A0C90348F6", "Script_Command" },

        {   "F487CD01-A951-11CF-8EE6-00C00C205365", "Marker" },

        {   "D6E229DC-35DA-11D1-9034-00A0C90349BE", "Bitrate_Mutual_Exclusion" },

        {   "75B22635-668E-11CF-A6D9-00AA0062CE6C", "Error_Correction" },

        {   "75B22633-668E-11CF-A6D9-00AA0062CE6C", "Content_Description" },

        {   "D2D0A440-E307-11D2-97F0-00A0C95EA850", "Extended_Content_Description" },

        {   "2211B3FA-BD23-11D2-B4B7-00A0C955FC6E", "Content_Branding" },

        {   "7BF875CE-468D-11D1-8D82-006097C9A2B2", "Stream_Bitrate_Properties" },

        {   "2211B3FB-BD23-11D2-B4B7-00A0C955FC6E", "Content_Encryption" },

        {   "298AE614-2622-4C17-B935-DAE07EE9289C", "Extended_Content_Encryption" },

        {   "2211B3FC-BD23-11D2-B4B7-00A0C955FC6E", "Digital_Signature" },

        {   "1806D474-CADF-4509-A4BA-9AABCB96AAE8", "Padding" },

        /// Header Extension Object GUIDs

        {   "14E6A5CB-C672-4332-8399-A96952065B5A", "Extended_Stream_Properties" },

        {   "A08649CF-4775-4670-8A16-6E35357566CD", "Advanced_Mutual_Exclusion" },

        {   "D1465A40-5A79-4338-B71B-E36B8FD6C249", "Group_Mutual_Exclusion" },

        {   "D4FED15B-88D3-454F-81F0-ED5C45999E24", "Stream_Prioritization" },

        {   "A69609E6-517B-11D2-B6AF-00C04FD908E9", "Bandwidth_Sharing" },

        {   "7C4346A9-EFE0-4BFC-B229-393EDE415C85", "Language_List" },

        {   "C5F8CBEA-5BAF-4877-8467-AA8C44FA4CCA", "Metadata" },

        {   "44231C94-9498-49D1-A141-1D134E457054", "Metadata_Library" },

        {   "D6E229DF-35DA-11D1-9034-00A0C90349BE", "Index_Parameters" },

        {   "6B203BAD-3F11-48E4-ACA8-D7613DE2CFA7", "Media_Index_Parameters" },

        {   "F55E496D-9797-4B5D-8C8B-604DFE9BFB24", "Timecode_Index_Parameters" },

        {   "26F18B5D-4584-47EC-9F5F-0E651F0452C9", "Compatibility" },

        {   "43058533-6981-49E6-9B74-AD12CB86D58C", "Advanced_Content_Encryption" },

        /// Stream Properties Object Stream Type GUIDs

        {   "F8699E40-5B4D-11CF-A8FD-00805F5C442B", "Audio_Media" },

        {   "BC19EFC0-5B4D-11CF-A8FD-00805F5C442B", "Video_Media" },

        {   "59DACFC0-59E6-11D0-A3AC-00A0C90348F6", "Command_Media" },

        {   "B61BE100-5B4E-11CF-A8FD-00805F5C442B", "JFIF_Media" },

        {   "35907DE0-E415-11CF-A917-00805F5C442B", "Degradable_JPEG_Media" },

        {   "91BD222C-F21C-497A-8B6D-5AA86BFC0185", "File_Transfer_Media" },

        {   "3AFB65E2-47EF-40F2-AC2C-70A90D71D343", "Binary_Media" },

        /// Web stream Type-Specific Data GUIDs

        {   "776257D4-C627-41CB-8F81-7AC7FF1C40CC", "Web_Stream_Media_Subtype" },

        {   "DA1E6B13-8359-4050-B398-388E965BF00C", "Web_Stream_Format" },

        /// Stream Properties Object Error Correction Type GUIDs

        {   "20FB5700-5B55-11CF-A8FD-00805F5C442B", "No_Error_Correction" },

        {   "BFC3CD50-618F-11CF-8BB2-00AA00B4E220", "Audio_Spread" },

        /// Header Extension Object GUIDs

        {   "ABD3D211-A9BA-11cf-8EE6-00C00C205365", "Reserved_1" },

        /// Advanced Content Encryption Object System ID GUIDs

        {   "7A079BB6-DAA4-4e12-A5CA-91D38DC11A8D", "Content_Encryption_System_Windows_Media_DRM_Network_Devices" },

        /// Codec List Object GUIDs

        {   "86D15241-311D-11D0-A3A4-00A0C90348F6", "Reserved_2" },

        /// Script Command Object GUIDs

        {   "4B1ACBE3-100B-11D0-A39B-00A0C90348F6", "Reserved_3" },

        /// Marker Object GUIDs

        {   "4CFEDB20-75F6-11CF-9C0F-00A0C90349CB", "Reserved_4" },

        /// Mutual Exclusion Object Exclusion Type GUIDs

        {   "D6E22A00-35DA-11D1-9034-00A0C90349BE", "Mutex_Language" },

        {   "D6E22A01-35DA-11D1-9034-00A0C90349BE", "Mutex_Bitrate" },

        {   "D6E22A02-35DA-11D1-9034-00A0C90349BE", "Mutex_Unknown" },

        /// Bandwidth Sharing Object GUIDs

        {   "AF6060AA-5197-11D2-B6AF-00C04FD908E9", "Bandwidth_Sharing_Exclusive" },

        {   "AF6060AB-5197-11D2-B6AF-00C04FD908E9", "Bandwidth_Sharing_Partial" },

        /// Standard Payload Extension System GUIDs

        {   "399595EC-8667-4E2D-8FDB-98814CE76C1E", "Payload_Extension_System_Timecode" },

        {   "E165EC0E-19ED-45D7-B4A7-25CBD1E28E9B", "Payload_Extension_System_File_Name" },

        {   "D590DC20-07BC-436C-9CF7-F3BBFBF1A4DC", "Payload_Extension_System_Content_Type" },

        {   "1B1EE554-F9EA-4BC8-821A-376B74E4C4B8", "Payload_Extension_System_Pixel_Aspect_Ratio" },

        {   "C6BD9450-867F-4907-83A3-C77921B733AD", "Payload_Extension_System_Sample_Duration" },

        {   "6698B84E-0AFA-4330-AEB2-1C0A98D7A44D", "Payload_Extension_System_Encryption_Sample_ID" },

        {   "00E1AF06-7BEC-11D1-A582-00C04FC29CFB", "Payload_Extension_System_Degradable_JPEG" }

    };

    //! Audio codec type-specific data in ASF

    extern const TagDetails audioCodec[] =  {

        {    0x161, "Windows Media Audio (7, 8, and 9 Series)" },

        {    0x162, "Windows Media Audio 9 Professional" },

        {    0x163, "Windows Media Audio 9 Lossless" },

        {   0x7A21, "GSM-AMR (CBR, no SID)" },

        {   0x7A22, "GSM-AMR (VBR including SID)" }

    };

    extern const TagDetails filePropertiesTags[] =  {

        {    7, "Xmp.video.FileLength" },

        {    6, "Xmp.video.CreationDate" },

        {    5, "Xmp.video.DataPackets" },

        {    4, "Xmp.video.Duration" },

        {    3, "Xmp.video.SendDuration" },

        {    2, "Xmp.video.Preroll" },

        {    1, "Xmp.video.MaxBitRate" }

    };

    extern const TagDetails contentDescriptionTags[] =  {

        {    0, "Xmp.video.Title" },

        {    1, "Xmp.video.Author" },

        {    2, "Xmp.video.Copyright" },

        {    3, "Xmp.video.Description" },

        {    4, "Xmp.video.Rating" }

    };

    /*!

      @brief Function used to read data from data buffer, reads 16-bit character

          array and stores it in std::string object.

      @param buf Exiv2 data buffer, which stores the information

      @return Returns std::string object .

     */

    std::string toString16(Exiv2::DataBuf& buf)

    {

        std::ostringstream os; char t;

        for(int i = 0; i <= buf.size_; i += 2 ) {

            t = buf.pData_[i] + 16 * buf.pData_[i + 1];

            if(t == 0) {

                if(i)

                    os << '\0';

                break;

            }

            os<< t;

        }

        return os.str();

    }

    /*!

      @brief Function used to check equality of two Tags (ignores case).

      @param str1 char* Pointer to First Tag

      @param str2 char* Pointer to Second Tag

      @return Returns true if both are equal.

     */

    bool compareTag(const char* str1, const char* str2) {

        if ( strlen(str1) != strlen(str2))

            return false;

        for ( uint64_t i = 0 ; i < strlen(str1); ++i )

            if (tolower(str1[i]) != tolower(str2[i]))

                return false;

        return true;

    }

    /*!

      @brief Function used to convert a decimal number to its Hexadecimal

          equivalent, then parsed into a character

      @param n Integer which is to be parsed as Hexadecimal character

      @return Return a Hexadecimal number, in character

     */

    char returnHEX(int n) {

        if(n >= 0 && n <= 9)

            return (char)(n + 48);

        else

            return (char)(n + 55);

    }

    /*!

      @brief Function used to calculate GUID, Tags comprises of 16 bytes.

          The Buffer contains the Tag in Binary Form. The information is then

          parsed into a character array GUID.

     */

    void getGUID (byte buf[], char GUID[]) {

        int i;

        for (i = 0; i < 4; ++i) {

            GUID[(3 - i) * 2]      = returnHEX(buf[i] / 0x10);

            GUID[(3 - i) * 2 + 1]  = returnHEX(buf[i] % 0x10);

        }

        for (i = 4; i < 6; ++i) {

            GUID[(9 - i) * 2 + 1]  = returnHEX(buf[i] / 0x10);

            GUID[(9 - i) * 2 + 2]  = returnHEX(buf[i] % 0x10);

        }

        for (i = 6; i < 8; ++i) {

            GUID[(14 - i) * 2]     = returnHEX(buf[i] / 0x10);

            GUID[(14 - i) * 2 + 1] = returnHEX(buf[i] % 0x10);

        }

        for (i = 8; i < 10; ++i) {

            GUID[ i * 2 + 3]       = returnHEX(buf[i] / 0x10);

            GUID[ i * 2 + 4]       = returnHEX(buf[i] % 0x10);

        }

        for (i = 10; i < 16; ++i) {

            GUID[ i * 2 + 4]       = returnHEX(buf[i] / 0x10);

            GUID[ i * 2 + 5]       = returnHEX(buf[i] % 0x10);

        }

        GUID[36] = '\0'; GUID[8] = GUID[13] = GUID[18] = GUID[23] = '-';

    }

    /*!

      @brief Function used to check if data stored in buf is equivalent to

          ASF Header Tag's GUID.

      @param buf Exiv2 byte buffer

      @return Returns true if the buffer data is equivalent to Header GUID.

     */

    bool isASFType (byte buf[]) {

        if(buf[0]  == 0x30   && buf[1]  == 0x26   && buf[2]  == 0xb2   && buf[3]  == 0x75 &&

           buf[4]  == 0x8e   && buf[5]  == 0x66   && buf[6]  == 0xcf   && buf[7]  == 0x11 &&

           buf[8]  == 0xa6   && buf[9]  == 0xd9   && buf[10] == 0x00   && buf[11] == 0xaa &&

           buf[12] == 0x00   && buf[13] == 0x62   && buf[14] == 0xce   && buf[15] == 0x6c )

                return true;

        return false;

    }

    //! Function used to convert buffer data into 64-bit Integer, information stored in littleEndian format

    uint64_t getUint64_t(Exiv2::DataBuf& buf) {

        uint64_t temp = 0;

        for(int i = 0; i < 8; ++i){

            temp = temp + static_cast<uint64_t>(buf.pData_[i]*(pow(static_cast<float>(256), i)));

        }

        return temp;

    }

}}                                      // namespace Internal, Exiv2

namespace Exiv2 {

    using namespace Exiv2::Internal;

    AsfVideo::AsfVideo(BasicIo::AutoPtr io)

        : Image(ImageType::asf, mdNone, io)

    {

    } // AsfVideo::AsfVideo

    std::string AsfVideo::mimeType() const

    {

        return "video/asf";

    }

    void AsfVideo::writeMetadata()

    {

    }

    void AsfVideo::readMetadata()

    {

        if (io_->open() != 0) throw Error(kerDataSourceOpenFailed, io_->path(), strError());

        // Ensure that this is the correct image type

        if (!isAsfType(*io_, false)) {

            if (io_->error() || io_->eof()) throw Error(kerFailedToReadImageData);

            throw Error(kerNotAnImage, "ASF");

        }

        IoCloser closer(*io_);

        clearMetadata();

        continueTraversing_ = true;

        io_->seek(0, BasicIo::beg);

        height_ = width_ = 1;

        xmpData_["Xmp.video.FileSize"] = (double)io_->size()/(double)1048576;

        xmpData_["Xmp.video.FileName"] = io_->path();

        xmpData_["Xmp.video.MimeType"] = mimeType();

        while (continueTraversing_) decodeBlock();

        aspectRatio();

    } // AsfVideo::readMetadata

    void AsfVideo::decodeBlock()

    {

        const long bufMinSize = 9;

        DataBuf buf(bufMinSize);

        uint64_t size = 0;

        buf.pData_[8] = '\0' ;

        const TagVocabulary* tv;

        uint64_t cur_pos = io_->tell();

        byte guidBuf[16];

        io_->read(guidBuf, 16);

        if(io_->eof()) {

            continueTraversing_ = false;

            return;

        }

        char GUID[37] = ""; //the getGUID function write the GUID[36],

        getGUID(guidBuf, GUID);

        tv = find( GUIDReferenceTags, GUID);

        std::memset(buf.pData_, 0x0, buf.size_);

        io_->read(buf.pData_, 8);

        size = getUint64_t(buf);

        if(tv) {

            tagDecoder(tv,size-24);

        }

        else

            io_->seek(cur_pos + size, BasicIo::beg);

        localPosition_ = io_->tell();

    } // AsfVideo::decodeBlock

    void AsfVideo::tagDecoder(const TagVocabulary *tv, uint64_t size)

    {

        uint64_t cur_pos = io_->tell();

        DataBuf buf(1000);

        unsigned long count = 0, tempLength = 0;

        buf.pData_[4] = '\0' ;

        Exiv2::Value::AutoPtr v = Exiv2::Value::create(Exiv2::xmpSeq);

        if(compareTag( exvGettext(tv->label_), "Header")) {

            localPosition_ = 0;

            io_->read(buf.pData_, 4);

            io_->read(buf.pData_, 2);

            while(localPosition_ < cur_pos + size) decodeBlock();

        }

        else if(compareTag( exvGettext(tv->label_), "File_Properties"))

            fileProperties();

        else if(compareTag( exvGettext(tv->label_), "Stream_Properties"))

            streamProperties();

        else if(compareTag( exvGettext(tv->label_), "Metadata"))

            metadataHandler(1);

        else if(compareTag( exvGettext(tv->label_), "Extended_Content_Description"))

            metadataHandler(2);

        else if(compareTag( exvGettext(tv->label_), "Metadata_Library"))

            metadataHandler(3);

        else if(compareTag( exvGettext(tv->label_), "Codec_List"))

            codecList();

        else if(compareTag( exvGettext(tv->label_), "Content_Description"))

            contentDescription(size);

        else if(compareTag( exvGettext(tv->label_), "Extended_Stream_Properties"))

            extendedStreamProperties(size);

        else if(compareTag( exvGettext(tv->label_), "Header_Extension")) {

            localPosition_ = 0;

            headerExtension(size);

        }

        else if(compareTag( exvGettext(tv->label_), "Language_List")) {

            std::memset(buf.pData_, 0x0, buf.size_);

            io_->read(buf.pData_, 2);

            count = Exiv2::getUShort(buf.pData_, littleEndian);

            while(count--) {

                std::memset(buf.pData_, 0x0, buf.size_);

                io_->read(buf.pData_, 1);   tempLength = (int)buf.pData_[0];

                io_->read(buf.pData_, tempLength);

                v->read(toString16(buf));

            }

            xmpData_.add(Exiv2::XmpKey("Xmp.video.TrackLang"), v.get());

        }

        io_->seek(cur_pos + size, BasicIo::beg);

        localPosition_ = io_->tell();

    } // AsfVideo::tagDecoder

    void AsfVideo::extendedStreamProperties(uint64_t size)

    {

        uint64_t cur_pos = io_->tell(), avgTimePerFrame = 0;

        DataBuf buf(8);

        static int previousStream;

        io_->seek(cur_pos + 48, BasicIo::beg);

        std::memset(buf.pData_, 0x0, buf.size_);

        io_->read(buf.pData_, 2);

        streamNumber_ = Exiv2::getUShort(buf.pData_, littleEndian);

        io_->read(buf.pData_, 2);

        io_->read(buf.pData_, 8);

        avgTimePerFrame = getUint64_t(buf);

        if(previousStream < streamNumber_  &&  avgTimePerFrame != 0)

            xmpData_["Xmp.video.FrameRate"] = (double)10000000/(double)avgTimePerFrame;

        previousStream = streamNumber_;

        io_->seek(cur_pos + size, BasicIo::beg);

    } // AsfVideo::extendedStreamProperties

    void AsfVideo::contentDescription(uint64_t size)

    {

        const long pos = io_->tell();

        if (pos == -1) throw Error(kerFailedToReadImageData);

        long length[5];

        for (int i = 0 ; i < 5 ; ++i) {

            byte buf[2];

            io_->read(buf, 2);

            if (io_->error() || io_->eof()) throw Error(kerFailedToReadImageData);

            length[i] = getUShort(buf, littleEndian);

        }

        for (int i = 0 ; i < 5 ; ++i) {

            DataBuf buf(length[i]);

            std::memset(buf.pData_, 0x0, buf.size_);

            io_->read(buf.pData_, length[i]);

            if (io_->error() || io_->eof()) throw Error(kerFailedToReadImageData);

            const TagDetails* td = find(contentDescriptionTags, i);

            assert(td);

            std::string str((const char*)buf.pData_, length[i]);

            if (convertStringCharset(str, "UCS-2LE", "UTF-8")) {

                xmpData_[td->label_] = str;

            }

            else {

                xmpData_[td->label_] = toString16(buf);

            }

        }

        if (io_->seek(pos + size, BasicIo::beg)) throw Error(kerFailedToReadImageData);

    } // AsfVideo::contentDescription

    void AsfVideo::streamProperties()

    {

        DataBuf buf(20);

        buf.pData_[8] = '\0' ;

        byte guidBuf[16]; int stream = 0;

        io_->read(guidBuf, 16);

        char streamType[37] = "";

        Exiv2::RiffVideo *test = NULL;

        getGUID(guidBuf, streamType);

        const TagVocabulary* tv;

        tv = find( GUIDReferenceTags, streamType);

        io_->read(guidBuf, 16);

        if(compareTag( exvGettext(tv->label_), "Audio_Media"))

            stream = 1;

        else if(compareTag( exvGettext(tv->label_), "Video_Media"))

            stream = 2;

        io_->read(buf.pData_, 8);

        if(stream == 2)

            xmpData_["Xmp.video.TimeOffset"] = getUint64_t(buf);

        else if(stream == 1)

            xmpData_["Xmp.audio.TimeOffset"] = getUint64_t(buf);

        io_->read(buf.pData_, 8);

        std::memset(buf.pData_, 0x0, buf.size_);

        io_->read(buf.pData_, 1);

        streamNumber_ = (int)buf.pData_[0] & 127;

        io_->read(buf.pData_, 5);

        std::memset(buf.pData_, 0x0, buf.size_);

        io_->read(buf.pData_, 2);

        long temp = Exiv2::getUShort(buf.pData_, littleEndian);

        if(stream == 2) {

            xmpData_["Xmp.video.Width"] = temp;

            width_ = temp;

        }

        else if(stream == 1) {

            xmpData_["Xmp.audio.Codec"] = test->printAudioEncoding(temp);

        }

        io_->read(buf.pData_, 2);

        temp = Exiv2::getUShort(buf.pData_, littleEndian);

        if(stream == 1)

            xmpData_["Xmp.audio.ChannelType"] = temp;

        io_->read(buf.pData_, 4);

        temp = Exiv2::getULong(buf.pData_, littleEndian);

        if(stream == 2) {

            xmpData_["Xmp.video.Height"] = temp;

            height_ = temp;

        }

        else if(stream == 1) {

            xmpData_["Xmp.audio.SampleRate"] = temp;

        }

    } // AsfVideo::streamProperties

    void AsfVideo::codecList()

    {

        DataBuf buf(200);

        io_->read(buf.pData_, 16);

        std::memset(buf.pData_, 0x0, buf.size_);

        io_->read(buf.pData_, 4);

        int codecCount = Exiv2::getULong(buf.pData_, littleEndian), descLength = 0, codecType = 0;

        while(codecCount--) {

            std::memset(buf.pData_, 0x0, buf.size_);

            io_->read(buf.pData_, 2);

            codecType = Exiv2::getUShort(buf.pData_, littleEndian);

            io_->read(buf.pData_, 2);

            descLength = Exiv2::getUShort(buf.pData_, littleEndian) * 2;

            if (descLength < 0) {

            #ifndef SUPPRESS_WARNINGS

                    EXV_ERROR   << " Description found in this ASF file is not of valid size ."

                                << " Entries considered invalid. Not Processed.\n";

            #endif

            }

            else {

                io_->read(buf.pData_, descLength);

                if(codecType == 1)

                    xmpData_["Xmp.video.Codec"] = toString16(buf);

                else if(codecType == 2)

                    xmpData_["Xmp.audio.Compressor"] = toString16(buf);

            }

            std::memset(buf.pData_, 0x0, buf.size_);

            io_->read(buf.pData_, 2);

            descLength = Exiv2::getUShort(buf.pData_, littleEndian) * 2;

            if (descLength < 0) {

            #ifndef SUPPRESS_WARNINGS

                    EXV_ERROR   << " Description found in this ASF file is not of valid size ."

                                << " Entries considered invalid. Not Processed.\n";

            #endif

            }

            else {

                io_->read(buf.pData_, descLength);

                if(codecType == 1)

                    xmpData_["Xmp.video.CodecDescription"] = toString16(buf);

                else if(codecType == 2)

                    xmpData_["Xmp.audio.CodecDescription"] = toString16(buf);

            }

            std::memset(buf.pData_, 0x0, buf.size_);

            io_->read(buf.pData_, 2);

            descLength = Exiv2::getUShort(buf.pData_, littleEndian);

            if (descLength < 0) {

            #ifndef SUPPRESS_WARNINGS

                    EXV_ERROR   << " Description found in this ASF file is not of valid size ."

                                << " Entries considered invalid. Not Processed.\n";

            #endif

            }

            else {

                io_->read(buf.pData_, descLength);

            }

        }

    } // AsfVideo::codecList

    void AsfVideo::headerExtension(uint64_t size)

    {

        uint64_t cur_pos = io_->tell();

        DataBuf buf(20);

        io_->read(buf.pData_, 18);

        buf.pData_[4] = '\0' ;

        io_->read(buf.pData_, 4);

        while(localPosition_ < cur_pos + size) decodeBlock();

        io_->seek(cur_pos + size, BasicIo::beg);

    } // AsfVideo::headerExtension

    void AsfVideo::metadataHandler(int meta)

    {

        DataBuf buf(5000);

        io_->read(buf.pData_, 2);

        int recordCount = Exiv2::getUShort(buf.pData_, littleEndian), nameLength = 0, dataLength = 0, dataType = 0;

        Exiv2::Value::AutoPtr v = Exiv2::Value::create(Exiv2::xmpSeq);

        byte guidBuf[16];   char fileID[37] = "";

        while(recordCount--) {

            std::memset(buf.pData_, 0x0, buf.size_);

            if(meta == 1 || meta == 3) {

                io_->read(buf.pData_, 4);

                io_->read(buf.pData_, 2);

                nameLength = Exiv2::getUShort(buf.pData_, littleEndian);

                io_->read(buf.pData_, 2);

                dataType = Exiv2::getUShort(buf.pData_, littleEndian);

                io_->read(buf.pData_, 4);

                dataLength = Exiv2::getULong(buf.pData_, littleEndian);

                if (nameLength > 5000) {

#ifndef SUPPRESS_WARNINGS

                    EXV_ERROR << "Xmp.video.Metadata nameLength was found to be larger than 5000 "

                              << " entries considered invalid; not read.\n";

#endif

                    io_->seek(io_->tell() + nameLength, BasicIo::beg);

                } else {

                    io_->read(buf.pData_, nameLength);

                }

                v->read(toString16(buf));

                if(dataType == 6) {

                    io_->read(guidBuf, 16);

                    getGUID(guidBuf, fileID);

                }

                else

                    // Sanity check with an "unreasonably" large number

                    if (dataLength > 5000) {

#ifndef SUPPRESS_WARNINGS

                        EXV_ERROR << "Xmp.video.Metadata dataLength was found to be larger than 5000 "

                                  << " entries considered invalid; not read.\n";

#endif

                        io_->seek(io_->tell() + dataLength, BasicIo::beg);

                    }

                else

                        io_->read(buf.pData_, dataLength);

            }

            else if(meta == 2) {

                io_->read(buf.pData_, 2);

                nameLength = Exiv2::getUShort(buf.pData_, littleEndian);

                if (nameLength > 5000) {

#ifndef SUPPRESS_WARNINGS

                    EXV_ERROR << "Xmp.video.Metadata nameLength was found to be larger than 5000 "

                              << " entries considered invalid; not read.\n";

#endif

                    io_->seek(io_->tell() + nameLength, BasicIo::beg);

                } else {

                    io_->read(buf.pData_, nameLength);

                }

                v->read(toString16(buf));

                io_->read(buf.pData_, 2);

                dataType = Exiv2::getUShort(buf.pData_, littleEndian);

                io_->read(buf.pData_, 2);

                dataLength = Exiv2::getUShort(buf.pData_, littleEndian);

                // Sanity check with an "unreasonably" large number

                if (dataLength > 5000) {

#ifndef SUPPRESS_WARNINGS

                    EXV_ERROR << "Xmp.video.Metadata dataLength was found to be larger than 5000 "

                              << " entries considered invalid; not read.\n";

#endif

                    io_->seek(io_->tell() + dataLength, BasicIo::beg);

                }

            else

                io_->read(buf.pData_, dataLength);

            }

            if(dataType == 0) {                       // Unicode String

                v->read(toString16(buf));

            }

            else if(dataType == 2 || dataType == 5) { // 16-bit Unsigned Integer

                v->read( Exiv2::toString( Exiv2::getUShort(buf.pData_, littleEndian)));

            }

            else if(dataType == 3) {                  // 32-bit Unsigned Integer

                v->read( Exiv2::toString( Exiv2::getULong( buf.pData_, littleEndian)));

            }

            else if(dataType == 4) {                  // 64-bit Unsigned Integer

                v->read(Exiv2::toString(getUint64_t(buf)));

            }

            else if(dataType == 6) {                  // 128-bit GUID

                v->read(Exiv2::toString(fileID));

            }

            else {                                    // Byte array

                v->read( Exiv2::toString(buf.pData_));

            }

        }

        if(meta == 1) {

            xmpData_.add(Exiv2::XmpKey("Xmp.video.Metadata"), v.get());

        }

        else if(meta == 2) {

            xmpData_.add(Exiv2::XmpKey("Xmp.video.ExtendedContentDescription"), v.get());

        }

        else {

            xmpData_.add(Exiv2::XmpKey("Xmp.video.MetadataLibrary"), v.get());

        }

    } // AsfVideo::metadataHandler

    void AsfVideo::fileProperties()

    {

        DataBuf buf(9);

        buf.pData_[8] = '\0' ;

        byte guidBuf[16];

        io_->read(guidBuf, 16);

        char fileID[37] = ""; int count = 7;

        getGUID(guidBuf, fileID);

        xmpData_["Xmp.video.FileID"] = fileID;

        const TagDetails* td;

        while(count--) {

            td = find(filePropertiesTags , (count + 1));

            io_->read(buf.pData_, 8);

            if(count == 0) {

                buf.pData_[4] = '\0' ;

                io_->read(buf.pData_, 4); io_->read(buf.pData_, 4);

            }

            if(count == 3 || count == 2) {

                xmpData_[exvGettext(td->label_)] = getUint64_t(buf) / 10000;

            }

            else {

                xmpData_[exvGettext(td->label_)] = getUint64_t(buf);

            }

        }

    } // AsfVideo::fileProperties

    void AsfVideo::aspectRatio()

    {

        //TODO - Make a better unified method to handle all cases of Aspect Ratio

        double aspectRatio = (double)width_ / (double)height_;

        aspectRatio = floor(aspectRatio*10) / 10;

        xmpData_["Xmp.video.AspectRatio"] = aspectRatio;

        int aR = (int) ((aspectRatio*10.0)+0.1);

        switch  (aR) {

            case 13 : xmpData_["Xmp.video.AspectRatio"] = "4:3"     ; break;

            case 17 : xmpData_["Xmp.video.AspectRatio"] = "16:9"    ; break;

            case 10 : xmpData_["Xmp.video.AspectRatio"] = "1:1"     ; break;

            case 16 : xmpData_["Xmp.video.AspectRatio"] = "16:10"   ; break;

            case 22 : xmpData_["Xmp.video.AspectRatio"] = "2.21:1"  ; break;

            case 23 : xmpData_["Xmp.video.AspectRatio"] = "2.35:1"  ; break;

            case 12 : xmpData_["Xmp.video.AspectRatio"] = "5:4"     ; break;

            default : xmpData_["Xmp.video.AspectRatio"] = aspectRatio;break;

        }

    } // AsfVideo::aspectRatio

    Image::AutoPtr newAsfInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new AsfVideo(io));

        if (!image->good()) {

            image.reset();

        }

        return image;

    }

    bool isAsfType(BasicIo& iIo, bool advance)

    {

        const int32_t len = 16;

        byte buf[len];

        iIo.read(buf, len);

        if (iIo.error() || iIo.eof()) {

            return false;

        }

        bool matched = isASFType(buf);

        if (!advance || !matched) {

            iIo.seek(0, BasicIo::beg);

        }

        return matched;

    }

}                                       // namespace Exiv2

#endif // EXV_ENABLE_VIDEO