// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2021 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
