API tools faq
paste
Advertisement
Guest User

MediaInfo for Python

a guest
Feb 26th, 2014
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 24.37 KB | None | 0 0
raw download clone embed print report
  1. ## Copyright (c) MediaArea.net SARL. All Rights Reserved.
  2.  #
  3.  # Use of this source code is governed by a BSD-style license that can
  4.  # be found in the License.html file in the root of the source tree.
  5.  ##
  6.  
  7. # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  8. #
  9. #  Public DLL interface implementation
  10. #  Wrapper for MediaInfo Library
  11. #  Please see MediaInfo.h for help
  12. #
  13. # Converted to python module by Petr Kaderabek
  14. # Modifications by Jerome Martinez
  15. # Python 3 update by Jerome Martinez
  16. #
  17. # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
  18.  
  19. import os
  20. from ctypes import *
  21. if os.name == "nt" or os.name == "dos" or os.name == "os2" or os.name == "ce":
  22.     MediaInfoDLL_Handler = windll.MediaInfo
  23.     MustUseAnsi = 0
  24. else:
  25.     MediaInfoDLL_Handler = CDLL("libmediainfo.so.0")
  26.     MustUseAnsi = 1
  27.  
  28.  
  29. # types --> C Python:
  30. # size_t            c_size_t
  31. # unsigned char*    c_char_p
  32. # enum              c_size_t
  33. # const wchar_t*    c_wchar_p
  34. # int64u            c_ulonglong
  35. # NULL              None
  36. # these functions need strings in unicode format
  37.  
  38.  
  39.  
  40.  
  41. class Stream:
  42.     General, Video, Audio, Text, Other, Image, Menu, Max = range(8)
  43.  
  44. class Info:
  45.     Name, Text, Measure, Options, Name_Text, Measure_Text, Info, HowTo, Max = range(9)
  46.  
  47. class InfoOption:
  48.     ShowInInform, Reserved, ShowInSupported, TypeOfValue, Max = range(5)
  49.  
  50. class FileOptions:
  51.     Nothing, Recursive, CloseAll, xxNonexx_3, Max = range(5)
  52.  
  53.  
  54.  
  55. class MediaInfo:
  56.  
  57.     #MEDIAINFO_EXP void*         __stdcall MediaInfo_New (); /*you must ALWAYS call MediaInfo_Delete(Handle) in order to free memory*/
  58.     #/** @brief A 'new' MediaInfo interface (with a quick init of useful options : "**VERSION**;**APP_NAME**;**APP_VERSION**", but without debug information, use it only if you know what you do), return a Handle, don't forget to delete it after using it*/
  59.     MediaInfo_New = MediaInfoDLL_Handler.MediaInfo_New
  60.     MediaInfo_New.argtypes = []
  61.     MediaInfo_New.restype  = c_void_p
  62.  
  63.     #MEDIAINFO_EXP void*         __stdcall MediaInfo_New_Quick (const wchar_t* File, const wchar_t* Options); /*you must ALWAYS call MediaInfo_Delete(Handle) in order to free memory*/
  64.     MediaInfo_New_Quick = MediaInfoDLL_Handler.MediaInfo_New_Quick
  65.     MediaInfo_New_Quick.argtypes = [c_wchar_p, c_wchar_p]
  66.     MediaInfo_New_Quick.restype  = c_void_p
  67.     MediaInfoA_New_Quick = MediaInfoDLL_Handler.MediaInfoA_New_Quick
  68.     MediaInfoA_New_Quick.argtypes = [c_char_p, c_char_p]
  69.     MediaInfoA_New_Quick.restype  = c_void_p
  70.  
  71.     #/** @brief Delete a MediaInfo interface*/
  72.     #MEDIAINFO_EXP void       __stdcall MediaInfo_Delete (void* Handle);
  73.     MediaInfo_Delete = MediaInfoDLL_Handler.MediaInfo_Delete
  74.     MediaInfo_Delete.argtypes = [c_void_p]
  75.     MediaInfo_Delete.restype  = None
  76.  
  77.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open (with a filename)*/
  78.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open (void* Handle, const wchar_t* File);
  79.     MediaInfo_Open = MediaInfoDLL_Handler.MediaInfo_Open
  80.     MediaInfo_Open.argtype = [c_void_p, c_wchar_p]
  81.     MediaInfo_Open.restype = c_size_t
  82.     MediaInfoA_Open = MediaInfoDLL_Handler.MediaInfoA_Open
  83.     MediaInfoA_Open.argtype = [c_void_p, c_char_p]
  84.     MediaInfoA_Open.restype = c_size_t
  85.  
  86.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open (with a buffer) */
  87.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open_Buffer (void* Handle, const unsigned char* Begin, size_t Begin_Size, const unsigned char* End, size_t End_Size); /*return Handle*/
  88.     MediaInfo_Open_Buffer = MediaInfoDLL_Handler.MediaInfo_Open_Buffer
  89.     MediaInfo_Open_Buffer.argtype = [c_void_p, c_void_p, c_size_t, c_void_p, c_size_t]
  90.     MediaInfo_Open_Buffer.restype = c_size_t
  91.  
  92.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open_Buffer_Init (with a buffer) */
  93.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open_Buffer_Init (void* Handle, int64u File_Size, int64u File_Offset);
  94.     MediaInfo_Open_Buffer_Init = MediaInfoDLL_Handler.MediaInfo_Open_Buffer_Init
  95.     MediaInfo_Open_Buffer_Init.argtype = [c_void_p, c_ulonglong, c_ulonglong]
  96.     MediaInfo_Open_Buffer_Init.restype = c_size_t
  97.  
  98.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open_Buffer_Continue (with a buffer) */
  99.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open_Buffer_Continue (void* Handle, const unsigned char* Buffer, size_t Buffer_Size);
  100.     MediaInfo_Open_Buffer_Continue = MediaInfoDLL_Handler.MediaInfo_Open_Buffer_Continue
  101.     MediaInfo_Open_Buffer_Continue.argtype = [c_void_p, c_void_p, c_size_t]
  102.     MediaInfo_Open_Buffer_Continue.restype = c_size_t
  103.  
  104.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open_Buffer_Continue_GoTo_Get (with a buffer) */
  105.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open_Buffer_Continue_GoTo_Get (void* Handle);
  106.     MediaInfo_Open_Buffer_Continue_GoTo_Get = MediaInfoDLL_Handler.MediaInfo_Open_Buffer_Continue_GoTo_Get
  107.     MediaInfo_Open_Buffer_Continue_GoTo_Get.argtype = [c_void_p]
  108.     MediaInfo_Open_Buffer_Continue_GoTo_Get.restype = c_ulonglong
  109.  
  110.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Open_Buffer_Finalize (with a buffer) */
  111.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Open_Buffer_Finalize (void* Handle);
  112.     MediaInfo_Open_Buffer_Finalize = MediaInfoDLL_Handler.MediaInfo_Open_Buffer_Finalize
  113.     MediaInfo_Open_Buffer_Finalize.argtype = [c_void_p]
  114.     MediaInfo_Open_Buffer_Finalize.restype = c_size_t
  115.  
  116.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Save */
  117.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Save (void* Handle);
  118.     MediaInfo_Save = MediaInfoDLL_Handler.MediaInfo_Save
  119.     MediaInfo_Save.argtype = [c_void_p]
  120.     MediaInfo_Save.restype = c_size_t
  121.  
  122.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Close */
  123.     #MEDIAINFO_EXP void       __stdcall MediaInfo_Close (void* Handle);
  124.     MediaInfo_Close = MediaInfoDLL_Handler.MediaInfo_Close
  125.     MediaInfo_Close.argtype = [c_void_p]
  126.     MediaInfo_Close.restype = None
  127.  
  128.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Inform */
  129.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfo_Inform (void* Handle, size_t Reserved); /*Default : Reserved=0*/
  130.     MediaInfo_Inform = MediaInfoDLL_Handler.MediaInfo_Inform
  131.     MediaInfo_Inform.argtype = [c_void_p, c_size_t]
  132.     MediaInfo_Inform.restype = c_wchar_p
  133.     MediaInfoA_Inform = MediaInfoDLL_Handler.MediaInfoA_Inform
  134.     MediaInfoA_Inform.argtype = [c_void_p, c_size_t]
  135.     MediaInfoA_Inform.restype = c_char_p
  136.  
  137.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Get */
  138.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfo_GetI (void* Handle, MediaInfo_stream_C StreamKind, size_t StreamNumber, size_t Parameter, MediaInfo_info_C InfoKind); /*Default : InfoKind=Info_Text*/
  139.     MediaInfo_GetI = MediaInfoDLL_Handler.MediaInfo_GetI
  140.     MediaInfo_GetI.argtype = [c_void_p, c_size_t, c_size_t, c_size_t, c_size_t]
  141.     MediaInfo_GetI.restype = c_wchar_p
  142.     MediaInfoA_GetI = MediaInfoDLL_Handler.MediaInfoA_GetI
  143.     MediaInfoA_GetI.argtype = [c_void_p, c_size_t, c_size_t, c_size_t, c_size_t]
  144.     MediaInfoA_GetI.restype = c_char_p
  145.  
  146.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Get */
  147.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfo_Get (void* Handle, MediaInfo_stream_C StreamKind, size_t StreamNumber, const wchar_t* Parameter, MediaInfo_info_C InfoKind, MediaInfo_info_C SearchKind); /*Default : InfoKind=Info_Text, SearchKind=Info_Name*/
  148.     MediaInfo_Get = MediaInfoDLL_Handler.MediaInfo_Get
  149.     MediaInfo_Get.argtype = [c_void_p, c_size_t, c_size_t, c_wchar_p, c_size_t, c_size_t]
  150.     MediaInfo_Get.restype = c_wchar_p
  151.     MediaInfoA_Get = MediaInfoDLL_Handler.MediaInfoA_Get
  152.     MediaInfoA_Get.argtype = [c_void_p, c_size_t, c_size_t, c_wchar_p, c_size_t, c_size_t]
  153.     MediaInfoA_Get.restype = c_char_p
  154.  
  155.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Set */
  156.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_SetI (void* Handle, const wchar_t* ToSet, MediaInfo_stream_C StreamKind, size_t StreamNumber, size_t Parameter, const wchar_t* OldParameter);
  157.     MediaInfo_SetI = MediaInfoDLL_Handler.MediaInfo_SetI
  158.     MediaInfo_SetI.argtype = [c_void_p, c_wchar_p, c_size_t, c_size_t, c_size_t, c_wchar_p]
  159.     MediaInfo_SetI.restype = c_void_p
  160.     MediaInfoA_SetI = MediaInfoDLL_Handler.MediaInfoA_SetI
  161.     MediaInfoA_SetI.argtype = [c_void_p, c_char_p, c_size_t, c_size_t, c_size_t, c_wchar_p]
  162.     MediaInfoA_SetI.restype = c_void_p
  163.  
  164.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Set */
  165.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Set (void* Handle, const wchar_t* ToSet, MediaInfo_stream_C StreamKind, size_t StreamNumber, const wchar_t* Parameter, const wchar_t* OldParameter);
  166.     MediaInfo_Set = MediaInfoDLL_Handler.MediaInfo_Set
  167.     MediaInfo_Set.argtype = [c_void_p, c_wchar_p, c_size_t, c_size_t, c_wchar_p, c_wchar_p]
  168.     MediaInfo_Set.restype = c_size_t
  169.     MediaInfoA_Set = MediaInfoDLL_Handler.MediaInfoA_Set
  170.     MediaInfoA_Set.argtype = [c_void_p, c_char_p, c_size_t, c_size_t, c_wchar_p, c_wchar_p]
  171.     MediaInfoA_Set.restype = c_size_t
  172.  
  173.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Option */
  174.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfo_Option (void* Handle, const wchar_t* Option, const wchar_t* Value);
  175.     MediaInfo_Option = MediaInfoDLL_Handler.MediaInfo_Option
  176.     MediaInfo_Option.argtype = [c_void_p, c_wchar_p, c_wchar_p]
  177.     MediaInfo_Option.restype = c_wchar_p
  178.     MediaInfoA_Option = MediaInfoDLL_Handler.MediaInfoA_Option
  179.     MediaInfoA_Option.argtype = [c_void_p, c_char_p, c_char_p]
  180.     MediaInfoA_Option.restype = c_char_p
  181.  
  182.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::State_Get */
  183.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_State_Get (void* Handle);
  184.     MediaInfo_State_Get = MediaInfoDLL_Handler.MediaInfo_State_Get
  185.     MediaInfo_State_Get.argtype = [c_void_p]
  186.     MediaInfo_State_Get.restype = c_size_t
  187.  
  188.     #/** @brief Wrapper for MediaInfoLib::MediaInfo::Count_Get */
  189.     #MEDIAINFO_EXP size_t       __stdcall MediaInfo_Count_Get (void* Handle, MediaInfo_stream_C StreamKind, size_t StreamNumber); /*Default : StreamNumber=-1*/
  190.     MediaInfo_Count_Get = MediaInfoDLL_Handler.MediaInfo_Count_Get
  191.     MediaInfo_Count_Get.argtype = [c_void_p, c_size_t, c_size_t]
  192.     MediaInfo_Count_Get.restype = c_size_t
  193.  
  194.     Handle = c_void_p(0)
  195.     MustUseAnsi = 0
  196.  
  197.     #Handling
  198.     def __init__(self):
  199.         self.Handle=self.MediaInfo_New()
  200.         self.MediaInfoA_Option(self.Handle, "CharSet", "UTF-8")
  201.     def __del__(self):
  202.         self.MediaInfo_Delete(self.Handle)
  203.     def Open(self, File):
  204.         if type(File)==str:
  205.             return self.MediaInfoA_Open (self.Handle, File);
  206.         elif MustUseAnsi:
  207.             return self.MediaInfoA_Open (self.Handle, File.encode("utf-8"));
  208.         else:
  209.             return self.MediaInfo_Open (self.Handle, File);
  210.     def Open_Buffer(self, Begin, Begin_Size, End=None, End_Size=0):
  211.         return self.MediaInfo_Open_Buffer(self.Handle, Begin, Begin_Size, End, End_Size)
  212.     def Open_Buffer_Init(self, File_Size, File_Offset):
  213.         return self.MediaInfo_Open_Buffer_Init(self.Handle, File_Size, File_Offset)
  214.     def Open_Buffer_Continue(self, Buffer, Buffer_Size):
  215.         return self.MediaInfo_Open_Buffer_Continue(self.Handle, Buffer, Buffer_Size)
  216.     def Open_Buffer_Continue_GoTo_Get(self):
  217.         return self.MediaInfo_Open_Buffer_Continue_GoTo_Get(self.Handle)
  218.     def Open_Buffer_Finalize(self):
  219.         return self.MediaInfo_Open_Buffer_Finalize(self.Handle)
  220.     def Save(self):
  221.         return self.MediaInfo_Save(self.Handle)
  222.     def Close(self):
  223.         return self.MediaInfo_Close(self.Handle)
  224.  
  225.     #General information
  226.     def Inform(self):
  227.         if MustUseAnsi:
  228.             return unicode(self.MediaInfoA_Inform(self.Handle, 0), "utf_8")
  229.         else:
  230.             return self.MediaInfo_Inform(self.Handle, 0)
  231.     def Get(self, StreamKind, StreamNumber, Parameter, InfoKind=Info.Text, SearchKind=Info.Name):
  232.         if type(Parameter)==str:
  233.             return unicode(self.MediaInfoA_Get(self.Handle, StreamKind, StreamNumber, Parameter, InfoKind, SearchKind), "utf_8")
  234.         elif MustUseAnsi:
  235.             return unicode(self.MediaInfoA_Get(self.Handle, StreamKind, StreamNumber, Parameter.encode("utf-8"), InfoKind, SearchKind), "utf_8")
  236.         else:
  237.             return self.MediaInfo_Get(self.Handle, StreamKind, StreamNumber, Parameter, InfoKind, SearchKind)
  238.     def GetI(self, StreamKind, StreamNumber, Parameter, InfoKind=Info.Text):
  239.         if MustUseAnsi:
  240.             return unicode(self.MediaInfoA_GetI(self.Handle, StreamKind, StreamNumber, Parameter, InfoKind), "utf_8")
  241.         else:
  242.             return self.MediaInfo_GetI(self.Handle, StreamKind, StreamNumber, Parameter, InfoKind)
  243.     def Set(self, ToSet, StreamKind, StreamNumber, Parameter, OldParameter=u""):
  244.         if type(Parameter)==str and type(OldParameter)==unicode:
  245.             Parameter=Parameter.decode("utf-8")
  246.         if type(Parameter)==unicode and type(OldParameter)==str:
  247.             OldParameter=OldParameter.decode("utf-8")
  248.         if type(Parameter)==str:
  249.             return self.MediaInfoA_Set(self.Handle, ToSet, StreamKind, StreamNumber, Parameter, OldParameter)
  250.         elif MustUseAnsi:
  251.             return self.MediaInfoA_Set(self.Handle, ToSet, StreamKind, StreamNumber, Parameter.encode("utf-8"), OldParameter.encode("utf-8"))
  252.         else:
  253.             return self.MediaInfo_Set(self.Handle, ToSet, StreamKind, StreamNumber, Parameter, OldParameter)
  254.     def SetI(self, ToSet, StreamKind, StreamNumber, Parameter, OldValue):
  255.         if MustUseAnsi:
  256.             return self.MediaInfoA_SetI(self.Handle, ToSet, StreamKind, StreamNumber, Parameter, OldValue.encode("utf-8"))
  257.         else:
  258.             return self.MediaInfo_SetI(self.Handle, ToSet, StreamKind, StreamNumber, Parameter, OldValue)
  259.  
  260.     #Options
  261.     def Option(self, Option, Value=u""):
  262.         if type(Option)==str and type(Value)==unicode:
  263.             Option=Option.decode("utf-8")
  264.         if type(Option)==unicode and type(Value)==str:
  265.             Value=Value.decode("utf-8")
  266.         if type(Option)==str:
  267.             return unicode(self.MediaInfoA_Option(self.Handle, Option.encode("utf-8"), Value.encode("utf-8")), "utf_8")
  268.         elif MustUseAnsi:
  269.             return unicode(self.MediaInfoA_Option(self.Handle, Option.encode("utf-8"), Value.encode("utf-8")), "utf_8")
  270.         else:
  271.             return self.MediaInfo_Option(self.Handle, Option, Value)
  272.     def Option_Static(self, Option, Value=u""):
  273.         if type(Option)==str and type(Value)==unicode:
  274.             Option=Option.decode("utf-8")
  275.         if type(Option)==unicode and type(Value)==str:
  276.             Value=Value.decode("utf-8")
  277.         if type(Option)==str:
  278.             return unicode(self.MediaInfoA_Option(None, Option, Value), "utf_8")
  279.         elif MustUseAnsi:
  280.             return unicode(self.MediaInfoA_Option(None, Option.encode("utf-8"), Value.encode("utf-8")), "utf_8")
  281.         else:
  282.             return self.MediaInfo_Option(None, Option, Value)
  283.     def State_Get(self):
  284.         return self.MediaInfo_State_Get(self.Handle)
  285.     def Count_Get(self, StreamKind, StreamNumber=-1):
  286.         if StreamNumber == -1:
  287.                 #We should use -1 the same way, but it fails on 64-bit
  288.                 #so we use slower Get() with a character string
  289.                 return int(self.Get(StreamKind, 0, "StreamCount"))
  290.         else:
  291.                 return self.MediaInfo_Count_Get(self.Handle, StreamKind, StreamNumber)
  292.  
  293.  
  294. class MediaInfoList:
  295.     #/** @brief A 'new' MediaInfoList interface, return a Handle, don't forget to delete it after using it*/
  296.     #MEDIAINFO_EXP void*             __stdcall MediaInfoList_New (); /*you must ALWAYS call MediaInfoList_Delete(Handle) in order to free memory*/
  297.     MediaInfoList_New = MediaInfoDLL_Handler.MediaInfoList_New
  298.     MediaInfoList_New.argtype = []
  299.     MediaInfoList_New.restype = c_void_p
  300.  
  301.     #/** @brief A 'new' MediaInfoList interface (with a quick init of useful options : "**VERSION**;**APP_NAME**;**APP_VERSION**", but without debug information, use it only if you know what you do), return a Handle, don't forget to delete it after using it*/
  302.     #MEDIAINFO_EXP void*             __stdcall MediaInfoList_New_Quick (const wchar_t* Files, const wchar_t* Config); /*you must ALWAYS call MediaInfoList_Delete(Handle) in order to free memory*/
  303.     MediaInfoList_New_Quick = MediaInfoDLL_Handler.MediaInfoList_New_Quick
  304.     MediaInfoList_New_Quick.argtype = [c_wchar_p, c_wchar_p]
  305.     MediaInfoList_New_Quick.restype = c_void_p
  306.  
  307.     #/** @brief Delete a MediaInfoList interface*/
  308.     #MEDIAINFO_EXP void           __stdcall MediaInfoList_Delete (void* Handle);
  309.     MediaInfoList_Delete = MediaInfoDLL_Handler.MediaInfoList_Delete
  310.     MediaInfoList_Delete.argtype = [c_void_p]
  311.  
  312.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Open (with a filename)*/
  313.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Open (void* Handle, const wchar_t* Files, const MediaInfo_fileoptions_C Options); /*Default : Options=MediaInfo_FileOption_Nothing*/
  314.     MediaInfoList_Open = MediaInfoDLL_Handler.MediaInfoList_Open
  315.     MediaInfoList_Open.argtype = [c_void_p, c_wchar_p, c_void_p]
  316.     MediaInfoList_Open.restype = c_void_p
  317.  
  318.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Open (with a buffer) */
  319.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Open_Buffer (void* Handle, const unsigned char* Begin, size_t Begin_Size, const unsigned char* End, size_t End_Size); /*return Handle*/
  320.     MediaInfoList_Open_Buffer = MediaInfoDLL_Handler.MediaInfoList_Open_Buffer
  321.     MediaInfoList_Open_Buffer.argtype = [c_void_p, c_void_p, c_void_p, c_void_p, c_void_p]
  322.     MediaInfoList_Open_Buffer.restype = c_void_p
  323.  
  324.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Save */
  325.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Save (void* Handle, size_t FilePos);
  326.     MediaInfoList_Save = MediaInfoDLL_Handler.MediaInfoList_Save
  327.     MediaInfoList_Save.argtype = [c_void_p, c_void_p]
  328.     MediaInfoList_Save.restype = c_void_p
  329.  
  330.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Close */
  331.     #MEDIAINFO_EXP void           __stdcall MediaInfoList_Close (void* Handle, size_t FilePos);
  332.     MediaInfoList_Close = MediaInfoDLL_Handler.MediaInfoList_Close
  333.     MediaInfoList_Close.argtype = [c_void_p, c_void_p]
  334.  
  335.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Inform */
  336.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfoList_Inform (void* Handle, size_t FilePos, size_t Reserved); /*Default : Reserved=0*/
  337.     MediaInfoList_Inform = MediaInfoDLL_Handler.MediaInfoList_Inform
  338.     MediaInfoList_Inform.argtype = [c_void_p, c_void_p, c_void_p]
  339.     MediaInfoList_Inform.restype = c_wchar_p
  340.  
  341.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Get */
  342.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfoList_GetI (void* Handle, size_t FilePos, MediaInfo_stream_C StreamKind, size_t StreamNumber, size_t Parameter, MediaInfo_info_C InfoKind); /*Default : InfoKind=Info_Text*/
  343.     MediaInfoList_GetI = MediaInfoDLL_Handler.MediaInfoList_GetI
  344.     MediaInfoList_GetI.argtype = [c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p]
  345.     MediaInfoList_GetI.restype = c_wchar_p
  346.  
  347.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Get */
  348.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfoList_Get (void* Handle, size_t FilePos, MediaInfo_stream_C StreamKind, size_t StreamNumber, const wchar_t* Parameter, MediaInfo_info_C InfoKind, MediaInfo_info_C SearchKind); /*Default : InfoKind=Info_Text, SearchKind=Info_Name*/
  349.     MediaInfoList_Get = MediaInfoDLL_Handler.MediaInfoList_Get
  350.     MediaInfoList_Get.argtype = [c_void_p, c_void_p, c_void_p, c_void_p, c_wchar_p, c_void_p, c_void_p]
  351.     MediaInfoList_Get.restype = c_wchar_p
  352.  
  353.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Set */
  354.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_SetI (void* Handle, const wchar_t* ToSet, size_t FilePos, MediaInfo_stream_C StreamKind, size_t StreamNumber, size_t Parameter, const wchar_t* OldParameter);
  355.     MediaInfoList_SetI = MediaInfoDLL_Handler.MediaInfoList_SetI
  356.     MediaInfoList_SetI.argtype = [c_void_p, c_wchar_p, c_void_p, c_void_p, c_void_p, c_void_p, c_wchar_p]
  357.     MediaInfoList_SetI.restype = c_void_p
  358.  
  359.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Set */
  360.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Set (void* Handle, const wchar_t* ToSet, size_t FilePos, MediaInfo_stream_C StreamKind, size_t StreamNumber, const wchar_t* Parameter, const wchar_t* OldParameter);
  361.     MediaInfoList_Set = MediaInfoDLL_Handler.MediaInfoList_Set
  362.     MediaInfoList_Set.argtype = [c_void_p, c_wchar_p, c_void_p, c_void_p, c_void_p, c_wchar_p, c_wchar_p]
  363.     MediaInfoList_Set.restype = c_void_p
  364.  
  365.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Option */
  366.     #MEDIAINFO_EXP const wchar_t*    __stdcall MediaInfoList_Option (void* Handle, const wchar_t* Option, const wchar_t* Value);
  367.     MediaInfoList_Option = MediaInfoDLL_Handler.MediaInfoList_Option
  368.     MediaInfoList_Option.argtype = [c_void_p, c_wchar_p, c_wchar_p]
  369.     MediaInfoList_Option.restype = c_wchar_p
  370.  
  371.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::State_Get */
  372.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_State_Get (void* Handle);
  373.     MediaInfoList_State_Get = MediaInfoDLL_Handler.MediaInfoList_State_Get
  374.     MediaInfoList_State_Get.argtype = [c_void_p]
  375.     MediaInfoList_State_Get.restype = c_void_p
  376.  
  377.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Count_Get */
  378.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Count_Get (void* Handle, size_t FilePos, MediaInfo_stream_C StreamKind, size_t StreamNumber); /*Default : StreamNumber=-1*/
  379.     MediaInfoList_Count_Get = MediaInfoDLL_Handler.MediaInfoList_Count_Get
  380.     MediaInfoList_Count_Get.argtype = [c_void_p, c_void_p, c_void_p, c_void_p]
  381.     MediaInfoList_Count_Get.restype = c_void_p
  382.  
  383.     #/** @brief Wrapper for MediaInfoListLib::MediaInfoList::Count_Get */
  384.     #MEDIAINFO_EXP size_t           __stdcall MediaInfoList_Count_Get_Files (void* Handle);
  385.     MediaInfoList_Count_Get_Files = MediaInfoDLL_Handler.MediaInfoList_Count_Get_Files
  386.     MediaInfoList_Count_Get_Files.argtype = [c_void_p]
  387.     MediaInfoList_Count_Get_Files.restype = c_void_p
  388.  
  389.     Handle = c_void_p(0)
  390.  
  391.     #Handling
  392.     def __init__(self):
  393.         self.Handle = self.MediaInfoList_New()
  394.     def __del__(self):
  395.         self.MediaInfoList_Delete(self.Handle)
  396.     def Open(self, Files, Options=FileOptions.Nothing):
  397.         return self.MediaInfoList_Open(self.Handle, Files, Options)
  398.     def Open_Buffer(self, Begin, Begin_Size, End=None, End_Size=0):
  399.         return self.MediaInfoList_Open_Buffer (self.Handle, Begin, Begin_Size, End, End_Size)
  400.     def Save(self, FilePos):
  401.         return self.MediaInfoList_Save(self.Handle, FilePos)
  402.     def Close(self, FilePos):
  403.         self.MediaInfoList_Close (self.Handle, FilePos)
  404.  
  405.     #General information
  406.     def Inform(self, FilePos, Reserved=0):
  407.         return self.MediaInfoList_Inform (self.Handle, FilePos, Reserved)
  408.     def GetI(self, FilePos, StreamKind, StreamNumber, Parameter, InfoKind=Info.Text):
  409.         return self.MediaInfoList_GetI (self.Handle, FilePos, StreamKind, StreamNumber, Parameter, InfoKind)
  410.     def Get(self, FilePos, StreamKind, StreamNumber, Parameter, InfoKind=Info.Text, SearchKind=Info.Name):
  411.         return self.MediaInfoList_Get (self.Handle, FilePos, StreamKind, StreamNumber, (Parameter), InfoKind, SearchKind)
  412.     def SetI(self, ToSet, FilePos, StreamKind, StreamNumber, Parameter, OldParameter=u""):
  413.         return self.MediaInfoList_SetI (self, Handle, ToSet, FilePos, StreamKind, StreamNumber, Parameter, OldParameter)
  414.     def Set(self, ToSet, FilePos, StreamKind, StreamNumber, Parameter, OldParameter=u""):
  415.         return self.MediaInfoList_Set (self.Handle, ToSet, FilePos, StreamKind, StreamNumber, Parameter, OldParameter)
  416.  
  417.     #Options
  418.     def Option(self, Option, Value=u""):
  419.         return self.MediaInfoList_Option (self.Handle, Option, Value)
  420.     def Option_Static(self, Option, Value=u""):
  421.         return self.MediaInfoList_Option(None, Option, Value)
  422.     def State_Get(self):
  423.         return self.MediaInfoList_State_Get (self.Handle)
  424.     def Count_Get(self, FilePos, StreamKind, StreamNumber):
  425.         return self.MediaInfoList_Count_Get (self.Handle, FilePos, StreamKind, StreamNumber=-1)
  426.     def Count_Get_Files(self):
  427.         return self.MediaInfoList_Count_Get_Files (self.Handle)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!