text
stringlengths 6
1.35M
|
|---|
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 8.01.0622 */
/* @@MIDL_FILE_HEADING( ) */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 500
#endif
/* verify that the <rpcsal.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCSAL_H_VERSION__
#define __REQUIRED_RPCSAL_H_VERSION__ 100
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif /* __RPCNDR_H_VERSION__ */
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __openservice_h__
#define __openservice_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __IOpenServiceActivityInput_FWD_DEFINED__
#define __IOpenServiceActivityInput_FWD_DEFINED__
typedef interface IOpenServiceActivityInput IOpenServiceActivityInput;
#endif /* __IOpenServiceActivityInput_FWD_DEFINED__ */
#ifndef __IOpenServiceActivityOutputContext_FWD_DEFINED__
#define __IOpenServiceActivityOutputContext_FWD_DEFINED__
typedef interface IOpenServiceActivityOutputContext IOpenServiceActivityOutputContext;
#endif /* __IOpenServiceActivityOutputContext_FWD_DEFINED__ */
#ifndef __IOpenService_FWD_DEFINED__
#define __IOpenService_FWD_DEFINED__
typedef interface IOpenService IOpenService;
#endif /* __IOpenService_FWD_DEFINED__ */
#ifndef __IOpenServiceManager_FWD_DEFINED__
#define __IOpenServiceManager_FWD_DEFINED__
typedef interface IOpenServiceManager IOpenServiceManager;
#endif /* __IOpenServiceManager_FWD_DEFINED__ */
#ifndef __OpenServiceManager_FWD_DEFINED__
#define __OpenServiceManager_FWD_DEFINED__
#ifdef __cplusplus
typedef class OpenServiceManager OpenServiceManager;
#else
typedef struct OpenServiceManager OpenServiceManager;
#endif /* __cplusplus */
#endif /* __OpenServiceManager_FWD_DEFINED__ */
#ifndef __OpenServiceActivityManager_FWD_DEFINED__
#define __OpenServiceActivityManager_FWD_DEFINED__
#ifdef __cplusplus
typedef class OpenServiceActivityManager OpenServiceActivityManager;
#else
typedef struct OpenServiceActivityManager OpenServiceActivityManager;
#endif /* __cplusplus */
#endif /* __OpenServiceActivityManager_FWD_DEFINED__ */
#ifndef __IOpenServiceActivity_FWD_DEFINED__
#define __IOpenServiceActivity_FWD_DEFINED__
typedef interface IOpenServiceActivity IOpenServiceActivity;
#endif /* __IOpenServiceActivity_FWD_DEFINED__ */
#ifndef __IEnumOpenServiceActivity_FWD_DEFINED__
#define __IEnumOpenServiceActivity_FWD_DEFINED__
typedef interface IEnumOpenServiceActivity IEnumOpenServiceActivity;
#endif /* __IEnumOpenServiceActivity_FWD_DEFINED__ */
#ifndef __IOpenServiceActivityCategory_FWD_DEFINED__
#define __IOpenServiceActivityCategory_FWD_DEFINED__
typedef interface IOpenServiceActivityCategory IOpenServiceActivityCategory;
#endif /* __IOpenServiceActivityCategory_FWD_DEFINED__ */
#ifndef __IEnumOpenServiceActivityCategory_FWD_DEFINED__
#define __IEnumOpenServiceActivityCategory_FWD_DEFINED__
typedef interface IEnumOpenServiceActivityCategory IEnumOpenServiceActivityCategory;
#endif /* __IEnumOpenServiceActivityCategory_FWD_DEFINED__ */
#ifndef __IOpenServiceActivityManager_FWD_DEFINED__
#define __IOpenServiceActivityManager_FWD_DEFINED__
typedef interface IOpenServiceActivityManager IOpenServiceActivityManager;
#endif /* __IOpenServiceActivityManager_FWD_DEFINED__ */
/* header files for imported files */
#include "objidl.h"
#include "oleidl.h"
#include "mshtml.h"
#include "exdisp.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_openservice_0000_0000 */
/* [local] */
//=--------------------------------------------------------------------------=
// openservice.h
//=--------------------------------------------------------------------------=
// (C) Copyright Microsoft Corporation. All Rights Reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//=--------------------------------------------------------------------------=
#include <winapifamily.h>
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef
enum OpenServiceErrors
{
OS_E_NOTFOUND = 0x80030002,
OS_E_NOTSUPPORTED = 0x80004021,
OS_E_CANCELLED = 0x80002ef1,
OS_E_GPDISABLED = 0xc00d0bdc
} OpenServiceErrors;
typedef
enum OpenServiceActivityContentType
{
ActivityContentNone = -1,
ActivityContentDocument = ( ActivityContentNone + 1 ) ,
ActivityContentSelection = ( ActivityContentDocument + 1 ) ,
ActivityContentLink = ( ActivityContentSelection + 1 ) ,
ActivityContentCount = ( ActivityContentLink + 1 )
} OpenServiceActivityContentType;
extern RPC_IF_HANDLE __MIDL_itf_openservice_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_openservice_0000_0000_v0_0_s_ifspec;
#ifndef __IOpenServiceActivityInput_INTERFACE_DEFINED__
#define __IOpenServiceActivityInput_INTERFACE_DEFINED__
/* interface IOpenServiceActivityInput */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceActivityInput;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("75cb4db9-6da0-4da3-83ce-422b6a433346")
IOpenServiceActivityInput : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetVariable(
/* [in] */ __RPC__in LPCWSTR pwzVariableName,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzVariableType,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrVariableContent) = 0;
virtual HRESULT STDMETHODCALLTYPE HasVariable(
/* [in] */ __RPC__in LPCWSTR pwzVariableName,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzVariableType,
/* [out] */ __RPC__out BOOL *pfHasVariable) = 0;
virtual HRESULT STDMETHODCALLTYPE GetType(
/* [out] */ __RPC__out OpenServiceActivityContentType *pType) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceActivityInputVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceActivityInput * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceActivityInput * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceActivityInput * This);
HRESULT ( STDMETHODCALLTYPE *GetVariable )(
__RPC__in IOpenServiceActivityInput * This,
/* [in] */ __RPC__in LPCWSTR pwzVariableName,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzVariableType,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrVariableContent);
HRESULT ( STDMETHODCALLTYPE *HasVariable )(
__RPC__in IOpenServiceActivityInput * This,
/* [in] */ __RPC__in LPCWSTR pwzVariableName,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzVariableType,
/* [out] */ __RPC__out BOOL *pfHasVariable);
HRESULT ( STDMETHODCALLTYPE *GetType )(
__RPC__in IOpenServiceActivityInput * This,
/* [out] */ __RPC__out OpenServiceActivityContentType *pType);
END_INTERFACE
} IOpenServiceActivityInputVtbl;
interface IOpenServiceActivityInput
{
CONST_VTBL struct IOpenServiceActivityInputVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceActivityInput_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceActivityInput_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceActivityInput_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceActivityInput_GetVariable(This,pwzVariableName,pwzVariableType,pbstrVariableContent) \
( (This)->lpVtbl -> GetVariable(This,pwzVariableName,pwzVariableType,pbstrVariableContent) )
#define IOpenServiceActivityInput_HasVariable(This,pwzVariableName,pwzVariableType,pfHasVariable) \
( (This)->lpVtbl -> HasVariable(This,pwzVariableName,pwzVariableType,pfHasVariable) )
#define IOpenServiceActivityInput_GetType(This,pType) \
( (This)->lpVtbl -> GetType(This,pType) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceActivityInput_INTERFACE_DEFINED__ */
#ifndef __IOpenServiceActivityOutputContext_INTERFACE_DEFINED__
#define __IOpenServiceActivityOutputContext_INTERFACE_DEFINED__
/* interface IOpenServiceActivityOutputContext */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceActivityOutputContext;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("e289deab-f709-49a9-b99e-282364074571")
IOpenServiceActivityOutputContext : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Navigate(
/* [in] */ __RPC__in LPCWSTR pwzUri,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzMethod,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzHeaders,
/* [unique][in] */ __RPC__in_opt IStream *pPostData) = 0;
virtual HRESULT STDMETHODCALLTYPE CanNavigate(
/* [in] */ __RPC__in LPCWSTR pwzUri,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzMethod,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzHeaders,
/* [unique][in] */ __RPC__in_opt IStream *pPostData,
/* [out] */ __RPC__out BOOL *pfCanNavigate) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceActivityOutputContextVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceActivityOutputContext * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceActivityOutputContext * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceActivityOutputContext * This);
HRESULT ( STDMETHODCALLTYPE *Navigate )(
__RPC__in IOpenServiceActivityOutputContext * This,
/* [in] */ __RPC__in LPCWSTR pwzUri,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzMethod,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzHeaders,
/* [unique][in] */ __RPC__in_opt IStream *pPostData);
HRESULT ( STDMETHODCALLTYPE *CanNavigate )(
__RPC__in IOpenServiceActivityOutputContext * This,
/* [in] */ __RPC__in LPCWSTR pwzUri,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzMethod,
/* [unique][in] */ __RPC__in_opt LPCWSTR pwzHeaders,
/* [unique][in] */ __RPC__in_opt IStream *pPostData,
/* [out] */ __RPC__out BOOL *pfCanNavigate);
END_INTERFACE
} IOpenServiceActivityOutputContextVtbl;
interface IOpenServiceActivityOutputContext
{
CONST_VTBL struct IOpenServiceActivityOutputContextVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceActivityOutputContext_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceActivityOutputContext_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceActivityOutputContext_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceActivityOutputContext_Navigate(This,pwzUri,pwzMethod,pwzHeaders,pPostData) \
( (This)->lpVtbl -> Navigate(This,pwzUri,pwzMethod,pwzHeaders,pPostData) )
#define IOpenServiceActivityOutputContext_CanNavigate(This,pwzUri,pwzMethod,pwzHeaders,pPostData,pfCanNavigate) \
( (This)->lpVtbl -> CanNavigate(This,pwzUri,pwzMethod,pwzHeaders,pPostData,pfCanNavigate) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceActivityOutputContext_INTERFACE_DEFINED__ */
#ifndef __IOpenService_INTERFACE_DEFINED__
#define __IOpenService_INTERFACE_DEFINED__
/* interface IOpenService */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenService;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("C2952ED1-6A89-4606-925F-1ED8B4BE0630")
IOpenService : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE IsDefault(
/* [out] */ __RPC__out BOOL *pfIsDefault) = 0;
virtual HRESULT STDMETHODCALLTYPE SetDefault(
/* [in] */ BOOL fDefault,
/* [in] */ __RPC__in HWND hwnd) = 0;
virtual HRESULT STDMETHODCALLTYPE GetID(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrID) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenService * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenService * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenService * This);
HRESULT ( STDMETHODCALLTYPE *IsDefault )(
__RPC__in IOpenService * This,
/* [out] */ __RPC__out BOOL *pfIsDefault);
HRESULT ( STDMETHODCALLTYPE *SetDefault )(
__RPC__in IOpenService * This,
/* [in] */ BOOL fDefault,
/* [in] */ __RPC__in HWND hwnd);
HRESULT ( STDMETHODCALLTYPE *GetID )(
__RPC__in IOpenService * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrID);
END_INTERFACE
} IOpenServiceVtbl;
interface IOpenService
{
CONST_VTBL struct IOpenServiceVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenService_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenService_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenService_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenService_IsDefault(This,pfIsDefault) \
( (This)->lpVtbl -> IsDefault(This,pfIsDefault) )
#define IOpenService_SetDefault(This,fDefault,hwnd) \
( (This)->lpVtbl -> SetDefault(This,fDefault,hwnd) )
#define IOpenService_GetID(This,pbstrID) \
( (This)->lpVtbl -> GetID(This,pbstrID) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenService_INTERFACE_DEFINED__ */
#ifndef __IOpenServiceManager_INTERFACE_DEFINED__
#define __IOpenServiceManager_INTERFACE_DEFINED__
/* interface IOpenServiceManager */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceManager;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("5664125f-4e10-4e90-98e4-e4513d955a14")
IOpenServiceManager : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE InstallService(
/* [in] */ __RPC__in LPCWSTR pwzServiceUrl,
/* [out] */ __RPC__deref_out_opt IOpenService **ppService) = 0;
virtual HRESULT STDMETHODCALLTYPE UninstallService(
/* [in] */ __RPC__in_opt IOpenService *pService) = 0;
virtual HRESULT STDMETHODCALLTYPE GetServiceByID(
/* [in] */ __RPC__in LPCWSTR pwzID,
/* [out] */ __RPC__deref_out_opt IOpenService **ppService) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceManagerVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceManager * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceManager * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceManager * This);
HRESULT ( STDMETHODCALLTYPE *InstallService )(
__RPC__in IOpenServiceManager * This,
/* [in] */ __RPC__in LPCWSTR pwzServiceUrl,
/* [out] */ __RPC__deref_out_opt IOpenService **ppService);
HRESULT ( STDMETHODCALLTYPE *UninstallService )(
__RPC__in IOpenServiceManager * This,
/* [in] */ __RPC__in_opt IOpenService *pService);
HRESULT ( STDMETHODCALLTYPE *GetServiceByID )(
__RPC__in IOpenServiceManager * This,
/* [in] */ __RPC__in LPCWSTR pwzID,
/* [out] */ __RPC__deref_out_opt IOpenService **ppService);
END_INTERFACE
} IOpenServiceManagerVtbl;
interface IOpenServiceManager
{
CONST_VTBL struct IOpenServiceManagerVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceManager_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceManager_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceManager_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceManager_InstallService(This,pwzServiceUrl,ppService) \
( (This)->lpVtbl -> InstallService(This,pwzServiceUrl,ppService) )
#define IOpenServiceManager_UninstallService(This,pService) \
( (This)->lpVtbl -> UninstallService(This,pService) )
#define IOpenServiceManager_GetServiceByID(This,pwzID,ppService) \
( (This)->lpVtbl -> GetServiceByID(This,pwzID,ppService) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceManager_INTERFACE_DEFINED__ */
#ifndef __IEOpenServiceObjects_LIBRARY_DEFINED__
#define __IEOpenServiceObjects_LIBRARY_DEFINED__
/* library IEOpenServiceObjects */
/* [uuid] */
EXTERN_C const IID LIBID_IEOpenServiceObjects;
EXTERN_C const CLSID CLSID_OpenServiceManager;
#ifdef __cplusplus
class DECLSPEC_UUID("098870b6-39ea-480b-b8b5-dd0167c4db59")
OpenServiceManager;
#endif
EXTERN_C const CLSID CLSID_OpenServiceActivityManager;
#ifdef __cplusplus
class DECLSPEC_UUID("c5efd803-50f8-43cd-9ab8-aafc1394c9e0")
OpenServiceActivityManager;
#endif
#endif /* __IEOpenServiceObjects_LIBRARY_DEFINED__ */
#ifndef __IOpenServiceActivity_INTERFACE_DEFINED__
#define __IOpenServiceActivity_INTERFACE_DEFINED__
/* interface IOpenServiceActivity */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceActivity;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("13645c88-221a-4905-8ed1-4f5112cfc108")
IOpenServiceActivity : public IOpenService
{
public:
virtual HRESULT STDMETHODCALLTYPE Execute(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput) = 0;
virtual HRESULT STDMETHODCALLTYPE CanExecute(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__out BOOL *pfCanExecute) = 0;
virtual HRESULT STDMETHODCALLTYPE CanExecuteType(
/* [in] */ OpenServiceActivityContentType type,
/* [out] */ __RPC__out BOOL *pfCanExecute) = 0;
virtual HRESULT STDMETHODCALLTYPE Preview(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput) = 0;
virtual HRESULT STDMETHODCALLTYPE CanPreview(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__out BOOL *pfCanPreview) = 0;
virtual HRESULT STDMETHODCALLTYPE CanPreviewType(
/* [in] */ OpenServiceActivityContentType type,
/* [out] */ __RPC__out BOOL *pfCanPreview) = 0;
virtual HRESULT STDMETHODCALLTYPE GetStatusText(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrStatusText) = 0;
virtual HRESULT STDMETHODCALLTYPE GetHomepageUrl(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrHomepageUrl) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDisplayName(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrDisplayName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDescription(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrDescription) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCategoryName(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrCategoryName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetIconPath(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrIconPath) = 0;
virtual HRESULT STDMETHODCALLTYPE GetIcon(
/* [in] */ BOOL fSmallIcon,
/* [out] */ __RPC__deref_out_opt HICON *phIcon) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDescriptionFilePath(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrXmlPath) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDownloadUrl(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrXmlUri) = 0;
virtual HRESULT STDMETHODCALLTYPE GetInstallUrl(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrInstallUri) = 0;
virtual HRESULT STDMETHODCALLTYPE IsEnabled(
/* [out] */ __RPC__out BOOL *pfIsEnabled) = 0;
virtual HRESULT STDMETHODCALLTYPE SetEnabled(
/* [in] */ BOOL fEnable) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceActivityVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceActivity * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceActivity * This);
HRESULT ( STDMETHODCALLTYPE *IsDefault )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__out BOOL *pfIsDefault);
HRESULT ( STDMETHODCALLTYPE *SetDefault )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ BOOL fDefault,
/* [in] */ __RPC__in HWND hwnd);
HRESULT ( STDMETHODCALLTYPE *GetID )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrID);
HRESULT ( STDMETHODCALLTYPE *Execute )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput);
HRESULT ( STDMETHODCALLTYPE *CanExecute )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__out BOOL *pfCanExecute);
HRESULT ( STDMETHODCALLTYPE *CanExecuteType )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ OpenServiceActivityContentType type,
/* [out] */ __RPC__out BOOL *pfCanExecute);
HRESULT ( STDMETHODCALLTYPE *Preview )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput);
HRESULT ( STDMETHODCALLTYPE *CanPreview )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__out BOOL *pfCanPreview);
HRESULT ( STDMETHODCALLTYPE *CanPreviewType )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ OpenServiceActivityContentType type,
/* [out] */ __RPC__out BOOL *pfCanPreview);
HRESULT ( STDMETHODCALLTYPE *GetStatusText )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrStatusText);
HRESULT ( STDMETHODCALLTYPE *GetHomepageUrl )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrHomepageUrl);
HRESULT ( STDMETHODCALLTYPE *GetDisplayName )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrDisplayName);
HRESULT ( STDMETHODCALLTYPE *GetDescription )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrDescription);
HRESULT ( STDMETHODCALLTYPE *GetCategoryName )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrCategoryName);
HRESULT ( STDMETHODCALLTYPE *GetIconPath )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrIconPath);
HRESULT ( STDMETHODCALLTYPE *GetIcon )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ BOOL fSmallIcon,
/* [out] */ __RPC__deref_out_opt HICON *phIcon);
HRESULT ( STDMETHODCALLTYPE *GetDescriptionFilePath )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrXmlPath);
HRESULT ( STDMETHODCALLTYPE *GetDownloadUrl )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrXmlUri);
HRESULT ( STDMETHODCALLTYPE *GetInstallUrl )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrInstallUri);
HRESULT ( STDMETHODCALLTYPE *IsEnabled )(
__RPC__in IOpenServiceActivity * This,
/* [out] */ __RPC__out BOOL *pfIsEnabled);
HRESULT ( STDMETHODCALLTYPE *SetEnabled )(
__RPC__in IOpenServiceActivity * This,
/* [in] */ BOOL fEnable);
END_INTERFACE
} IOpenServiceActivityVtbl;
interface IOpenServiceActivity
{
CONST_VTBL struct IOpenServiceActivityVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceActivity_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceActivity_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceActivity_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceActivity_IsDefault(This,pfIsDefault) \
( (This)->lpVtbl -> IsDefault(This,pfIsDefault) )
#define IOpenServiceActivity_SetDefault(This,fDefault,hwnd) \
( (This)->lpVtbl -> SetDefault(This,fDefault,hwnd) )
#define IOpenServiceActivity_GetID(This,pbstrID) \
( (This)->lpVtbl -> GetID(This,pbstrID) )
#define IOpenServiceActivity_Execute(This,pInput,pOutput) \
( (This)->lpVtbl -> Execute(This,pInput,pOutput) )
#define IOpenServiceActivity_CanExecute(This,pInput,pOutput,pfCanExecute) \
( (This)->lpVtbl -> CanExecute(This,pInput,pOutput,pfCanExecute) )
#define IOpenServiceActivity_CanExecuteType(This,type,pfCanExecute) \
( (This)->lpVtbl -> CanExecuteType(This,type,pfCanExecute) )
#define IOpenServiceActivity_Preview(This,pInput,pOutput) \
( (This)->lpVtbl -> Preview(This,pInput,pOutput) )
#define IOpenServiceActivity_CanPreview(This,pInput,pOutput,pfCanPreview) \
( (This)->lpVtbl -> CanPreview(This,pInput,pOutput,pfCanPreview) )
#define IOpenServiceActivity_CanPreviewType(This,type,pfCanPreview) \
( (This)->lpVtbl -> CanPreviewType(This,type,pfCanPreview) )
#define IOpenServiceActivity_GetStatusText(This,pInput,pbstrStatusText) \
( (This)->lpVtbl -> GetStatusText(This,pInput,pbstrStatusText) )
#define IOpenServiceActivity_GetHomepageUrl(This,pbstrHomepageUrl) \
( (This)->lpVtbl -> GetHomepageUrl(This,pbstrHomepageUrl) )
#define IOpenServiceActivity_GetDisplayName(This,pbstrDisplayName) \
( (This)->lpVtbl -> GetDisplayName(This,pbstrDisplayName) )
#define IOpenServiceActivity_GetDescription(This,pbstrDescription) \
( (This)->lpVtbl -> GetDescription(This,pbstrDescription) )
#define IOpenServiceActivity_GetCategoryName(This,pbstrCategoryName) \
( (This)->lpVtbl -> GetCategoryName(This,pbstrCategoryName) )
#define IOpenServiceActivity_GetIconPath(This,pbstrIconPath) \
( (This)->lpVtbl -> GetIconPath(This,pbstrIconPath) )
#define IOpenServiceActivity_GetIcon(This,fSmallIcon,phIcon) \
( (This)->lpVtbl -> GetIcon(This,fSmallIcon,phIcon) )
#define IOpenServiceActivity_GetDescriptionFilePath(This,pbstrXmlPath) \
( (This)->lpVtbl -> GetDescriptionFilePath(This,pbstrXmlPath) )
#define IOpenServiceActivity_GetDownloadUrl(This,pbstrXmlUri) \
( (This)->lpVtbl -> GetDownloadUrl(This,pbstrXmlUri) )
#define IOpenServiceActivity_GetInstallUrl(This,pbstrInstallUri) \
( (This)->lpVtbl -> GetInstallUrl(This,pbstrInstallUri) )
#define IOpenServiceActivity_IsEnabled(This,pfIsEnabled) \
( (This)->lpVtbl -> IsEnabled(This,pfIsEnabled) )
#define IOpenServiceActivity_SetEnabled(This,fEnable) \
( (This)->lpVtbl -> SetEnabled(This,fEnable) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceActivity_INTERFACE_DEFINED__ */
#ifndef __IEnumOpenServiceActivity_INTERFACE_DEFINED__
#define __IEnumOpenServiceActivity_INTERFACE_DEFINED__
/* interface IEnumOpenServiceActivity */
/* [unique][uuid][object] */
typedef IOpenServiceActivity *EnumActivityType;
EXTERN_C const IID IID_IEnumOpenServiceActivity;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("a436d7d2-17c3-4ef4-a1e8-5c86faff26c0")
IEnumOpenServiceActivity : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, *pceltFetched) EnumActivityType *rgelt,
/* [out] */ __RPC__out ULONG *pceltFetched) = 0;
virtual HRESULT STDMETHODCALLTYPE Skip(
/* [in] */ ULONG celt) = 0;
virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Clone(
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivity **ppenum) = 0;
};
#else /* C style interface */
typedef struct IEnumOpenServiceActivityVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IEnumOpenServiceActivity * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IEnumOpenServiceActivity * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IEnumOpenServiceActivity * This);
HRESULT ( STDMETHODCALLTYPE *Next )(
__RPC__in IEnumOpenServiceActivity * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, *pceltFetched) EnumActivityType *rgelt,
/* [out] */ __RPC__out ULONG *pceltFetched);
HRESULT ( STDMETHODCALLTYPE *Skip )(
__RPC__in IEnumOpenServiceActivity * This,
/* [in] */ ULONG celt);
HRESULT ( STDMETHODCALLTYPE *Reset )(
__RPC__in IEnumOpenServiceActivity * This);
HRESULT ( STDMETHODCALLTYPE *Clone )(
__RPC__in IEnumOpenServiceActivity * This,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivity **ppenum);
END_INTERFACE
} IEnumOpenServiceActivityVtbl;
interface IEnumOpenServiceActivity
{
CONST_VTBL struct IEnumOpenServiceActivityVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IEnumOpenServiceActivity_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IEnumOpenServiceActivity_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IEnumOpenServiceActivity_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IEnumOpenServiceActivity_Next(This,celt,rgelt,pceltFetched) \
( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) )
#define IEnumOpenServiceActivity_Skip(This,celt) \
( (This)->lpVtbl -> Skip(This,celt) )
#define IEnumOpenServiceActivity_Reset(This) \
( (This)->lpVtbl -> Reset(This) )
#define IEnumOpenServiceActivity_Clone(This,ppenum) \
( (This)->lpVtbl -> Clone(This,ppenum) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IEnumOpenServiceActivity_INTERFACE_DEFINED__ */
#ifndef __IOpenServiceActivityCategory_INTERFACE_DEFINED__
#define __IOpenServiceActivityCategory_INTERFACE_DEFINED__
/* interface IOpenServiceActivityCategory */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceActivityCategory;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("850AF9D6-7309-40b5-BDB8-786C106B2153")
IOpenServiceActivityCategory : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE HasDefaultActivity(
/* [out] */ __RPC__out BOOL *pfHasDefaultActivity) = 0;
virtual HRESULT STDMETHODCALLTYPE GetDefaultActivity(
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppDefaultActivity) = 0;
virtual HRESULT STDMETHODCALLTYPE SetDefaultActivity(
/* [in] */ __RPC__in_opt IOpenServiceActivity *pActivity,
/* [in] */ __RPC__in HWND hwnd) = 0;
virtual HRESULT STDMETHODCALLTYPE GetName(
/* [out] */ __RPC__deref_out_opt BSTR *pbstrName) = 0;
virtual HRESULT STDMETHODCALLTYPE GetActivityEnumerator(
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivity **ppEnumActivity) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceActivityCategoryVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceActivityCategory * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceActivityCategory * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceActivityCategory * This);
HRESULT ( STDMETHODCALLTYPE *HasDefaultActivity )(
__RPC__in IOpenServiceActivityCategory * This,
/* [out] */ __RPC__out BOOL *pfHasDefaultActivity);
HRESULT ( STDMETHODCALLTYPE *GetDefaultActivity )(
__RPC__in IOpenServiceActivityCategory * This,
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppDefaultActivity);
HRESULT ( STDMETHODCALLTYPE *SetDefaultActivity )(
__RPC__in IOpenServiceActivityCategory * This,
/* [in] */ __RPC__in_opt IOpenServiceActivity *pActivity,
/* [in] */ __RPC__in HWND hwnd);
HRESULT ( STDMETHODCALLTYPE *GetName )(
__RPC__in IOpenServiceActivityCategory * This,
/* [out] */ __RPC__deref_out_opt BSTR *pbstrName);
HRESULT ( STDMETHODCALLTYPE *GetActivityEnumerator )(
__RPC__in IOpenServiceActivityCategory * This,
/* [in] */ __RPC__in_opt IOpenServiceActivityInput *pInput,
/* [in] */ __RPC__in_opt IOpenServiceActivityOutputContext *pOutput,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivity **ppEnumActivity);
END_INTERFACE
} IOpenServiceActivityCategoryVtbl;
interface IOpenServiceActivityCategory
{
CONST_VTBL struct IOpenServiceActivityCategoryVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceActivityCategory_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceActivityCategory_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceActivityCategory_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceActivityCategory_HasDefaultActivity(This,pfHasDefaultActivity) \
( (This)->lpVtbl -> HasDefaultActivity(This,pfHasDefaultActivity) )
#define IOpenServiceActivityCategory_GetDefaultActivity(This,ppDefaultActivity) \
( (This)->lpVtbl -> GetDefaultActivity(This,ppDefaultActivity) )
#define IOpenServiceActivityCategory_SetDefaultActivity(This,pActivity,hwnd) \
( (This)->lpVtbl -> SetDefaultActivity(This,pActivity,hwnd) )
#define IOpenServiceActivityCategory_GetName(This,pbstrName) \
( (This)->lpVtbl -> GetName(This,pbstrName) )
#define IOpenServiceActivityCategory_GetActivityEnumerator(This,pInput,pOutput,ppEnumActivity) \
( (This)->lpVtbl -> GetActivityEnumerator(This,pInput,pOutput,ppEnumActivity) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceActivityCategory_INTERFACE_DEFINED__ */
#ifndef __IEnumOpenServiceActivityCategory_INTERFACE_DEFINED__
#define __IEnumOpenServiceActivityCategory_INTERFACE_DEFINED__
/* interface IEnumOpenServiceActivityCategory */
/* [unique][uuid][object] */
typedef IOpenServiceActivityCategory *EnumActivityVerbType;
EXTERN_C const IID IID_IEnumOpenServiceActivityCategory;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("33627a56-8c9a-4430-8fd1-b5f5c771afb6")
IEnumOpenServiceActivityCategory : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, *pceltFetched) EnumActivityVerbType *rgelt,
/* [out] */ __RPC__out ULONG *pceltFetched) = 0;
virtual HRESULT STDMETHODCALLTYPE Skip(
/* [in] */ ULONG celt) = 0;
virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Clone(
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivityCategory **ppenum) = 0;
};
#else /* C style interface */
typedef struct IEnumOpenServiceActivityCategoryVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IEnumOpenServiceActivityCategory * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IEnumOpenServiceActivityCategory * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IEnumOpenServiceActivityCategory * This);
HRESULT ( STDMETHODCALLTYPE *Next )(
__RPC__in IEnumOpenServiceActivityCategory * This,
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, *pceltFetched) EnumActivityVerbType *rgelt,
/* [out] */ __RPC__out ULONG *pceltFetched);
HRESULT ( STDMETHODCALLTYPE *Skip )(
__RPC__in IEnumOpenServiceActivityCategory * This,
/* [in] */ ULONG celt);
HRESULT ( STDMETHODCALLTYPE *Reset )(
__RPC__in IEnumOpenServiceActivityCategory * This);
HRESULT ( STDMETHODCALLTYPE *Clone )(
__RPC__in IEnumOpenServiceActivityCategory * This,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivityCategory **ppenum);
END_INTERFACE
} IEnumOpenServiceActivityCategoryVtbl;
interface IEnumOpenServiceActivityCategory
{
CONST_VTBL struct IEnumOpenServiceActivityCategoryVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IEnumOpenServiceActivityCategory_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IEnumOpenServiceActivityCategory_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IEnumOpenServiceActivityCategory_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IEnumOpenServiceActivityCategory_Next(This,celt,rgelt,pceltFetched) \
( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) )
#define IEnumOpenServiceActivityCategory_Skip(This,celt) \
( (This)->lpVtbl -> Skip(This,celt) )
#define IEnumOpenServiceActivityCategory_Reset(This) \
( (This)->lpVtbl -> Reset(This) )
#define IEnumOpenServiceActivityCategory_Clone(This,ppenum) \
( (This)->lpVtbl -> Clone(This,ppenum) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IEnumOpenServiceActivityCategory_INTERFACE_DEFINED__ */
#ifndef __IOpenServiceActivityManager_INTERFACE_DEFINED__
#define __IOpenServiceActivityManager_INTERFACE_DEFINED__
/* interface IOpenServiceActivityManager */
/* [unique][uuid][object] */
EXTERN_C const IID IID_IOpenServiceActivityManager;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("8a2d0a9d-e920-4bdc-a291-d30f650bc4f1")
IOpenServiceActivityManager : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetCategoryEnumerator(
/* [in] */ OpenServiceActivityContentType eType,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivityCategory **ppEnum) = 0;
virtual HRESULT STDMETHODCALLTYPE GetActivityByID(
/* [in] */ __RPC__in LPCWSTR pwzActivityID,
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppActivity) = 0;
virtual HRESULT STDMETHODCALLTYPE GetActivityByHomepageAndCategory(
/* [in] */ __RPC__in LPCWSTR pwzHomepage,
/* [in] */ __RPC__in LPCWSTR pwzCategory,
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppActivity) = 0;
virtual HRESULT STDMETHODCALLTYPE GetVersionCookie(
/* [out] */ __RPC__out DWORD *pdwVersionCookie) = 0;
};
#else /* C style interface */
typedef struct IOpenServiceActivityManagerVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
__RPC__in IOpenServiceActivityManager * This,
/* [in] */ __RPC__in REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
__RPC__in IOpenServiceActivityManager * This);
ULONG ( STDMETHODCALLTYPE *Release )(
__RPC__in IOpenServiceActivityManager * This);
HRESULT ( STDMETHODCALLTYPE *GetCategoryEnumerator )(
__RPC__in IOpenServiceActivityManager * This,
/* [in] */ OpenServiceActivityContentType eType,
/* [out] */ __RPC__deref_out_opt IEnumOpenServiceActivityCategory **ppEnum);
HRESULT ( STDMETHODCALLTYPE *GetActivityByID )(
__RPC__in IOpenServiceActivityManager * This,
/* [in] */ __RPC__in LPCWSTR pwzActivityID,
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppActivity);
HRESULT ( STDMETHODCALLTYPE *GetActivityByHomepageAndCategory )(
__RPC__in IOpenServiceActivityManager * This,
/* [in] */ __RPC__in LPCWSTR pwzHomepage,
/* [in] */ __RPC__in LPCWSTR pwzCategory,
/* [out] */ __RPC__deref_out_opt IOpenServiceActivity **ppActivity);
HRESULT ( STDMETHODCALLTYPE *GetVersionCookie )(
__RPC__in IOpenServiceActivityManager * This,
/* [out] */ __RPC__out DWORD *pdwVersionCookie);
END_INTERFACE
} IOpenServiceActivityManagerVtbl;
interface IOpenServiceActivityManager
{
CONST_VTBL struct IOpenServiceActivityManagerVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IOpenServiceActivityManager_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IOpenServiceActivityManager_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IOpenServiceActivityManager_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IOpenServiceActivityManager_GetCategoryEnumerator(This,eType,ppEnum) \
( (This)->lpVtbl -> GetCategoryEnumerator(This,eType,ppEnum) )
#define IOpenServiceActivityManager_GetActivityByID(This,pwzActivityID,ppActivity) \
( (This)->lpVtbl -> GetActivityByID(This,pwzActivityID,ppActivity) )
#define IOpenServiceActivityManager_GetActivityByHomepageAndCategory(This,pwzHomepage,pwzCategory,ppActivity) \
( (This)->lpVtbl -> GetActivityByHomepageAndCategory(This,pwzHomepage,pwzCategory,ppActivity) )
#define IOpenServiceActivityManager_GetVersionCookie(This,pdwVersionCookie) \
( (This)->lpVtbl -> GetVersionCookie(This,pdwVersionCookie) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IOpenServiceActivityManager_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_openservice_0000_0010 */
/* [local] */
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
extern RPC_IF_HANDLE __MIDL_itf_openservice_0000_0010_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_openservice_0000_0010_v0_0_s_ifspec;
/* Additional Prototypes for ALL interfaces */
unsigned long __RPC_USER BSTR_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );
void __RPC_USER BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * );
unsigned long __RPC_USER HICON_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in HICON * );
unsigned char * __RPC_USER HICON_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in HICON * );
unsigned char * __RPC_USER HICON_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out HICON * );
void __RPC_USER HICON_UserFree( __RPC__in unsigned long *, __RPC__in HICON * );
unsigned long __RPC_USER HWND_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in HWND * );
unsigned char * __RPC_USER HWND_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in HWND * );
unsigned char * __RPC_USER HWND_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out HWND * );
void __RPC_USER HWND_UserFree( __RPC__in unsigned long *, __RPC__in HWND * );
unsigned long __RPC_USER BSTR_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * );
unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * );
void __RPC_USER BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * );
unsigned long __RPC_USER HICON_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in HICON * );
unsigned char * __RPC_USER HICON_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in HICON * );
unsigned char * __RPC_USER HICON_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out HICON * );
void __RPC_USER HICON_UserFree64( __RPC__in unsigned long *, __RPC__in HICON * );
unsigned long __RPC_USER HWND_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in HWND * );
unsigned char * __RPC_USER HWND_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in HWND * );
unsigned char * __RPC_USER HWND_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out HWND * );
void __RPC_USER HWND_UserFree64( __RPC__in unsigned long *, __RPC__in HWND * );
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
|
/*
* This header is generated by classdump-dyld 1.5
* on Wednesday, April 14, 2021 at 2:38:26 PM Mountain Standard Time
* Operating System: Version 14.4 (Build 18K802)
* Image Source: /System/Library/PrivateFrameworks/VideosUI.framework/VideosUI
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <VideosUI/VUIMediaItem.h>
#import <libobjc.A.dylib/VUIPlistMediaEntityImageLoadParamsCreating.h>
@class VUIPlistMediaDatabaseItem;
@interface VUIPlistMediaItem : VUIMediaItem <VUIPlistMediaEntityImageLoadParamsCreating> {
VUIPlistMediaDatabaseItem* _databaseItem;
}
@property (nonatomic,retain) VUIPlistMediaDatabaseItem * databaseItem; //@synthesize databaseItem=_databaseItem - In the implementation block
-(id)isLocal;
-(id)assetType;
-(id)showTitle;
-(id)seasonNumber;
-(id)showIdentifier;
-(id)playedState;
-(id)seasonIdentifier;
-(id)imageLoadParamsWithImageType:(unsigned long long)arg1 ;
-(id)initWithMediaLibrary:(id)arg1 identifier:(id)arg2 requestedProperties:(id)arg3 kind:(id)arg4 ;
-(id)initWithMediaLibrary:(id)arg1 databaseItem:(id)arg2 requestedProperties:(id)arg3 ;
-(id)previewFrameImageIdentifier;
-(id)seasonTitle;
-(id)coverArtImageIdentifier;
-(id)_valueForPropertyDescriptor:(id)arg1 ;
-(VUIPlistMediaDatabaseItem *)databaseItem;
-(void)setDatabaseItem:(VUIPlistMediaDatabaseItem *)arg1 ;
@end
|
//
// Weeks.h
// JodaTime
//
// Created by Christian Fruth on 28.04.14.
// Copyright (c) 2014 Boxx IT Solutions GmbH. All rights reserved.
//
# import "Period.h"
@class LocalDate;
@interface Weeks : Period
@property (nonatomic, readonly) NSInteger weeks;
+ (instancetype)ZERO;
+ (instancetype)ONE;
+ (instancetype)weeks:(NSInteger)weeks;
+ (instancetype)weeksBetween:(LocalDate *)startDate and:(LocalDate *)stopDate;
- (Weeks *)plus:(Weeks *)aWeeks;
- (Weeks *)minus:(Weeks *)aWeeks;
- (BOOL)isEqualToWeeks:(Weeks *)aDays;
- (NSComparisonResult)compare:(Weeks *)aDays;
@end
|
//
// files.h
//
// classes and functions for dealing with files
//
// Copyright Peter Andrews 2015 @ CSHL
//
#ifndef LONGMEM_FILES_H_
#define LONGMEM_FILES_H_
#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string> // Placed before cstring, no error, why?
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <limits>
#include <map>
#include <sstream>
#include <thread>
#include <utility>
#include <vector>
#include "error.h"
#ifndef MAP_POPULATE
#define MAP_POPULATE 0
#endif
namespace paa {
extern bool read_ahead;
extern bool memory_mapped;
// A safe file name
inline std::string safe_file_name(const std::string & name) {
if (name.empty()) return "";
std::istringstream stream{name.c_str()};
char c;
std::string result{""};
while (stream.get(c)) if (isalnum(c) || c == '.') result += c;
return result;
}
// Get file extension, if exists
inline std::string extension(const std::string & file_name) {
const size_t pos{file_name.find_last_of('.')};
if (pos == std::string::npos) return "";
return file_name.substr(pos);
}
// Grab file contents as a string
inline std::string file_string(const std::string & name) {
std::ifstream css{name.c_str()};
std::string result;
char c;
while (css.get(c)) result += c;
return result;
}
// Files and directories
inline uint64_t file_size(const std::string & file_name) {
struct stat st;
if (stat(file_name.c_str(), &st)) {
return 0;
}
return static_cast<uint64_t>(st.st_size);
}
inline void mkdir(const std::string & dir_name) {
if (::mkdir(dir_name.c_str(),
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) &&
errno != EEXIST)
throw Error("Problem creating directory") << dir_name;
}
inline std::string get_cwd() {
constexpr uint64_t Ksize{1024};
char buffer[Ksize];
if (getcwd(buffer, Ksize) == nullptr)
throw Error("Problem getting current working directory");
return std::string(buffer);
}
inline void symlink(const std::string & target, const std::string & linkpath) {
#ifdef __CYGWIN__
throw Error("Cannot do symlink under cygwin");
#else
if (::symlink(target.c_str(), linkpath.c_str()) && errno != EEXIST)
throw Error("Problem creating symbilic link") << linkpath << "to" << target;
#endif
}
inline bool readable(const std::string & file) {
return !access(file.c_str(), R_OK);
}
inline void unlink(const std::string & file, const bool complain = false) {
if (::unlink(file.c_str()) && complain) {
throw Error("Could not unlink file") << file;
}
}
inline uint64_t get_block_size(const std::string name) {
struct stat sb;
if (stat(name.c_str(), &sb) == -1) {
perror("stat");
throw Error("stat call failure for") << name;
}
return sb.st_blksize;
}
inline std::string get_next_file(const std::string & name,
const std::string ext) {
static std::map<std::string, unsigned int> last_indexes;
for (unsigned int i{last_indexes[name + ext] + 1}; ; ++i) {
const std::string test{name + "." + std::to_string(i) + "." + ext};
if (!readable(test)) {
last_indexes[name] = i;
return test;
}
}
}
// Read Specific columns from disk
class Columns {
public:
Columns(const std::string & file_name, const uint64_t size_hint,
const std::string & columns, const bool header) {
// Get list of desired column names or numbers
std::istringstream column_input{columns.c_str()};
std::string column_spec;
while (getline(column_input, column_spec, ',')) {
// column spec is either name or name:type
std::istringstream spec_stream{column_spec.c_str()};
std::string column_name{};
std::string column_type{};
getline(spec_stream, column_name, ':');
if (spec_stream) {
spec_stream >> column_type;
}
column_names.push_back(column_name);
column_types.push_back(column_type);
}
// Input file name
std::ifstream input{file_name.c_str()};
if (!input) throw Error("Could not open input file") << file_name;
// Process header, or just use column numbers passed
using ColumnLookup = std::pair<unsigned int, unsigned int>;
const std::vector<ColumnLookup> column_numbers{
[this, header, columns, &input] () {
std::vector<ColumnLookup> result;
if (header) {
// Column names are strings
std::string header_line;
getline(input, header_line);
std::string column_name;
std::istringstream header_stream{header_line.c_str()};
unsigned int column{0};
while (header_stream >> column_name) {
const std::vector<std::string>::const_iterator found{
find(column_names.begin(), column_names.end(), column_name)};
if (found != column_names.end())
result.emplace_back(column, found - column_names.begin());
++column;
}
} else {
// Column names are numbers, starting with 1
for (unsigned int c{0}; c != column_names.size(); ++c) {
result.emplace_back(static_cast<unsigned int>(
stoul(column_names[c]) - 1), c);
column_names[c] = std::string(header ? "" : "column ") +
column_names[c];
}
sort(result.begin(), result.end(),
[](const ColumnLookup & lhs, const ColumnLookup & rhs) {
return lhs.first < rhs.first;
});
}
if (column_names.size() != result.size()) {
throw Error("Could not find all columns specified in")
<< columns;
}
return result;
}()};
if (0) {
std::cerr << "Parse:" << std::endl;
for (const std::pair<unsigned int, unsigned int> & lu : column_numbers) {
std::cerr << column_names[lu.second]
<< " " << lu.first << " " << lu.second << std::endl;
}
}
// Reserve space for data
data.resize(column_names.size());
for (unsigned int c{0}; c != data.size(); ++c) {
data.reserve(size_hint);
}
// Read in data line by line
std::string line;
std::string text;
double value{0};
while (getline(input, line)) {
std::istringstream stream{line.c_str()};
std::vector<ColumnLookup>::const_iterator nc{column_numbers.begin()};
unsigned int c{0};
while (stream) {
if (nc != column_numbers.end() && nc->first == c) {
if (stream >> value) data[nc++->second].push_back(value);
} else {
stream >> text;
}
++c;
}
}
if (0) std::cerr << "Read " << data[0].size()
<< " lines from " << file_name << std::endl;
}
const std::string & name(unsigned int c) const { return column_names[c]; }
const std::string & type(unsigned int c) const { return column_types[c]; }
uint64_t n_rows() const { return n_cols() ? data[0].size() : 0; }
unsigned int n_cols() const { return static_cast<unsigned int>(data.size()); }
const std::vector<double> & operator[](const unsigned int c) const {
return data[c];
}
private:
std::vector<std::string> column_names{};
std::vector<std::string> column_types{};
std::vector<std::vector<double>> data{};
};
// class FileVector {};
// Iterator for file-based vector
template<class Type, template <class ...> class Container>
class VectorIterator {
public:
// iterator properties
using value_type = Type;
using difference_type = std::ptrdiff_t;
using pointer = void;
using reference = void;
using iterator_category = std::random_access_iterator_tag;
// constructor
VectorIterator(const Container<Type> & file_, const uint64_t current_) :
file{&file_}, current{current_} { }
// null iterator construction
explicit VectorIterator(const void *) :
file{nullptr}, current{static_cast<uint64_t>(-1)} { }
// value access
const Type operator*() const { return (*file)[current]; }
const Type operator[](const uint64_t offset) const {
return (*file)[current + offset];
}
// const Type operator->() const { return (*file)[current]; }
// iterator comparison
bool operator!=(const VectorIterator & rhs) const {
return current != rhs.current;
}
bool operator==(const VectorIterator & rhs) const {
return current == rhs.current;
}
bool operator<(const VectorIterator & rhs) const {
return current < rhs.current;
}
int64_t operator-(const VectorIterator & rhs) const {
return static_cast<int64_t>(current) -
static_cast<int64_t>(rhs.current);
}
// iteration and random access
VectorIterator & operator++() {
++current;
return *this;
}
VectorIterator & operator--() {
--current;
return *this;
}
VectorIterator & operator+=(const uint64_t offset) {
current += offset;
return *this;
}
VectorIterator & operator-=(const uint64_t offset) {
current -= offset;
return *this;
}
VectorIterator operator+(const uint64_t offset) const {
VectorIterator advanced = *this;
advanced.current += offset;
return advanced;
}
VectorIterator operator-(const uint64_t offset) const {
VectorIterator advanced = *this;
advanced.current -= offset;
return advanced;
}
private:
const Container<Type> * file;
uint64_t current{0};
};
// Make an on-disk file (not in memory) act like a read-only vector
template<class Type>
class FileVector {
public:
using const_iterator = VectorIterator<Type, paa::FileVector>;
// deleted
FileVector(const FileVector &) = delete;
FileVector & operator=(const FileVector &) = delete;
FileVector & operator=(FileVector &&) = delete;
// construction
explicit FileVector(const std::string & file_name,
const bool warn_empty = true) :
file{fopen(file_name.c_str(), "rb")} {
// Try a few times - sometimes nfs is malfunctioning temporarily
if (file == nullptr) {
sleep(2);
file = fopen(file_name.c_str(), "rb");
if (file == nullptr) {
sleep(5);
file = fopen(file_name.c_str(), "rb");
if (file == nullptr) {
perror("Open File");
throw Error("Could not open file in FileVector") << file_name;
}
}
}
n_elem = file_size(file_name) / sizeof(Type);
if (warn_empty && n_elem == 0) {
std::cerr << "Empty file opened " << file_name << std::endl;
}
// fileno is not available on cygwin and is not posix
#if 0
const int fd{fileno(file)};
if (fd == -1) {
throw Error("Could not get file descriptor for file") << file_name;
}
struct stat buf;
if (fstat(fd, &buf) == -1) {
throw Error("Could not get status for file") << file_name;
}
const uint64_t file_size{static_cast<uint64_t>(buf.st_size)};
if (warn_empty && file_size == 0) {
std::cerr << "Empty file opened " << file_name << std::endl;
}
n_elem = file_size / sizeof(Type);
#endif
}
FileVector(FileVector && other) noexcept :
file{other.file},
n_elem{other.n_elem} {
other.file = nullptr;
other.n_elem = 0;
}
// size
uint64_t size() const { return n_elem; }
uint64_t bytes() const { return size() * sizeof(Type); }
// iteration
const_iterator begin() const {
return const_iterator{*this, 0};
}
const_iterator end() const {
return const_iterator{*this, size()};
}
// Just a memory location to read into
union FakeType {
uint64_t dummy; // to assure proper alignment
char data[sizeof(Type)];
};
// access
Type operator[](const uint64_t index) const {
FakeType entry;
if (fseek(file, index * sizeof(Type), SEEK_SET) != 0) {
throw Error("Problem seeking in file");
}
if (fread(&entry, sizeof(Type), 1, file) != 1) {
throw Error("Problem reading from file");
}
return reinterpret_cast<Type&>(entry);
}
Type back() const { return (*this)[size() - 1]; }
// destruction
~FileVector() {
if (file != nullptr) {
fclose(file);
}
}
private:
FILE * file{};
uint64_t n_elem{};
};
// Memory or Memory-Mapped read-only vector base class
template<class Type>
class MemoryVectorBase {
public:
typedef const Type * const_iterator;
typedef Type * iterator;
// deleted
MemoryVectorBase(const MemoryVectorBase &) = delete;
MemoryVectorBase & operator=(const MemoryVectorBase &) = delete;
MemoryVectorBase & operator=(MemoryVectorBase &&) = delete;
// construction
MemoryVectorBase() { }
MemoryVectorBase(MemoryVectorBase && other) noexcept :
data{other.data}, n_elem{other.n_elem} {
other.data = nullptr;
other.n_elem = 0;
}
// size
uint64_t size() const { return n_elem; }
uint64_t bytes() const { return size() * sizeof(Type); }
// iteration
const_iterator begin() const { return data; }
const_iterator end() const { return data + n_elem; }
iterator begin() { return data; }
iterator end() { return data + n_elem; }
// access
Type operator[](const uint64_t index) const { return data[index]; }
Type & operator[](const uint64_t index) { return data[index]; }
protected:
Type * data{nullptr};
uint64_t n_elem{0};
};
// In-Memory read-only vector
template<class Type>
class MemoryVector : public MemoryVectorBase<Type> {
public:
// typedefs
using Base = MemoryVectorBase<Type>;
using Base::data;
using Base::n_elem;
// construction
MemoryVector(MemoryVector && other) noexcept : Base{std::move(other)} { }
explicit MemoryVector(const std::string & file_name,
const bool warn_empty = true) {
const int input{open(file_name.c_str(), O_RDONLY)};
if (input == -1)
throw Error("could not open input") << file_name << "for reading";
struct stat buf;
if (fstat(input, &buf) == -1)
throw Error("Could not get status for file") << file_name;
const uint64_t file_size{static_cast<uint64_t>(buf.st_size)};
n_elem = file_size / sizeof(Type);
if (file_size == 0) {
if (warn_empty)
std::cerr << "Empty file in MemoryVector "
<< file_name << std::endl;
} else {
data = static_cast<Type *>(::operator new(sizeof(Type) * n_elem));
if (data == nullptr) throw Error("Could not allocate memory for")
<< file_name;
char * cdata{reinterpret_cast<char *>(data)};
uint64_t bytes_read{0};
unsigned int error_count{0};
while (bytes_read < file_size) {
const uint64_t bytes_to_read{file_size - bytes_read};
const int64_t read_result{
read(input, cdata + bytes_read, bytes_to_read)};
if (read_result == -1) {
if (++error_count > 10) {
perror("System error");
throw Error("Problem reading file in Memory Vector")
<< file_name << file_size << bytes_to_read;
}
} else {
bytes_read += read_result;
}
}
}
close(input);
}
// destruction
~MemoryVector() {
if (data != nullptr) delete data;
}
};
// Memory-mapped read-only vector
template<class Type, bool ReadAhead>
class TMappedVector : public MemoryVectorBase<Type> {
public:
// typedefs
using Base = MemoryVectorBase<Type>;
using Base::data;
using Base::n_elem;
using Base::bytes;
// construction
TMappedVector() : Base{} { }
TMappedVector(TMappedVector && other) noexcept : Base{std::move(other)} { }
TMappedVector(const std::string & file_name, const uint64_t expected) :
TMappedVector{file_name, false} {
if (this->size() != expected)
throw Error("Unexpected size in MappedVector") << file_name;
}
explicit TMappedVector(const std::string & file_name,
const bool warn_empty = true) {
const int input{open(file_name.c_str(), O_RDONLY)};
if (input == -1)
throw Error("could not open input") << file_name << "for reading";
struct stat buf;
if (fstat(input, &buf) == -1)
throw Error("Could not get status for file") << file_name;
const uint64_t file_size{static_cast<uint64_t>(buf.st_size)};
if (file_size == 0) {
if (warn_empty)
std::cerr << "Empty file in TMappedVector "
<< file_name << std::endl;
} else {
data = static_cast<Type *>(
mmap(nullptr, file_size, PROT_READ, MAP_SHARED |
(ReadAhead ? MAP_POPULATE : 0), input, 0));
if (data == MAP_FAILED) {
// Need PRIVATE on newer kernels with MAP_POPULATE
data = static_cast<Type *>(
mmap(nullptr, file_size, PROT_READ, MAP_PRIVATE |
(ReadAhead ? MAP_POPULATE : 0), input, 0));
if (data == MAP_FAILED) {
perror("System Error in mmap");
throw Error("Memory mapping error for mapped file")
<< file_name << file_size;
}
}
}
n_elem = file_size / sizeof(Type);
close(input);
}
// destruction
~TMappedVector() {
if (n_elem && munmap(data, bytes()))
perror("munmap error in TMappedVector");
}
};
// PreMapped loads slowly, but is used quickly
template <class Type> using PreMappedVector = TMappedVector<Type, true>;
// UnMapped loads instantly, but is used slowly at first
template <class Type> using UnMappedVector = TMappedVector<Type, false>;
// Use UnMapped as default
template <class Type> using MappedVector = UnMappedVector<Type>;
#if 0
// Only works for char Type
template <class Type>
class ZippedVector {
public:
ZippedVector(const std::string & unzipped_name, const uint64_t expected) {
const std::string unzip{"zcat " + unzipped_name + ".gz"};
redi::ipstream input{unzip.c_str()};
if (!input) throw Error("Problem executing command") << unzip;
input >> data;
if (data.size() != expected)
throw Error("Unexpected size in ZippedVector")
<< unzipped_name << data.size() << expected;
}
uint64_t size() const { return data.size(); }
const Type & operator[](const uint64_t index) const { return data[index]; }
private:
std::string data{};
};
#endif
//
// Class that loads data from text file the first time,
// and saves binary cache for later use of file
//
template <class Data>
class BinaryCache {
public:
class NormalFileEnd {};
template <class ParseStreamFun>
BinaryCache(const std::string & input_file_name,
ParseStreamFun parse_line,
std::string binary_file_name = "") {
if (binary_file_name.empty()) {
binary_file_name = input_file_name + ".bin";
}
if (!readable(binary_file_name)) {
try {
std::ifstream in_stream{input_file_name.c_str()};
std::ofstream out_stream{binary_file_name.c_str(), std::ios::binary};
if (!in_stream) throw Error("Could not open input file in BinaryCache")
<< input_file_name;
while (in_stream) {
const Data item{parse_line(in_stream)};
out_stream.write(reinterpret_cast<const char *>(&item), sizeof(Data));
}
} catch (NormalFileEnd &) {
if (false) std::cerr << "File end" << std::endl;
}
}
new (this) BinaryCache<Data>{binary_file_name};
}
explicit BinaryCache(const std::string & binary_file_name) :
data{binary_file_name} { }
uint64_t size() const { return data.size(); }
const Data & operator[](const uint64_t index) const {
return data[index];
}
const Data * begin() const { return data.begin(); }
const Data * end() const { return data.end(); }
private:
const PreMappedVector<Data> data{"/dev/null", false};
};
template <class Type>
void write_one(FILE * out, const Type & value, const char * name) {
const uint64_t written = fwrite(&value, sizeof(Type), 1, out);
if (written != 1) {
perror(nullptr);
throw Error("problem writing") << name;
}
}
template <class Type>
void read_one(FILE * in, Type & value, const char * name) {
const uint64_t read_in = fread(&value, sizeof(Type), 1, in);
if (read_in != 1) {
perror(nullptr);
throw Error("problem reading") << name;
}
}
inline void bwritec(FILE * output, const void * data, const std::string & name,
const uint64_t count) {
const uint64_t written = fwrite(data, 1, count, output);
if (written != count) {
perror(nullptr);
throw Error("problem writing") << count << "bytes at" << name
<< "only wrote" << written;
}
}
inline void bwritec(const std::string & filename, const void * data,
const std::string & name, const uint64_t count) {
FILE * output = fopen(filename.c_str(), "wb");
if (output == nullptr)
throw Error("could not open output") << filename << "for writing";
bwritec(output, data, name, count);
if (fclose(output) != 0)
throw Error("problem closing output file") << filename;
}
// Flexible Memory or Mapped vector
// memory - read / write / change size
// mapped - read only
template<class Type>
class FlexVector : public MemoryVectorBase<Type> {
public:
// typedefs
using Base = MemoryVectorBase<Type>;
using Base::data;
using Base::n_elem;
using Base::bytes;
// construction
FlexVector(const FlexVector &) = delete;
FlexVector & operator=(const FlexVector &) = delete;
FlexVector & operator=(FlexVector &&) = delete;
FlexVector() : Base{} { }
FlexVector(FlexVector && other) noexcept : Base{std::move(other)},
mapped_{other.mapped_} { other.mapped_ = false; }
explicit FlexVector(const uint64_t new_n_elem) : Base{} {
clear_and_resize(new_n_elem);
}
explicit FlexVector(const std::string & file_name,
const bool mapped__ = true,
const bool read_ahead_ = false,
const bool warn_empty = true) :
mapped_{mapped__} {
if (mapped_) {
read_mapped(file_name, read_ahead_, warn_empty);
} else {
read_memory(file_name);
}
}
// destruction
~FlexVector() {
// std::cerr << "Destroy FlexVector " << n_elem << " " << data << " "
// << mapped_ << std::endl;
free();
}
// Common functions
void free() {
if (data) {
if (mapped_) {
if (munmap(data, bytes())) {
perror("munmap error in FlexVector");
}
} else {
delete[] data;
}
}
}
void save(const std::string & file_name) const {
bwritec(file_name, data, "FlexVector", n_elem * sizeof(Type));
}
// Memory only functions
void clear_and_resize(const uint64_t new_n_elem) {
if (new_n_elem != n_elem) {
free();
n_elem = new_n_elem;
data = new Type[n_elem]();
} else {
for (uint64_t i{0}; i != n_elem; ++i) {
data[i] = Type();
}
}
}
void read_memory(const std::string &) {
throw Error("read_memory not implemented yet");
}
// Mapped only functions
void read_mapped(const std::string & file_name,
const bool read_ahead_ = true,
const bool warn_empty = true) {
free();
mapped_ = true;
const int fid{open(file_name.c_str(), O_RDONLY)};
if (fid == -1) {
throw Error("could not open input") << file_name << "for reading";
}
struct stat buf;
if (fstat(fid, &buf) == -1) {
throw Error("Could not get status for file") << file_name;
}
const uint64_t file_size{static_cast<uint64_t>(buf.st_size)};
if (file_size == 0) {
if (warn_empty) {
std::cerr << "Empty file in FlexVector " << file_name << std::endl;
}
data = nullptr;
} else {
data = static_cast<Type *>(
mmap(nullptr, file_size, PROT_READ, MAP_SHARED |
(read_ahead_ ? MAP_POPULATE : 0), fid, 0));
if (data == MAP_FAILED) {
// Need PRIVATE on newer kernels with MAP_POPULATE
data = static_cast<Type *>(
mmap(nullptr, file_size, PROT_READ, MAP_PRIVATE |
(read_ahead_ ? MAP_POPULATE : 0), fid, 0));
if (data == MAP_FAILED) {
perror("System Error in mmap");
throw Error("Memory mapping error for mapped file")
<< file_name << file_size;
}
}
}
n_elem = file_size / sizeof(Type);
close(fid);
}
private:
bool mapped_{false};
};
template<class T>
void bwrite(FILE * output, const T & data, const std::string & name,
const uint64_t count = 1) {
bwritec(output, &data, name, sizeof(T) * count);
}
// void bwritec(const std::string & filename, const void * data,
// const std::string & name, const uint64_t count);
template<class T>
void bwrite(const std::string & filename, const T & data,
const std::string & name,
const uint64_t count = 1) {
bwritec(filename, &data, name, sizeof(T) * count);
}
void breadc(FILE * input, void * data, const std::string & name,
const uint64_t count);
template<class T>
void bread(FILE * input, T & data, const std::string & name,
const uint64_t count = 1) {
breadc(input, &data, name, sizeof(T) * count);
}
void breadc(const std::string & filename, void * & data,
const std::string & name, const uint64_t count);
template<class T>
void bread(const std::string & filename, T * & data,
const std::string & name,
const uint64_t count = 1) {
breadc(filename, reinterpret_cast<void*&>(data), name, count * sizeof(T));
}
template<class Type>
class GrowingVector {
public:
typedef Type * iterator;
typedef const Type * const_iterator;
// deleted
GrowingVector(const GrowingVector &) = delete;
GrowingVector & operator=(const GrowingVector &) = delete;
// construction, etc
GrowingVector() noexcept(false) : GrowingVector{initial_size} {}
explicit GrowingVector(const uint64_t start_size) noexcept(false) :
capacity{start_size},
data{static_cast<Type *>(::operator new(sizeof(Type) * capacity))} { }
GrowingVector(GrowingVector && other) noexcept :
n_elem{other.n_elem}, capacity{other.capacity}, data{other.data} {
other.n_elem = 0;
other.capacity = 0;
other.data = nullptr;
}
GrowingVector & operator=(GrowingVector && other) noexcept {
if (capacity) delete data;
n_elem = other.n_elem;
capacity = other.capacity;
data = other.data;
other.n_elem = 0;
other.capacity = 0;
other.data = nullptr;
return *this;
}
// expansion
template<typename... VArgs>
void emplace_back(VArgs && ... args) {
expand_if_needed();
new (data + n_elem++) Type(std::forward<VArgs>(args) ...);
}
void push_back(const Type val) {
expand_if_needed();
data[n_elem++] = val;
}
template <class P>
void insert_back(P b, P e) {
while (b != e) {
push_back(*(b++));
}
}
// info
uint64_t bytes() const { return capacity * sizeof(Type); }
uint64_t size() const { return n_elem; }
// read only access
const Type * begin() const { return data; }
const Type * end() const { return data + n_elem; }
Type operator[](const uint64_t index) const { return data[index]; }
const Type back() const { return data[n_elem - 1]; }
// write access
Type * begin() { return data; }
Type * end() { return data + n_elem; }
Type & operator[](const uint64_t index) { return data[index]; }
Type & back() { return data[n_elem - 1]; }
// shrinking
void clear() { n_elem = 0; }
void reduce_size(const uint64_t new_size) { n_elem = new_size; }
// saving
void save(const std::string & file_name) const {
bwritec(file_name, data, "GrowingVector", n_elem * sizeof(Type));
}
void write(std::FILE * out_file) const {
bwritec(out_file, data, "GrowingVector", n_elem * sizeof(Type));
}
void write_n(std::FILE * out_file, const uint64_t n) const {
bwritec(out_file, data, "GrowingVector", n * sizeof(Type));
}
// destruction
~GrowingVector() { if (capacity) delete data; }
private:
void expand_if_needed() {
if (n_elem + 1 > capacity) {
capacity *= 2;
Type * new_data_location =
static_cast<Type *>(::operator new(sizeof(Type) * capacity));
memcpy(new_data_location, data, n_elem * sizeof(Type));
delete data;
data = new_data_location;
}
}
static constexpr uint64_t initial_size{1024};
uint64_t n_elem{0};
uint64_t capacity{0};
Type * data{nullptr};
};
class MappedFile {
public:
// deleted
MappedFile(const MappedFile &) = delete;
MappedFile operator=(const MappedFile &) = delete;
MappedFile & operator=(MappedFile &&) = delete;
MappedFile();
explicit MappedFile(const std::string & file_name_,
const bool warn_empty = true);
MappedFile(MappedFile && other) noexcept;
~MappedFile();
void load(const std::string & file_name_,
const bool warn_empty = true);
const std::string & name() const {
return file_name;
}
void unmap();
int advise(const char * start, uint64_t length, const int advice) const;
void sequential(const char * start = nullptr,
const uint64_t length = 0) const;
void random(const char * start = nullptr,
const uint64_t length = 0) const;
void unneeded(const char * start = nullptr,
const uint64_t length = 0) const;
void needed(const char * start = nullptr,
const uint64_t length = 0) const;
char * begin() {
return file_begin;
}
char * end() {
return file_end;
}
const char * begin() const {
return file_begin;
}
const char * end() const {
return file_end;
}
const char * cbegin() const {
return file_begin;
}
const char * cend() const {
return file_end;
}
uint64_t size() const {
return static_cast<uint64_t>(file_end - file_begin);
}
uint64_t page_size() const {
return page;
}
private:
std::string file_name{};
char * file_begin{nullptr};
char * file_end{nullptr};
uint64_t page{0};
};
class BinWriter {
public:
explicit BinWriter(const std::string & filename) :
outfile{fopen(filename.c_str(), "wb")} {
if (outfile == nullptr)
throw Error("could not open outfile") << filename << "for writing";
}
BinWriter(const BinWriter &) = delete;
BinWriter operator=(const BinWriter &) = delete;
~BinWriter() {
if (fclose(outfile) != 0)
std::cerr << "problem closing BinWriter outfile" << std::endl;
}
FILE * outfile;
};
template <class Out>
BinWriter & operator<<(BinWriter & writer, const Out out) {
bwrite(writer.outfile, out, "some binary value", 1);
return writer;
}
//
// FileMerger
//
// Keeps list of file names
// merges the objects in them
//
// keeps sorted list (1) of objects from front of files
// no objects elsewhere are lower than highest object in list (A)
//
// higher objects are still in files or in a separate sorted array (2)
//
// Merger opens and reads from files at current position
// then sorts objects in (2)
//
// when (1) is empty, (2) is transferred to (1) so that (A) is satisfied
//
// Buffered Closed File
//
// Read a stream from many thousands of files at once
// but can only have open 1000 or so at a time
// how to handle?
//
// Want to limit file open/close operations
// Want to limit read operations
// Want data from all files to be accessible quickly
// this means buffering, while attempting to keep
// all soon-to-be-used data in cache if possible,
// and maybe read-aheads to limit wait times for file access
//
// open file, read into big buffer, close file,
// copy section into small buffer
// read from small buffer until exhausted
// copy from big buffer into small buffer
// When big buffer exhausted, open thread to replenish
//
// keep small buffers in cache!
// Files are intended to be stored in an array!
// picture 4096 files
// 16 cores * 32 KB = 512 KB
// 512 KB / 4096 = 128 bytes
// if 24 bytes per record
// small buffer is 5.3 objects only!
//
// Similar reasoning gives for 20 MB shared cache
// big buffer is 10248 bytes and holds 426.6 objects
//
// ~15 Million objects chr 1 per file
// 30,000 file opens and reads per file
//
// 16 cores on wigclust 17-24
// 32 KB / core L1 cache
// 256 KB / core L2 cache
// 20 MB L3 cache x 2 processors
//
// Designed for sequential access
// using next()
// but can do initial binary search while open to find good starting point?
//
template <class Type,
unsigned int small_buffer_bytes = 128,
unsigned int big_buffer_bytes = 10240>
class BufferedClosedFile {
};
template<class Type>
class OldMappedVector {
public:
typedef Type * iterator;
typedef const Type * const_iterator;
// deleted
OldMappedVector(const OldMappedVector &) = delete;
OldMappedVector & operator=(const OldMappedVector &) = delete;
OldMappedVector & operator=(OldMappedVector &&) = delete;
// use these member functions during building only
OldMappedVector() : OldMappedVector{initial_size} {}
explicit OldMappedVector(const uint64_t start_size) : capacity{start_size},
data{static_cast<Type *>(::operator new(sizeof(Type) * capacity))} { }
OldMappedVector(OldMappedVector && old) noexcept :
file{std::move(old.file)}, mapped{old.mapped},
n_elem{old.n_elem}, capacity{old.capacity}, data{old.data} {
old.mapped = false;
old.capacity = 0;
}
template<typename... VArgs>
void emplace_back(VArgs && ... args) {
expand_if_needed();
new (data + n_elem++) Type(std::forward<VArgs>(args) ...);
}
void push_back(const Type val) {
expand_if_needed();
data[n_elem++] = val;
}
template <class P>
void insert_back(P b, P e) {
while (b != e) {
push_back(*(b++));
}
}
Type * begin() { return data; }
Type * end() { return data + n_elem; }
void clear() { n_elem = 0; }
void reduce_size(const uint64_t new_size) { n_elem = new_size; }
void save(const std::string & file_name) const {
bwritec(file_name, data, "OldMappedVector", n_elem * sizeof(Type));
}
void write(std::FILE * out_file) const {
bwritec(out_file, data, "OldMappedVector", n_elem * sizeof(Type));
}
void write_n(std::FILE * out_file, const uint64_t n) const {
bwritec(out_file, data, "OldMappedVector", n * sizeof(Type));
}
// use these member function during reading only
explicit OldMappedVector(const std::string & file_name,
const bool warn_empty = true) :
file{file_name, warn_empty},
mapped{file.begin() == nullptr ? false : true},
n_elem{file.size() / sizeof(Type)},
capacity{n_elem},
data{reinterpret_cast<Type *>(file.begin())} { }
const std::string & name() const { return file.name(); }
// these member functions can be used anytime
uint64_t bytes() const { return capacity * sizeof(Type); }
uint64_t size() const { return n_elem; }
const Type * begin() const { return data; }
const Type * end() const { return data + n_elem; }
Type operator[](const uint64_t index) const { return data[index]; }
Type & operator[](const uint64_t index) { return data[index]; }
const Type back() const { return data[n_elem - 1]; }
Type & back() { return data[n_elem - 1]; }
~OldMappedVector() { if (!mapped && capacity) delete data; }
private:
void expand_if_needed() {
if (n_elem + 1 > capacity) {
capacity *= 2;
Type * new_data_location =
static_cast<Type *>(::operator new(sizeof(Type) * capacity));
memcpy(new_data_location, data, n_elem * sizeof(Type));
delete data;
data = new_data_location;
}
}
static constexpr uint64_t initial_size{1000};
MappedFile file{};
bool mapped{false};
uint64_t n_elem{0};
uint64_t capacity{0};
Type * data{nullptr};
};
//
// a potentially dangerous class - exists in a build state or a read state
// and some member functions can only be used in one of the states
//
template<class Type>
class OlderMappedVector {
public:
typedef Type * iterator;
typedef const Type * const_iterator;
// deleted
OlderMappedVector(const OlderMappedVector &) = delete;
OlderMappedVector & operator=(const OlderMappedVector &) = delete;
OlderMappedVector & operator=(OlderMappedVector &&) = delete;
// use these member functions during building only
OlderMappedVector() : OlderMappedVector{initial_size} {}
explicit OlderMappedVector(const uint64_t start_size) : capacity{start_size},
data{static_cast<Type *>(::operator new(sizeof(Type) * capacity))} { }
OlderMappedVector(OlderMappedVector && old) noexcept :
file{std::move(old.file)}, mapped{old.mapped},
n_elem{old.n_elem}, capacity{old.capacity}, data{old.data} {
old.mapped = false;
old.capacity = 0;
}
template<typename... VArgs>
void emplace_back(VArgs && ... args) {
expand_if_needed();
new (data + n_elem++) Type(std::forward<VArgs>(args) ...);
}
void push_back(const Type val) {
expand_if_needed();
data[n_elem++] = val;
}
template <class P>
void insert_back(P b, P e) {
while (b != e) {
push_back(*(b++));
}
}
Type * begin() { return data; }
Type * end() { return data + n_elem; }
void clear() { n_elem = 0; }
void reduce_size(const uint64_t new_size) { n_elem = new_size; }
void save(const std::string & file_name) const {
bwritec(file_name, data, "OlderMappedVector", n_elem * sizeof(Type));
}
void write(std::FILE * out_file) const {
bwritec(out_file, data, "OlderMappedVector", n_elem * sizeof(Type));
}
void write_n(std::FILE * out_file, const uint64_t n) const {
bwritec(out_file, data, "OlderMappedVector", n * sizeof(Type));
}
// use these member function during reading only
explicit OlderMappedVector(const std::string & file_name,
const bool warn_empty = true) :
file{file_name, warn_empty},
mapped{file.begin() == nullptr ? false : true},
n_elem{file.size() / sizeof(Type)},
capacity{n_elem},
data{reinterpret_cast<Type *>(file.begin())} { }
const std::string & name() const { return file.name(); }
void load(const std::string & file_name_, const bool warn_empty = true) {
file.load(file_name_, warn_empty);
mapped = file.begin() == nullptr ? false : true;
n_elem = file.size() / sizeof(Type);
data = reinterpret_cast<Type *>(file.begin());
}
// these member functions can be used anytime
uint64_t bytes() const { return capacity * sizeof(Type); }
uint64_t size() const { return n_elem; }
const Type * begin() const { return data; }
const Type * end() const { return data + n_elem; }
Type operator[](const uint64_t index) const { return data[index]; }
Type & operator[](const uint64_t index) { return data[index]; }
const Type back() const { return data[n_elem - 1]; }
Type & back() { return data[n_elem - 1]; }
~OlderMappedVector() { if (!mapped && capacity) delete data; }
private:
void expand_if_needed() {
if (n_elem + 1 > capacity) {
capacity *= 2;
Type * new_data_location =
static_cast<Type *>(::operator new(sizeof(Type) * capacity));
memcpy(new_data_location, data, n_elem * sizeof(Type));
delete data;
data = new_data_location;
}
}
static constexpr uint64_t initial_size{1000};
MappedFile file{};
bool mapped{false};
uint64_t n_elem{0};
uint64_t capacity{0};
Type * data{nullptr};
};
template<class BigInt, class SmallInt>
class CompressedInts {
public:
explicit CompressedInts(const uint64_t capacity = 0,
const uint64_t n_lookup = 0) :
lookup{n_lookup}, small{capacity} { }
explicit CompressedInts(const std::string & dir,
const unsigned int small_start = 0,
const unsigned int lookup_start = 0) :
lookup{dir + "/lookup.bin"},
small{dir + "/counts.bin"},
big{dir + "/over.bin"},
small_position{small_start},
big_position{lookup[lookup_start]} {}
#if 0
CompressedInts(CompressedInts && other) noexcept {
lookup = move(other.lookup);
small = move(other.small);
big = move(other.big);
small_position = other.small_position;
big_position = other.big_position;
}
#endif
BigInt next_int() const {
if (small_position == small.size()) {
throw Error("Tried to read past end of CompressedInts");
return std::numeric_limits<BigInt>::max();
} else {
const SmallInt s = small[small_position++];
if (s == std::numeric_limits<SmallInt>::max()) {
return big[big_position++];
} else {
return s;
}
}
}
void add_int(unsigned int b) {
if (b > std::numeric_limits<BigInt>::max()) {
std::cerr << "add_int encountered big int " << b << std::endl;
b = std::numeric_limits<BigInt>::max();
}
if (b >= std::numeric_limits<SmallInt>::max()) {
small.push_back(std::numeric_limits<SmallInt>::max());
big.push_back(static_cast<BigInt>(b));
} else {
small.push_back(static_cast<SmallInt>(b));
}
}
void print_savings() const {
std::cerr << "Saved " << small.size() * (sizeof(BigInt)-sizeof(SmallInt)) -
big.size() * sizeof(BigInt) << " bytes" << std::endl;
}
void add_lookup_entry() {
lookup.push_back(static_cast<unsigned int>(big.size()));
}
void save(const std::string & dir_name) const {
mkdir(dir_name);
std::ostringstream counts_filename;
counts_filename << dir_name << "/counts.bin";
std::FILE * counts_file = fopen(counts_filename.str().c_str(), "wb");
if (counts_file == nullptr) throw Error("Problem opening counts file")
<< counts_filename.str();
if (fwrite(small.begin(), sizeof(SmallInt), small.size(), counts_file) !=
small.size())
throw Error("Problem writing in counts file")
<< counts_filename.str();
if (fclose(counts_file)) throw Error("Problem closing counts file")
<< counts_filename.str();
std::ostringstream over_filename;
over_filename << dir_name << "/over.bin";
std::FILE * over_file = fopen(over_filename.str().c_str(), "wb");
if (over_file == nullptr) throw Error("Problem opening over file")
<< over_filename.str();
if (fwrite(big.begin(), sizeof(BigInt), big.size(), over_file) !=
big.size())
throw Error("Problem writing in over file") << over_filename.str();
if (fclose(over_file)) throw Error("Problem closing over file")
<< over_filename.str();
std::ostringstream lookup_filename;
lookup_filename << dir_name << "/lookup.bin";
std::FILE * lookup_file = fopen(lookup_filename.str().c_str(), "wb");
if (lookup_file == nullptr) throw Error("Problem opening lookup file")
<< lookup_filename.str();
if (fwrite(lookup.begin(), sizeof(unsigned int),
lookup.size(), lookup_file) != lookup.size())
throw Error("Problem writing in lookup file")
<< lookup_filename.str();
if (fclose(lookup_file)) throw Error("Problem closing lookup file")
<< lookup_filename.str();
print_savings();
}
void relocate(const uint64_t new_small, const uint64_t new_lookup) const {
small_position = new_small;
big_position = lookup[new_lookup];
}
uint64_t size() const {
return small.size();
}
SmallInt clipped_result(const uint64_t i) const {
return small[i];
}
private:
OlderMappedVector<unsigned int> lookup;
OlderMappedVector<SmallInt> small;
OlderMappedVector<BigInt> big{};
mutable uint64_t small_position{0};
mutable uint64_t big_position{0};
};
typedef CompressedInts<uint16_t, uint8_t> Compressed;
template <class STREAM>
struct Fstream : public STREAM {
explicit Fstream(const std::string & file_name,
const std::string & description = "") :
STREAM{file_name} {
if (!*this) {
std::ostringstream message;
message << "Problem opening";
if (description.size()) message << ' ' << description;
message << " file " << file_name;
throw Error(message.str());
}
}
};
using iFstream = Fstream<std::ifstream>;
using oFstream = Fstream<std::ofstream>;
} // namespace paa
#endif // LONGMEM_FILES_H_
|
/*
* i2c.c
*
* Created on: 26/ott/2015
* Author: nicola
*/
// Function used to setup I2C1, that is P0.19 and P0.20 on LPC1769
// That's useful because an I2C-E2PROM 24LC64 is already present on evaluation board
//
#include "lpc1769.h"
#include "i2c.h"
unsigned char I2Cbuffer[I2C_BUFFER_LEN]; // I2C data buffer
unsigned char* I2CbufferPtr; // I2C buffer pointer
int I2CbufferCnt; // I2C buffer counter
int I2CrptStartPos; // I2C Repeated Start position
// I2C1 Interrupt request handler
void I2C1_IRQHandler(void)
{
unsigned int I2C_Status=0;
I2C_Status = I2C1STAT; // load I2C1 status register value
switch(I2C_Status)
{
case START: // START condition or
I2CbufferPtr = I2Cbuffer; // reset buffer pointer
case REP_START: // repeated START condition has been transmitted
I2C1DAT = *I2CbufferPtr; // load SLA+R/W to I2C1DAT
I2CbufferCnt--; // update buffer counter
I2C1CONCLR = (1<<5); // clear I2C STA flag
break;
////////////////////// Master transmitter mode
case SLA_W_ACK: // SLA+W has been transmitted; ACK has been received
case DATA_W_ACK: // Data byte in I2DAT has been transmitted; ACK has been received
if(I2CbufferCnt>0) // check buffer counter value
{
I2CbufferPtr++; // update buffer pointer
if(I2CbufferCnt!=I2CrptStartPos)
{
I2C1DAT = *I2CbufferPtr; // load data byte to I2C1DAT
I2CbufferCnt--; // update buffer counter
}
else
I2C1CONSET |= (1<<5); // set I2C START flag (REPEATED START)
}
else
I2C1CONSET = (1<<4); // set I2C STOP flag
break;
case SLA_W_NACK: // SLA+W has been transmitted; NOT ACK has been received
case DATA_W_NACK: // Data byte in I2DAT has been transmitted; NOT ACK has been received
I2C1CONSET = (1<<4); // set I2C STOP flag
break;
////////////////////////////////////
////////////////////// Master receiver mode
case SLA_R_ACK: // SLA+R has been transmitted; ACK has been received
I2CbufferPtr++; // update buffer pointer
break;
case DATA_R_ACK: // Data byte has been received; ACK has been returned
if(I2CbufferCnt>1) // check buffer counter value
I2C1CONSET = (1<<2); // set I2C AA flag
else
I2C1CONCLR = (1<<2); // clear I2C AA flag
*I2CbufferPtr = I2C1DAT; // load I2C1DAT to data byte
I2CbufferCnt--; // update buffer counter
break;
case DATA_R_NACK: // Data byte has been received; NOT ACK has been returned
*I2CbufferPtr = I2C1DAT; // load I2C1DAT to data byte
I2CbufferCnt--; // update buffer counter
case SLA_R_NACK: // SLA+R has been transmitted; NOT ACK has been received
I2C1CONSET = (1<<4); // set I2C STOP flag
break;
////////////////////////////////////
case NO_RELEVANT: // No relevant information available; SI = 0
break;
default: // undefined status
I2C1CONSET = (1<<4); // set I2C STOP flag
}
I2C1CONCLR = (1<<3); // clear I2C interrupt flag
return;
}
// I2C1 setup function
int setupI2C1()
{
PINSEL1 |= (0b1111 << 6); // set bit PINSEL1[9:6] at 0b1111 so that P0.19 act as SDA1 and P0.20 as SCL1
PINMODE1 |= (0b1010 << 6); // set bit PINMODE1[9:6] at 0b1010 so that P0.19 and P0.20 have neither pull-up nor pull-down
PINMODE_OD0 |= (0b11 << 19); // set bit PINMODE_OD0[20:19] at 0b11 so that P0.19 and P0.20 are open drain
ISER0 |= (0b1 << 11); // set ISER0[11] so that ISE_I2C1 interrupt is enabled
IPR2 |= (0b10000 << 27); // set IPR2[31:27] at 0b10000 so that IP_I2C1 has priority 0x10 (middle priority)
I2C1SCLH = I2C1SCLL = ((CORE_CLK/4)/I2C_STD_FREQ)/2; // check equation(13) at page 457 of User Manual
I2C1CONSET |= (1<<6); // set I2EN to enable I2C1 interface
return 0;
}
// I2C1 start function
int startI2C1()
{
I2C1CONSET |= (1<<5); // set I2C START flag
return 0;
}
|
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012, 2013 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef RIPPLE_CORE_CONFIG_H_INCLUDED
#define RIPPLE_CORE_CONFIG_H_INCLUDED
#include <ripple/basics/BasicConfig.h>
#include <ripple/basics/base_uint.h>
#include <ripple/protocol/SystemParameters.h> // VFALCO Breaks levelization
#include <ripple/beast/net/IPEndpoint.h>
#include <beast/core/string.hpp>
#include <ripple/beast/utility/Journal.h>
#include <boost/asio/ip/tcp.hpp> // VFALCO FIX: This include should not be here
#include <boost/filesystem.hpp> // VFALCO FIX: This include should not be here
#include <boost/lexical_cast.hpp>
#include <boost/optional.hpp>
#include <cstdint>
#include <map>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>
namespace ripple {
using namespace std::chrono_literals;
class Rules;
//------------------------------------------------------------------------------
enum SizedItemName
{
siSweepInterval,
siNodeCacheSize,
siNodeCacheAge,
siTreeCacheSize,
siTreeCacheAge,
siSLECacheSize,
siSLECacheAge,
siLedgerSize,
siLedgerAge,
siLedgerFetch,
siHashNodeDBCache,
siTxnDBCache,
siLgrDBCache,
};
struct SizedItem
{
SizedItemName item;
int sizes[5];
};
// This entire derived class is deprecated.
// For new config information use the style implied
// in the base class. For existing config information
// try to refactor code to use the new style.
//
class Config : public BasicConfig
{
public:
// Settings related to the configuration file location and directories
static char const* const configFileName;
static char const* const databaseDirName;
static char const* const validatorsFileName;
/** Returns the full path and filename of the debug log file. */
boost::filesystem::path getDebugLogFile () const;
/** Returns the full path and filename of the entropy seed file. */
boost::filesystem::path getEntropyFile () const;
private:
boost::filesystem::path CONFIG_FILE;
boost::filesystem::path CONFIG_DIR;
boost::filesystem::path DEBUG_LOGFILE;
void load ();
beast::Journal j_;
bool QUIET = false; // Minimize logging verbosity.
bool SILENT = false; // No output to console after startup.
/** Operate in stand-alone mode.
In stand alone mode:
- Peer connections are not attempted or accepted
- The ledger is not advanced automatically.
- If no ledger is loaded, the default ledger with the root
account is created.
*/
bool RUN_STANDALONE = false;
public:
bool doImport = false;
bool valShards = false;
bool ELB_SUPPORT = false;
std::vector<std::string> IPS; // Peer IPs from rippled.cfg.
std::vector<std::string> IPS_FIXED; // Fixed Peer IPs from rippled.cfg.
std::vector<std::string> SNTP_SERVERS; // SNTP servers from rippled.cfg.
enum StartUpType
{
FRESH,
NORMAL,
LOAD,
LOAD_FILE,
REPLAY,
NETWORK
};
StartUpType START_UP = NORMAL;
bool START_VALID = false;
std::string START_LEDGER;
// Network parameters
int const TRANSACTION_FEE_BASE = 10; // The number of fee units a reference transaction costs
// Note: The following parameters do not relate to the UNL or trust at all
std::size_t NETWORK_QUORUM = 0; // Minimum number of nodes to consider the network present
// Peer networking parameters
bool PEER_PRIVATE = false; // True to ask peers not to relay current IP.
int PEERS_MAX = 0;
std::chrono::seconds WEBSOCKET_PING_FREQ = 5min;
// Path searching
int PATH_SEARCH_OLD = 7;
int PATH_SEARCH = 7;
int PATH_SEARCH_FAST = 2;
int PATH_SEARCH_MAX = 10;
// Validation
boost::optional<std::size_t> VALIDATION_QUORUM; // validations to consider ledger authoritative
std::uint64_t FEE_DEFAULT = 10;
std::uint64_t FEE_ACCOUNT_RESERVE = 200*SYSTEM_CURRENCY_PARTS;
std::uint64_t FEE_OWNER_RESERVE = 50*SYSTEM_CURRENCY_PARTS;
std::uint64_t FEE_OFFER = 10;
// Node storage configuration
std::uint32_t LEDGER_HISTORY = 256;
std::uint32_t FETCH_DEPTH = 1000000000;
int NODE_SIZE = 0;
bool SSL_VERIFY = true;
std::string SSL_VERIFY_FILE;
std::string SSL_VERIFY_DIR;
// Thread pool configuration
std::size_t WORKERS = 0;
// These override the command line client settings
boost::optional<boost::asio::ip::address_v4> rpc_ip;
boost::optional<std::uint16_t> rpc_port;
std::unordered_set<uint256, beast::uhash<>> features;
public:
Config() = default;
int getSize (SizedItemName) const;
/* Be very careful to make sure these bool params
are in the right order. */
void setup (std::string const& strConf, bool bQuiet,
bool bSilent, bool bStandalone);
void setupControl (bool bQuiet,
bool bSilent, bool bStandalone);
/**
* Load the config from the contents of the string.
*
* @param fileContents String representing the config contents.
*/
void loadFromString (std::string const& fileContents);
bool quiet() const { return QUIET; }
bool silent() const { return SILENT; }
bool standalone() const { return RUN_STANDALONE; }
};
} // ripple
#endif
|
//
// Copyright (c) 2014-2016 THUNDERBEAST GAMES LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#pragma once
#include "JSBSourceWriter.h"
using namespace Atomic;
namespace ToolCore
{
class JSBPackage;
class JSBClass;
class JSBPackageWriter : public JSBSourceWriter
{
public:
virtual void GenerateSource();
virtual void PostProcess() {}
protected:
JSBPackageWriter(JSBPackage* package);
JSBPackage* package_;
};
}
|
#ifndef __SUB_TRACK_FILTER_H__
#define __SUB_TRACK_FILTER_H__
#include "abstractreader.h"
class SubTrackFilter
{
public:
SubTrackFilter(int pid) : m_srcPID(pid) {}
virtual ~SubTrackFilter() {}
static int pidToSubPid(int pid, int subPid) { return (pid << 16) + subPid; }
static bool isSubTrack(int pid) { return pid >= 65536; }
bool isSupportedTrack(int pid) const { return m_srcPID == pid; }
virtual int demuxPacket(DemuxedData& demuxedData, const PIDSet& acceptedPIDs, AVPacket& avPacket) = 0;
protected:
int m_srcPID;
};
#endif // __SUB_TRACK_FILTER_H__
|
//
// UIImage+Util.h
// iosapp
//
// Created by ChanAetern on 2/13/15.
// Copyright (c) 2015 oschina. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface UIImage (Util)
- (UIImage *)imageMaskedWithColor:(UIColor *)maskColor;
- (UIImage *)cropToRect:(CGRect)rect;
@end
|
#ifndef STDIO_H
#define STDIO_H
#include "os_type.h"
class STDIO
{
private:
uint8 *screen;
public:
STDIO();
// 初始化函数
void initialize();
// 打印字符c，颜色color到位置(x,y)
void print(uint x, uint y, uint8 c, uint8 color);
// 打印字符c，颜色color到光标位置
void print(uint8 c, uint8 color);
// 打印字符c，颜色默认到光标位置
void print(uint8 c);
// 移动光标到一维位置
void moveCursor(uint position);
// 移动光标到二维位置
void moveCursor(uint x, uint y);
// 获取光标位置
uint getCursor();
private:
// 滚屏
void rollUp();
};
#endif
|
/*
* Microsoft Advanced Streaming Format demuxer
* Copyright (c) 2014 Alexandra Hájková
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/attributes.h"
#include "libavutil/avstring.h"
#include "libavutil/bswap.h"
#include "libavutil/common.h"
#include "libavutil/dict.h"
#include "libavutil/internal.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/time_internal.h"
#include "avformat.h"
#include "avio_internal.h"
#include "avlanguage.h"
#include "id3v2.h"
#include "internal.h"
#include "riff.h"
#include "asf.h"
#include "asfcrypt.h"
#define ASF_BOOL 0x2
#define ASF_WORD 0x5
#define ASF_GUID 0x6
#define ASF_DWORD 0x3
#define ASF_QWORD 0x4
#define ASF_UNICODE 0x0
#define ASF_FLAG_BROADCAST 0x1
#define ASF_BYTE_ARRAY 0x1
#define ASF_TYPE_AUDIO 0x2
#define ASF_TYPE_VIDEO 0x1
#define ASF_STREAM_NUM 0x7F
#define ASF_MAX_STREAMS 128
#define BMP_HEADER_SIZE 40
#define ASF_NUM_OF_PAYLOADS 0x3F
#define ASF_ERROR_CORRECTION_LENGTH_TYPE 0x60
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
typedef struct GUIDParseTable {
const char *name;
ff_asf_guid guid;
int (*read_object)(AVFormatContext *, const struct GUIDParseTable *);
int is_subobject;
} GUIDParseTable;
typedef struct ASFPacket {
AVPacket avpkt;
int64_t dts;
uint32_t frame_num; // ASF payloads with the same number are parts of the same frame
int flags;
int data_size;
int duration;
int size_left;
uint8_t stream_index;
} ASFPacket;
typedef struct ASFStream {
uint8_t stream_index; // from packet header
int index; // stream index in AVFormatContext, set in asf_read_stream_properties
int type;
int indexed; // added index entries from the Simple Index Object or not
int8_t span; // for deinterleaving
uint16_t virtual_pkt_len;
uint16_t virtual_chunk_len;
int16_t lang_idx;
ASFPacket pkt;
} ASFStream;
typedef struct ASFStreamData{
char langs[32];
AVDictionary *asf_met; // for storing per-stream metadata
AVRational aspect_ratio;
} ASFStreamData;
typedef struct ASFContext {
int data_reached;
int is_simple_index; // is simple index present or not 1/0
int is_header;
uint64_t preroll;
uint64_t nb_packets; // ASF packets
uint32_t packet_size;
int64_t send_time;
int duration;
uint32_t b_flags; // flags with broadcast flag
uint32_t prop_flags; // file properties object flags
uint64_t data_size; // data object size
uint64_t unknown_size; // size of the unknown object
int64_t offset; // offset of the current object
int64_t data_offset;
int64_t first_packet_offset; // packet offset
int64_t unknown_offset; // for top level header objects or subobjects without specified behavior
// ASF file must not contain more than 128 streams according to the specification
ASFStream *asf_st[ASF_MAX_STREAMS];
ASFStreamData asf_sd[ASF_MAX_STREAMS];
int nb_streams;
int stream_index; // from packet header, for the subpayload case
// packet parameters
uint64_t sub_header_offset; // offset of subpayload header
int64_t sub_dts;
uint8_t dts_delta; // for subpayloads
uint32_t packet_size_internal; // packet size stored inside ASFPacket, can be 0
int64_t packet_offset; // offset of the current packet inside Data Object
uint32_t pad_len; // padding after payload
uint32_t rep_data_len;
// packet state
uint64_t sub_left; // subpayloads left or not
unsigned int nb_sub; // number of subpayloads read so far from the current ASF packet
uint16_t mult_sub_len; // total length of subpayloads array inside multiple payload
uint64_t nb_mult_left; // multiple payloads left
int return_subpayload;
enum {
PARSE_PACKET_HEADER,
READ_SINGLE,
READ_MULTI,
READ_MULTI_SUB
} state;
} ASFContext;
static int detect_unknown_subobject(AVFormatContext *s, int64_t offset, int64_t size);
static const GUIDParseTable *find_guid(ff_asf_guid guid);
static int asf_probe(AVProbeData *pd)
{
/* check file header */
if (!ff_guidcmp(pd->buf, &ff_asf_header))
return AVPROBE_SCORE_MAX/2;
else
return 0;
}
static void swap_guid(ff_asf_guid guid)
{
FFSWAP(unsigned char, guid[0], guid[3]);
FFSWAP(unsigned char, guid[1], guid[2]);
FFSWAP(unsigned char, guid[4], guid[5]);
FFSWAP(unsigned char, guid[6], guid[7]);
}
static void align_position(AVIOContext *pb, int64_t offset, uint64_t size)
{
if (size < INT64_MAX - offset && avio_tell(pb) != offset + size)
avio_seek(pb, offset + size, SEEK_SET);
}
static int asf_read_unknown(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = avio_rl64(pb);
int ret;
if (size > INT64_MAX)
return AVERROR_INVALIDDATA;
if (asf->is_header)
asf->unknown_size = size;
asf->is_header = 0;
if (!g->is_subobject) {
if (!(ret = strcmp(g->name, "Header Extension")))
avio_skip(pb, 22); // skip reserved fields and Data Size
if ((ret = detect_unknown_subobject(s, asf->unknown_offset,
asf->unknown_size)) < 0)
return ret;
} else {
if (size < 24) {
av_log(s, AV_LOG_ERROR, "Too small size %"PRIu64" (< 24).\n", size);
return AVERROR_INVALIDDATA;
}
avio_skip(pb, size - 24);
}
return 0;
}
static int get_asf_string(AVIOContext *pb, int maxlen, char *buf, int buflen)
{
char *q = buf;
int ret = 0;
if (buflen <= 0)
return AVERROR(EINVAL);
while (ret + 1 < maxlen) {
uint8_t tmp;
uint32_t ch;
GET_UTF16(ch, (ret += 2) <= maxlen ? avio_rl16(pb) : 0, break;);
PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)
}
*q = 0;
return ret;
}
static int asf_read_marker(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = avio_rl64(pb);
int i, nb_markers, ret;
size_t len;
char name[1024];
avio_skip(pb, 8);
avio_skip(pb, 8); // skip reserved GUID
nb_markers = avio_rl32(pb);
avio_skip(pb, 2); // skip reserved field
len = avio_rl16(pb);
for (i = 0; i < len; i++)
avio_skip(pb, 1);
for (i = 0; i < nb_markers; i++) {
int64_t pts;
avio_skip(pb, 8);
pts = avio_rl64(pb);
pts -= asf->preroll * 10000;
avio_skip(pb, 2); // entry length
avio_skip(pb, 4); // send time
avio_skip(pb, 4); // flags
len = avio_rl32(pb);
if ((ret = avio_get_str16le(pb, len, name,
sizeof(name))) < len)
avio_skip(pb, len - ret);
avpriv_new_chapter(s, i, (AVRational) { 1, 10000000 }, pts,
AV_NOPTS_VALUE, name);
}
align_position(pb, asf->offset, size);
return 0;
}
static int asf_read_metadata(AVFormatContext *s, const char *title, uint16_t len,
unsigned char *ch, uint16_t buflen)
{
AVIOContext *pb = s->pb;
avio_get_str16le(pb, len, ch, buflen);
if (ch[0]) {
if (av_dict_set(&s->metadata, title, ch, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
}
return 0;
}
static int asf_read_value(AVFormatContext *s, const uint8_t *name,
uint16_t val_len, int type, AVDictionary **met)
{
int ret;
uint8_t *value;
uint16_t buflen = 2 * val_len + 1;
AVIOContext *pb = s->pb;
value = av_malloc(buflen);
if (!value)
return AVERROR(ENOMEM);
if (type == ASF_UNICODE) {
// get_asf_string reads UTF-16 and converts it to UTF-8 which needs longer buffer
if ((ret = get_asf_string(pb, val_len, value, buflen)) < 0)
goto failed;
if (av_dict_set(met, name, value, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
} else {
char buf[256];
if (val_len > sizeof(buf)) {
ret = AVERROR_INVALIDDATA;
goto failed;
}
if ((ret = avio_read(pb, value, val_len)) < 0)
goto failed;
if (ret < 2 * val_len)
value[ret] = '\0';
else
value[2 * val_len - 1] = '\0';
snprintf(buf, sizeof(buf), "%s", value);
if (av_dict_set(met, name, buf, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
}
av_freep(&value);
return 0;
failed:
av_freep(&value);
return ret;
}
static int asf_read_generic_value(AVIOContext *pb, int type, uint64_t *value)
{
switch (type) {
case ASF_BOOL:
*value = avio_rl16(pb);
break;
case ASF_DWORD:
*value = avio_rl32(pb);
break;
case ASF_QWORD:
*value = avio_rl64(pb);
break;
case ASF_WORD:
*value = avio_rl16(pb);
break;
default:
return AVERROR_INVALIDDATA;
}
return 0;
}
static int asf_set_metadata(AVFormatContext *s, const uint8_t *name,
int type, AVDictionary **met)
{
AVIOContext *pb = s->pb;
uint64_t value;
char buf[32];
int ret;
ret = asf_read_generic_value(pb, type, &value);
if (ret < 0)
return ret;
snprintf(buf, sizeof(buf), "%"PRIu64, value);
if (av_dict_set(met, name, buf, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
return 0;
}
/* MSDN claims that this should be "compatible with the ID3 frame, APIC",
* but in reality this is only loosely similar */
static int asf_read_picture(AVFormatContext *s, int len)
{
ASFContext *asf = s->priv_data;
AVPacket pkt = { 0 };
const CodecMime *mime = ff_id3v2_mime_tags;
enum AVCodecID id = AV_CODEC_ID_NONE;
char mimetype[64];
uint8_t *desc = NULL;
AVStream *st = NULL;
int ret, type, picsize, desc_len;
ASFStream *asf_st;
/* type + picsize + mime + desc */
if (len < 1 + 4 + 2 + 2) {
av_log(s, AV_LOG_ERROR, "Invalid attached picture size: %d.\n", len);
return AVERROR_INVALIDDATA;
}
/* picture type */
type = avio_r8(s->pb);
len--;
if (type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types) || type < 0) {
av_log(s, AV_LOG_WARNING, "Unknown attached picture type: %d.\n", type);
type = 0;
}
/* picture data size */
picsize = avio_rl32(s->pb);
len -= 4;
/* picture MIME type */
len -= avio_get_str16le(s->pb, len, mimetype, sizeof(mimetype));
while (mime->id != AV_CODEC_ID_NONE) {
if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
id = mime->id;
break;
}
mime++;
}
if (id == AV_CODEC_ID_NONE) {
av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
mimetype);
return 0;
}
if (picsize >= len) {
av_log(s, AV_LOG_ERROR, "Invalid attached picture data size: %d >= %d.\n",
picsize, len);
return AVERROR_INVALIDDATA;
}
/* picture description */
desc_len = (len - picsize) * 2 + 1;
desc = av_malloc(desc_len);
if (!desc)
return AVERROR(ENOMEM);
len -= avio_get_str16le(s->pb, len - picsize, desc, desc_len);
ret = av_get_packet(s->pb, &pkt, picsize);
if (ret < 0)
goto fail;
st = avformat_new_stream(s, NULL);
if (!st) {
ret = AVERROR(ENOMEM);
goto fail;
}
asf->asf_st[asf->nb_streams] = av_mallocz(sizeof(*asf_st));
asf_st = asf->asf_st[asf->nb_streams];
if (!asf_st) {
ret = AVERROR(ENOMEM);
goto fail;
}
st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codecpar->codec_type = asf_st->type = AVMEDIA_TYPE_VIDEO;
st->codecpar->codec_id = id;
st->attached_pic = pkt;
st->attached_pic.stream_index = asf_st->index = st->index;
st->attached_pic.flags |= AV_PKT_FLAG_KEY;
asf->nb_streams++;
if (*desc) {
if (av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
} else
av_freep(&desc);
if (av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
return 0;
fail:
av_freep(&desc);
av_packet_unref(&pkt);
return ret;
}
static void get_id3_tag(AVFormatContext *s, int len)
{
ID3v2ExtraMeta *id3v2_extra_meta = NULL;
ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, len);
if (id3v2_extra_meta)
ff_id3v2_parse_apic(s, &id3v2_extra_meta);
ff_id3v2_free_extra_meta(&id3v2_extra_meta);
}
static int process_metadata(AVFormatContext *s, const uint8_t *name, uint16_t name_len,
uint16_t val_len, uint16_t type, AVDictionary **met)
{
int ret;
ff_asf_guid guid;
if (val_len) {
switch (type) {
case ASF_UNICODE:
asf_read_value(s, name, val_len, type, met);
break;
case ASF_BYTE_ARRAY:
if (!strcmp(name, "WM/Picture")) // handle cover art
asf_read_picture(s, val_len);
else if (!strcmp(name, "ID3")) // handle ID3 tag
get_id3_tag(s, val_len);
else
asf_read_value(s, name, val_len, type, met);
break;
case ASF_GUID:
ff_get_guid(s->pb, &guid);
break;
default:
if ((ret = asf_set_metadata(s, name, type, met)) < 0)
return ret;
break;
}
}
return 0;
}
static int asf_read_ext_content(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = avio_rl64(pb);
uint16_t nb_desc = avio_rl16(pb);
int i, ret;
for (i = 0; i < nb_desc; i++) {
uint16_t name_len, type, val_len;
uint8_t *name = NULL;
name_len = avio_rl16(pb);
if (!name_len)
return AVERROR_INVALIDDATA;
name = av_malloc(name_len);
if (!name)
return AVERROR(ENOMEM);
avio_get_str16le(pb, name_len, name,
name_len);
type = avio_rl16(pb);
// BOOL values are 16 bits long in the Metadata Object
// but 32 bits long in the Extended Content Description Object
if (type == ASF_BOOL)
type = ASF_DWORD;
val_len = avio_rl16(pb);
ret = process_metadata(s, name, name_len, val_len, type, &s->metadata);
av_freep(&name);
if (ret < 0)
return ret;
}
align_position(pb, asf->offset, size);
return 0;
}
static AVStream *find_stream(AVFormatContext *s, uint16_t st_num)
{
AVStream *st = NULL;
ASFContext *asf = s->priv_data;
int i;
for (i = 0; i < asf->nb_streams; i++) {
if (asf->asf_st[i]->stream_index == st_num) {
st = s->streams[asf->asf_st[i]->index];
break;
}
}
return st;
}
static int asf_store_aspect_ratio(AVFormatContext *s, uint8_t st_num, uint8_t *name, int type)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t value = 0;
int ret;
ret = asf_read_generic_value(pb, type, &value);
if (ret < 0)
return ret;
if (st_num < ASF_MAX_STREAMS) {
if (!strcmp(name, "AspectRatioX"))
asf->asf_sd[st_num].aspect_ratio.num = value;
else
asf->asf_sd[st_num].aspect_ratio.den = value;
}
return 0;
}
static int asf_read_metadata_obj(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = avio_rl64(pb);
uint16_t nb_recs = avio_rl16(pb); // number of records in the Description Records list
int i, ret;
for (i = 0; i < nb_recs; i++) {
uint16_t name_len, buflen, type, val_len, st_num;
uint8_t *name = NULL;
avio_skip(pb, 2); // skip reserved field
st_num = avio_rl16(pb);
name_len = avio_rl16(pb);
buflen = 2 * name_len + 1;
if (!name_len)
break;
type = avio_rl16(pb);
val_len = avio_rl32(pb);
name = av_malloc(buflen);
if (!name)
return AVERROR(ENOMEM);
avio_get_str16le(pb, name_len, name,
buflen);
if (!strcmp(name, "AspectRatioX") || !strcmp(name, "AspectRatioY")) {
ret = asf_store_aspect_ratio(s, st_num, name, type);
if (ret < 0) {
av_freep(&name);
break;
}
} else {
if (st_num < ASF_MAX_STREAMS) {
if ((ret = process_metadata(s, name, name_len, val_len, type,
&asf->asf_sd[st_num].asf_met)) < 0) {
av_freep(&name);
break;
}
}
}
av_freep(&name);
}
align_position(pb, asf->offset, size);
return 0;
}
static int asf_read_content_desc(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int i;
static const char *const titles[] =
{ "Title", "Author", "Copyright", "Description", "Rate" };
uint16_t len[5], buflen[5] = { 0 };
uint8_t *ch;
uint64_t size = avio_rl64(pb);
for (i = 0; i < 5; i++) {
len[i] = avio_rl16(pb);
// utf8 string should be <= 2 * utf16 string, extra byte for the terminator
buflen[i] = 2 * len[i] + 1;
}
for (i = 0; i < 5; i++) {
ch = av_malloc(buflen[i]);
if (!ch)
return(AVERROR(ENOMEM));
asf_read_metadata(s, titles[i], len[i], ch, buflen[i]);
av_freep(&ch);
}
align_position(pb, asf->offset, size);
return 0;
}
static int asf_read_properties(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
time_t creation_time;
avio_rl64(pb); // read object size
avio_skip(pb, 16); // skip File ID
avio_skip(pb, 8); // skip File size
creation_time = avio_rl64(pb);
if (!(asf->b_flags & ASF_FLAG_BROADCAST)) {
struct tm tmbuf;
struct tm *tm;
char buf[64];
// creation date is in 100 ns units from 1 Jan 1601, conversion to s
creation_time /= 10000000;
// there are 11644473600 seconds between 1 Jan 1601 and 1 Jan 1970
creation_time -= 11644473600;
tm = gmtime_r(&creation_time, &tmbuf);
if (tm) {
if (!strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm))
buf[0] = '\0';
} else
buf[0] = '\0';
if (buf[0]) {
if (av_dict_set(&s->metadata, "creation_time", buf, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
}
}
asf->nb_packets = avio_rl64(pb);
asf->duration = avio_rl64(pb) / 10000; // stream duration
avio_skip(pb, 8); // skip send duration
asf->preroll = avio_rl64(pb);
asf->duration -= asf->preroll;
asf->b_flags = avio_rl32(pb);
avio_skip(pb, 4); // skip minimal packet size
asf->packet_size = avio_rl32(pb);
avio_skip(pb, 4); // skip max_bitrate
return 0;
}
static int parse_video_info(AVIOContext *pb, AVStream *st)
{
uint16_t size;
unsigned int tag;
st->codecpar->width = avio_rl32(pb);
st->codecpar->height = avio_rl32(pb);
avio_skip(pb, 1); // skip reserved flags
size = avio_rl16(pb); // size of the Format Data
tag = ff_get_bmp_header(pb, st, NULL);
st->codecpar->codec_tag = tag;
st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag);
if (size > BMP_HEADER_SIZE) {
int ret;
st->codecpar->extradata_size = size - BMP_HEADER_SIZE;
if (!(st->codecpar->extradata = av_malloc(st->codecpar->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE))) {
st->codecpar->extradata_size = 0;
return AVERROR(ENOMEM);
}
memset(st->codecpar->extradata + st->codecpar->extradata_size , 0,
AV_INPUT_BUFFER_PADDING_SIZE);
if ((ret = avio_read(pb, st->codecpar->extradata,
st->codecpar->extradata_size)) < 0)
return ret;
}
return 0;
}
static int asf_read_stream_properties(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size;
uint32_t err_data_len, ts_data_len; // type specific data length
uint16_t flags;
ff_asf_guid stream_type;
enum AVMediaType type;
int i, ret;
uint8_t stream_index;
AVStream *st;
ASFStream *asf_st;
// ASF file must not contain more than 128 streams according to the specification
if (asf->nb_streams >= ASF_MAX_STREAMS)
return AVERROR_INVALIDDATA;
size = avio_rl64(pb);
ff_get_guid(pb, &stream_type);
if (!ff_guidcmp(&stream_type, &ff_asf_audio_stream))
type = AVMEDIA_TYPE_AUDIO;
else if (!ff_guidcmp(&stream_type, &ff_asf_video_stream))
type = AVMEDIA_TYPE_VIDEO;
else if (!ff_guidcmp(&stream_type, &ff_asf_jfif_media))
type = AVMEDIA_TYPE_VIDEO;
else if (!ff_guidcmp(&stream_type, &ff_asf_command_stream))
type = AVMEDIA_TYPE_DATA;
else if (!ff_guidcmp(&stream_type,
&ff_asf_ext_stream_embed_stream_header))
type = AVMEDIA_TYPE_UNKNOWN;
else
return AVERROR_INVALIDDATA;
ff_get_guid(pb, &stream_type); // error correction type
avio_skip(pb, 8); // skip the time offset
ts_data_len = avio_rl32(pb);
err_data_len = avio_rl32(pb);
flags = avio_rl16(pb); // bit 15 - Encrypted Content
stream_index = flags & ASF_STREAM_NUM;
for (i = 0; i < asf->nb_streams; i++)
if (stream_index == asf->asf_st[i]->stream_index) {
av_log(s, AV_LOG_WARNING,
"Duplicate stream found, this stream will be ignored.\n");
align_position(pb, asf->offset, size);
return 0;
}
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 32, 1, 1000); // pts should be dword, in milliseconds
st->codecpar->codec_type = type;
asf->asf_st[asf->nb_streams] = av_mallocz(sizeof(*asf_st));
if (!asf->asf_st[asf->nb_streams])
return AVERROR(ENOMEM);
asf_st = asf->asf_st[asf->nb_streams];
asf->nb_streams++;
asf_st->stream_index = stream_index;
asf_st->index = st->index;
asf_st->indexed = 0;
st->id = flags & ASF_STREAM_NUM;
av_init_packet(&asf_st->pkt.avpkt);
asf_st->pkt.data_size = 0;
avio_skip(pb, 4); // skip reserved field
switch (type) {
case AVMEDIA_TYPE_AUDIO:
asf_st->type = AVMEDIA_TYPE_AUDIO;
if ((ret = ff_get_wav_header(s, pb, st->codecpar, ts_data_len, 0)) < 0)
return ret;
break;
case AVMEDIA_TYPE_VIDEO:
asf_st->type = AVMEDIA_TYPE_VIDEO;
if ((ret = parse_video_info(pb, st)) < 0)
return ret;
break;
default:
avio_skip(pb, ts_data_len);
break;
}
if (err_data_len) {
if (type == AVMEDIA_TYPE_AUDIO) {
uint8_t span = avio_r8(pb);
if (span > 1) {
asf_st->span = span;
asf_st->virtual_pkt_len = avio_rl16(pb);
asf_st->virtual_chunk_len = avio_rl16(pb);
if (!asf_st->virtual_chunk_len || !asf_st->virtual_pkt_len)
return AVERROR_INVALIDDATA;
avio_skip(pb, err_data_len - 5);
} else
avio_skip(pb, err_data_len - 1);
} else
avio_skip(pb, err_data_len);
}
align_position(pb, asf->offset, size);
return 0;
}
static void set_language(AVFormatContext *s, const char *rfc1766, AVDictionary **met)
{
// language abbr should contain at least 2 chars
if (rfc1766 && strlen(rfc1766) > 1) {
const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
const char *iso6392 = ff_convert_lang_to(primary_tag,
AV_LANG_ISO639_2_BIBL);
if (iso6392)
if (av_dict_set(met, "language", iso6392, 0) < 0)
av_log(s, AV_LOG_WARNING, "av_dict_set failed.\n");
}
}
static int asf_read_ext_stream_properties(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = NULL;
ff_asf_guid guid;
uint16_t nb_st_name, nb_pay_exts, st_num, lang_idx;
int i, ret;
uint32_t bitrate;
uint64_t start_time, end_time, time_per_frame;
uint64_t size = avio_rl64(pb);
start_time = avio_rl64(pb);
end_time = avio_rl64(pb);
bitrate = avio_rl32(pb);
avio_skip(pb, 28); // skip some unused values
st_num = avio_rl16(pb);
st_num &= ASF_STREAM_NUM;
lang_idx = avio_rl16(pb); // Stream Language ID Index
for (i = 0; i < asf->nb_streams; i++) {
if (st_num == asf->asf_st[i]->stream_index) {
st = s->streams[asf->asf_st[i]->index];
asf->asf_st[i]->lang_idx = lang_idx;
break;
}
}
time_per_frame = avio_rl64(pb); // average time per frame
if (st) {
st->start_time = start_time;
st->duration = end_time - start_time;
st->codecpar->bit_rate = bitrate;
st->avg_frame_rate.num = 10000000;
st->avg_frame_rate.den = time_per_frame;
}
nb_st_name = avio_rl16(pb);
nb_pay_exts = avio_rl16(pb);
for (i = 0; i < nb_st_name; i++) {
uint16_t len;
avio_rl16(pb); // Language ID Index
len = avio_rl16(pb);
avio_skip(pb, len);
}
for (i = 0; i < nb_pay_exts; i++) {
uint32_t len;
avio_skip(pb, 16); // Extension System ID
avio_skip(pb, 2); // Extension Data Size
len = avio_rl32(pb);
avio_skip(pb, len);
}
if ((ret = ff_get_guid(pb, &guid)) < 0) {
align_position(pb, asf->offset, size);
return 0;
}
g = find_guid(guid);
if (g && !(strcmp(g->name, "Stream Properties"))) {
if ((ret = g->read_object(s, g)) < 0)
return ret;
}
align_position(pb, asf->offset, size);
return 0;
}
static int asf_read_language_list(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int i, ret;
uint64_t size = avio_rl64(pb);
uint16_t nb_langs = avio_rl16(pb);
if (nb_langs < ASF_MAX_STREAMS) {
for (i = 0; i < nb_langs; i++) {
size_t len;
len = avio_r8(pb);
if (!len)
len = 6;
if ((ret = get_asf_string(pb, len, asf->asf_sd[i].langs,
sizeof(asf->asf_sd[i].langs))) < 0) {
return ret;
}
}
}
align_position(pb, asf->offset, size);
return 0;
}
// returns data object offset when reading this object for the first time
static int asf_read_data(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = asf->data_size = avio_rl64(pb);
int i;
if (!asf->data_reached) {
asf->data_reached = 1;
asf->data_offset = asf->offset;
}
for (i = 0; i < asf->nb_streams; i++) {
if (!(asf->b_flags & ASF_FLAG_BROADCAST))
s->streams[i]->duration = asf->duration;
}
asf->nb_mult_left = 0;
asf->sub_left = 0;
asf->state = PARSE_PACKET_HEADER;
asf->return_subpayload = 0;
asf->packet_size_internal = 0;
avio_skip(pb, 16); // skip File ID
size = avio_rl64(pb); // Total Data Packets
if (size != asf->nb_packets)
av_log(s, AV_LOG_WARNING,
"Number of Packets from File Properties Object is not equal to Total"
"Datapackets value! num of packets %"PRIu64" total num %"PRIu64".\n",
size, asf->nb_packets);
avio_skip(pb, 2); // skip reserved field
asf->first_packet_offset = avio_tell(pb);
if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(asf->b_flags & ASF_FLAG_BROADCAST))
align_position(pb, asf->offset, asf->data_size);
return 0;
}
static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = NULL;
uint64_t interval; // index entry time interval in 100 ns units, usually it's 1s
uint32_t pkt_num, nb_entries;
int32_t prev_pkt_num = -1;
int i, ret;
uint64_t size = avio_rl64(pb);
// simple index objects should be ordered by stream number, this loop tries to find
// the first not indexed video stream
for (i = 0; i < asf->nb_streams; i++) {
if ((asf->asf_st[i]->type == AVMEDIA_TYPE_VIDEO) && !asf->asf_st[i]->indexed) {
asf->asf_st[i]->indexed = 1;
st = s->streams[asf->asf_st[i]->index];
break;
}
}
if (!st) {
avio_skip(pb, size - 24); // if there's no video stream, skip index object
return 0;
}
avio_skip(pb, 16); // skip File ID
interval = avio_rl64(pb);
avio_skip(pb, 4);
nb_entries = avio_rl32(pb);
for (i = 0; i < nb_entries; i++) {
pkt_num = avio_rl32(pb);
ret = avio_skip(pb, 2);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Skipping failed in asf_read_simple_index.\n");
return ret;
}
if (prev_pkt_num != pkt_num) {
av_add_index_entry(st, asf->first_packet_offset + asf->packet_size *
pkt_num, av_rescale(interval, i, 10000),
asf->packet_size, 0, AVINDEX_KEYFRAME);
prev_pkt_num = pkt_num;
}
}
asf->is_simple_index = 1;
align_position(pb, asf->offset, size);
return 0;
}
static const GUIDParseTable gdef[] = {
{ "Data", { 0x75, 0xB2, 0x26, 0x36, 0x66, 0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_data, 1 },
{ "Simple Index", { 0x33, 0x00, 0x08, 0x90, 0xE5, 0xB1, 0x11, 0xCF, 0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB }, asf_read_simple_index, 1 },
{ "Content Description", { 0x75, 0xB2, 0x26, 0x33, 0x66 ,0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_content_desc, 1 },
{ "Extended Content Description", { 0xD2, 0xD0, 0xA4, 0x40, 0xE3, 0x07, 0x11, 0xD2, 0x97, 0xF0, 0x00, 0xA0, 0xC9, 0x5e, 0xA8, 0x50 }, asf_read_ext_content, 1 },
{ "Stream Bitrate Properties", { 0x7B, 0xF8, 0x75, 0xCE, 0x46, 0x8D, 0x11, 0xD1, 0x8D, 0x82, 0x00, 0x60, 0x97, 0xC9, 0xA2, 0xB2 }, asf_read_unknown, 1 },
{ "File Properties", { 0x8C, 0xAB, 0xDC, 0xA1, 0xA9, 0x47, 0x11, 0xCF, 0x8E, 0xE4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_properties, 1 },
{ "Header Extension", { 0x5F, 0xBF, 0x03, 0xB5, 0xA9, 0x2E, 0x11, 0xCF, 0x8E, 0xE3, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_unknown, 0 },
{ "Stream Properties", { 0xB7, 0xDC, 0x07, 0x91, 0xA9, 0xB7, 0x11, 0xCF, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_stream_properties, 1 },
{ "Codec List", { 0x86, 0xD1, 0x52, 0x40, 0x31, 0x1D, 0x11, 0xD0, 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 }, asf_read_unknown, 1 },
{ "Marker", { 0xF4, 0x87, 0xCD, 0x01, 0xA9, 0x51, 0x11, 0xCF, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }, asf_read_marker, 1 },
{ "Script Command", { 0x1E, 0xFB, 0x1A, 0x30, 0x0B, 0x62, 0x11, 0xD0, 0xA3, 0x9B, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 }, asf_read_unknown, 1 },
{ "Language List", { 0x7C, 0x43, 0x46, 0xa9, 0xef, 0xe0, 0x4B, 0xFC, 0xB2, 0x29, 0x39, 0x3e, 0xde, 0x41, 0x5c, 0x85 }, asf_read_language_list, 1},
{ "Padding", { 0x18, 0x06, 0xD4, 0x74, 0xCA, 0xDF, 0x45, 0x09, 0xA4, 0xBA, 0x9A, 0xAB, 0xCB, 0x96, 0xAA, 0xE8 }, asf_read_unknown, 1 },
{ "DRMv1 Header", { 0x22, 0x11, 0xB3, 0xFB, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
{ "DRMv2 Header", { 0x29, 0x8A, 0xE6, 0x14, 0x26, 0x22, 0x4C, 0x17, 0xB9, 0x35, 0xDA, 0xE0, 0x7E, 0xE9, 0x28, 0x9c }, asf_read_unknown, 1 },
{ "Index", { 0xD6, 0xE2, 0x29, 0xD3, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Media Object Index", { 0xFE, 0xB1, 0x03, 0xF8, 0x12, 0xAD, 0x4C, 0x64, 0x84, 0x0F, 0x2A, 0x1D, 0x2F, 0x7A, 0xD4, 0x8C }, asf_read_unknown, 1 },
{ "Timecode Index", { 0x3C, 0xB7, 0x3F, 0xD0, 0x0C, 0x4A, 0x48, 0x03, 0x95, 0x3D, 0xED, 0xF7, 0xB6, 0x22, 0x8F, 0x0C }, asf_read_unknown, 0 },
{ "Bitrate_Mutual_Exclusion", { 0xD6, 0xE2, 0x29, 0xDC, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Error Correction", { 0x75, 0xB2, 0x26, 0x35, 0x66, 0x8E, 0x11, 0xCF, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }, asf_read_unknown, 1 },
{ "Content Branding", { 0x22, 0x11, 0xB3, 0xFA, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
{ "Content Encryption", { 0x22, 0x11, 0xB3, 0xFB, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
{ "Extended Content Encryption", { 0x29, 0x8A, 0xE6, 0x14, 0x26, 0x22, 0x4C, 0x17, 0xB9, 0x35, 0xDA, 0xE0, 0x7E, 0xE9, 0x28, 0x9C }, asf_read_unknown, 1 },
{ "Digital Signature", { 0x22, 0x11, 0xB3, 0xFC, 0xBD, 0x23, 0x11, 0xD2, 0xB4, 0xB7, 0x00, 0xA0, 0xC9, 0x55, 0xFC, 0x6E }, asf_read_unknown, 1 },
{ "Extended Stream Properties", { 0x14, 0xE6, 0xA5, 0xCB, 0xC6, 0x72, 0x43, 0x32, 0x83, 0x99, 0xA9, 0x69, 0x52, 0x06, 0x5B, 0x5A }, asf_read_ext_stream_properties, 1 },
{ "Advanced Mutual Exclusion", { 0xA0, 0x86, 0x49, 0xCF, 0x47, 0x75, 0x46, 0x70, 0x8A, 0x16, 0x6E, 0x35, 0x35, 0x75, 0x66, 0xCD }, asf_read_unknown, 1 },
{ "Group Mutual Exclusion", { 0xD1, 0x46, 0x5A, 0x40, 0x5A, 0x79, 0x43, 0x38, 0xB7, 0x1B, 0xE3, 0x6B, 0x8F, 0xD6, 0xC2, 0x49 }, asf_read_unknown, 1},
{ "Stream Prioritization", { 0xD4, 0xFE, 0xD1, 0x5B, 0x88, 0xD3, 0x45, 0x4F, 0x81, 0xF0, 0xED, 0x5C, 0x45, 0x99, 0x9E, 0x24 }, asf_read_unknown, 1 },
{ "Bandwidth Sharing Object", { 0xA6, 0x96, 0x09, 0xE6, 0x51, 0x7B, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
{ "Metadata", { 0xC5, 0xF8, 0xCB, 0xEA, 0x5B, 0xAF, 0x48, 0x77, 0x84, 0x67, 0xAA, 0x8C, 0x44, 0xFA, 0x4C, 0xCA }, asf_read_metadata_obj, 1 },
{ "Metadata Library", { 0x44, 0x23, 0x1C, 0x94, 0x94, 0x98, 0x49, 0xD1, 0xA1, 0x41, 0x1D, 0x13, 0x4E, 0x45, 0x70, 0x54 }, asf_read_metadata_obj, 1 },
{ "Audio Spread", { 0xBF, 0xC3, 0xCD, 0x50, 0x61, 0x8F, 0x11, 0xCF, 0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20 }, asf_read_unknown, 1 },
{ "Index Parameters", { 0xD6, 0xE2, 0x29, 0xDF, 0x35, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Content Encryption System Windows Media DRM Network Devices",
{ 0x7A, 0x07, 0x9B, 0xB6, 0xDA, 0XA4, 0x4e, 0x12, 0xA5, 0xCA, 0x91, 0xD3, 0x8D, 0xC1, 0x1A, 0x8D }, asf_read_unknown, 1 },
{ "Mutex Language", { 0xD6, 0xE2, 0x2A, 0x00, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Mutex Bitrate", { 0xD6, 0xE2, 0x2A, 0x01, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Mutex Unknown", { 0xD6, 0xE2, 0x2A, 0x02, 0x25, 0xDA, 0x11, 0xD1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE }, asf_read_unknown, 1 },
{ "Bandwidth Sharing Exclusive", { 0xAF, 0x60, 0x60, 0xAA, 0x51, 0x97, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
{ "Bandwidth Sharing Partial", { 0xAF, 0x60, 0x60, 0xAB, 0x51, 0x97, 0x11, 0xD2, 0xB6, 0xAF, 0x00, 0xC0, 0x4F, 0xD9, 0x08, 0xE9 }, asf_read_unknown, 1 },
{ "Payload Extension System Timecode", { 0x39, 0x95, 0x95, 0xEC, 0x86, 0x67, 0x4E, 0x2D, 0x8F, 0xDB, 0x98, 0x81, 0x4C, 0xE7, 0x6C, 0x1E }, asf_read_unknown, 1 },
{ "Payload Extension System File Name", { 0xE1, 0x65, 0xEC, 0x0E, 0x19, 0xED, 0x45, 0xD7, 0xB4, 0xA7, 0x25, 0xCB, 0xD1, 0xE2, 0x8E, 0x9B }, asf_read_unknown, 1 },
{ "Payload Extension System Content Type", { 0xD5, 0x90, 0xDC, 0x20, 0x07, 0xBC, 0x43, 0x6C, 0x9C, 0xF7, 0xF3, 0xBB, 0xFB, 0xF1, 0xA4, 0xDC }, asf_read_unknown, 1 },
{ "Payload Extension System Pixel Aspect Ratio", { 0x1, 0x1E, 0xE5, 0x54, 0xF9, 0xEA, 0x4B, 0xC8, 0x82, 0x1A, 0x37, 0x6B, 0x74, 0xE4, 0xC4, 0xB8 }, asf_read_unknown, 1 },
{ "Payload Extension System Sample Duration", { 0xC6, 0xBD, 0x94, 0x50, 0x86, 0x7F, 0x49, 0x07, 0x83, 0xA3, 0xC7, 0x79, 0x21, 0xB7, 0x33, 0xAD }, asf_read_unknown, 1 },
{ "Payload Extension System Encryption Sample ID", { 0x66, 0x98, 0xB8, 0x4E, 0x0A, 0xFA, 0x43, 0x30, 0xAE, 0xB2, 0x1C, 0x0A, 0x98, 0xD7, 0xA4, 0x4D }, asf_read_unknown, 1 },
{ "Payload Extension System Degradable JPEG", { 0x00, 0xE1, 0xAF, 0x06, 0x7B, 0xEC, 0x11, 0xD1, 0xA5, 0x82, 0x00, 0xC0, 0x4F, 0xC2, 0x9C, 0xFB }, asf_read_unknown, 1 },
};
#define READ_LEN(flag, name, len) \
do { \
if ((flag) == name ## IS_BYTE) \
len = avio_r8(pb); \
else if ((flag) == name ## IS_WORD) \
len = avio_rl16(pb); \
else if ((flag) == name ## IS_DWORD) \
len = avio_rl32(pb); \
else \
len = 0; \
} while(0)
static int asf_read_subpayload(AVFormatContext *s, AVPacket *pkt, int is_header)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint8_t sub_len;
int ret, i;
if (is_header) {
asf->dts_delta = avio_r8(pb);
if (asf->nb_mult_left) {
asf->mult_sub_len = avio_rl16(pb); // total
}
asf->sub_header_offset = avio_tell(pb);
asf->nb_sub = 0;
asf->sub_left = 1;
}
sub_len = avio_r8(pb);
if ((ret = av_get_packet(pb, pkt, sub_len)) < 0) // each subpayload is entire frame
return ret;
for (i = 0; i < asf->nb_streams; i++) {
if (asf->stream_index == asf->asf_st[i]->stream_index) {
pkt->stream_index = asf->asf_st[i]->index;
break;
}
}
asf->return_subpayload = 1;
if (!sub_len)
asf->return_subpayload = 0;
if (sub_len)
asf->nb_sub++;
pkt->dts = asf->sub_dts + (asf->nb_sub - 1) * asf->dts_delta - asf->preroll;
if (asf->nb_mult_left && (avio_tell(pb) >=
(asf->sub_header_offset + asf->mult_sub_len))) {
asf->sub_left = 0;
asf->nb_mult_left--;
}
if (avio_tell(pb) >= asf->packet_offset + asf->packet_size - asf->pad_len) {
asf->sub_left = 0;
if (!asf->nb_mult_left) {
avio_skip(pb, asf->pad_len);
if (avio_tell(pb) != asf->packet_offset + asf->packet_size) {
if (!asf->packet_size)
return AVERROR_INVALIDDATA;
av_log(s, AV_LOG_WARNING,
"Position %"PRId64" wrong, should be %"PRId64"\n",
avio_tell(pb), asf->packet_offset + asf->packet_size);
avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
}
}
}
return 0;
}
static void reset_packet(ASFPacket *asf_pkt)
{
asf_pkt->size_left = 0;
asf_pkt->data_size = 0;
asf_pkt->duration = 0;
asf_pkt->flags = 0;
asf_pkt->dts = 0;
asf_pkt->duration = 0;
av_packet_unref(&asf_pkt->avpkt);
av_init_packet(&asf_pkt->avpkt);
}
static int asf_read_replicated_data(AVFormatContext *s, ASFPacket *asf_pkt)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int ret, data_size;
if (!asf_pkt->data_size) {
data_size = avio_rl32(pb); // read media object size
if (data_size <= 0)
return AVERROR_INVALIDDATA;
if ((ret = av_new_packet(&asf_pkt->avpkt, data_size)) < 0)
return ret;
asf_pkt->data_size = asf_pkt->size_left = data_size;
} else
avio_skip(pb, 4); // reading of media object size is already done
asf_pkt->dts = avio_rl32(pb); // read presentation time
if (asf->rep_data_len && (asf->rep_data_len >= 8))
avio_skip(pb, asf->rep_data_len - 8); // skip replicated data
return 0;
}
static int asf_read_multiple_payload(AVFormatContext *s, AVPacket *pkt,
ASFPacket *asf_pkt)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint16_t pay_len;
unsigned char *p;
int ret;
int skip = 0;
// if replicated length is 1, subpayloads are present
if (asf->rep_data_len == 1) {
asf->sub_left = 1;
asf->state = READ_MULTI_SUB;
pkt->flags = asf_pkt->flags;
if ((ret = asf_read_subpayload(s, pkt, 1)) < 0)
return ret;
} else {
if (asf->rep_data_len)
if ((ret = asf_read_replicated_data(s, asf_pkt)) < 0)
return ret;
pay_len = avio_rl16(pb); // payload length should be WORD
if (pay_len > asf->packet_size) {
av_log(s, AV_LOG_ERROR,
"Error: invalid data packet size, pay_len %"PRIu16", "
"asf->packet_size %"PRIu32", offset %"PRId64".\n",
pay_len, asf->packet_size, avio_tell(pb));
return AVERROR_INVALIDDATA;
}
p = asf_pkt->avpkt.data + asf_pkt->data_size - asf_pkt->size_left;
if (pay_len > asf_pkt->size_left) {
av_log(s, AV_LOG_ERROR,
"Error: invalid buffer size, pay_len %d, data size left %d.\n",
pay_len, asf_pkt->size_left);
skip = pay_len - asf_pkt->size_left;
pay_len = asf_pkt->size_left;
}
if (asf_pkt->size_left <= 0)
return AVERROR_INVALIDDATA;
if ((ret = avio_read(pb, p, pay_len)) < 0)
return ret;
if (s->key && s->keylen == 20)
ff_asfcrypt_dec(s->key, p, ret);
avio_skip(pb, skip);
asf_pkt->size_left -= pay_len;
asf->nb_mult_left--;
}
return 0;
}
static int asf_read_single_payload(AVFormatContext *s, ASFPacket *asf_pkt)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int64_t offset;
uint64_t size;
unsigned char *p;
int ret, data_size;
if (!asf_pkt->data_size) {
data_size = avio_rl32(pb); // read media object size
if (data_size <= 0)
return AVERROR_EOF;
if ((ret = av_new_packet(&asf_pkt->avpkt, data_size)) < 0)
return ret;
asf_pkt->data_size = asf_pkt->size_left = data_size;
} else
avio_skip(pb, 4); // skip media object size
asf_pkt->dts = avio_rl32(pb); // read presentation time
if (asf->rep_data_len >= 8)
avio_skip(pb, asf->rep_data_len - 8); // skip replicated data
offset = avio_tell(pb);
// size of the payload - size of the packet without header and padding
if (asf->packet_size_internal)
size = asf->packet_size_internal - offset + asf->packet_offset - asf->pad_len;
else
size = asf->packet_size - offset + asf->packet_offset - asf->pad_len;
if (size > asf->packet_size) {
av_log(s, AV_LOG_ERROR,
"Error: invalid data packet size, offset %"PRId64".\n",
avio_tell(pb));
return AVERROR_INVALIDDATA;
}
p = asf_pkt->avpkt.data + asf_pkt->data_size - asf_pkt->size_left;
if (size > asf_pkt->size_left || asf_pkt->size_left <= 0)
return AVERROR_INVALIDDATA;
if (asf_pkt->size_left > size)
asf_pkt->size_left -= size;
else
asf_pkt->size_left = 0;
if ((ret = avio_read(pb, p, size)) < 0)
return ret;
if (s->key && s->keylen == 20)
ff_asfcrypt_dec(s->key, p, ret);
if (asf->packet_size_internal)
avio_skip(pb, asf->packet_size - asf->packet_size_internal);
avio_skip(pb, asf->pad_len); // skip padding
return 0;
}
static int asf_read_payload(AVFormatContext *s, AVPacket *pkt)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int ret, i;
ASFPacket *asf_pkt = NULL;
if (!asf->sub_left) {
uint32_t off_len, media_len;
uint8_t stream_num;
stream_num = avio_r8(pb);
asf->stream_index = stream_num & ASF_STREAM_NUM;
for (i = 0; i < asf->nb_streams; i++) {
if (asf->stream_index == asf->asf_st[i]->stream_index) {
asf_pkt = &asf->asf_st[i]->pkt;
asf_pkt->stream_index = asf->asf_st[i]->index;
break;
}
}
if (!asf_pkt) {
if (asf->packet_offset + asf->packet_size <= asf->data_offset + asf->data_size) {
if (!asf->packet_size) {
av_log(s, AV_LOG_ERROR, "Invalid packet size 0.\n");
return AVERROR_INVALIDDATA;
}
avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
av_log(s, AV_LOG_WARNING, "Skipping the stream with the invalid stream index %d.\n",
asf->stream_index);
return AVERROR(EAGAIN);
} else
return AVERROR_INVALIDDATA;
}
if (stream_num >> 7)
asf_pkt->flags |= AV_PKT_FLAG_KEY;
READ_LEN(asf->prop_flags & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE,
ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_, media_len);
READ_LEN(asf->prop_flags & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE,
ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_, off_len);
READ_LEN(asf->prop_flags & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE,
ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_, asf->rep_data_len);
if (asf_pkt->size_left && (asf_pkt->frame_num != media_len)) {
av_log(s, AV_LOG_WARNING, "Unfinished frame will be ignored\n");
reset_packet(asf_pkt);
}
asf_pkt->frame_num = media_len;
asf->sub_dts = off_len;
if (asf->nb_mult_left) {
if ((ret = asf_read_multiple_payload(s, pkt, asf_pkt)) < 0)
return ret;
} else if (asf->rep_data_len == 1) {
asf->sub_left = 1;
asf->state = READ_SINGLE;
pkt->flags = asf_pkt->flags;
if ((ret = asf_read_subpayload(s, pkt, 1)) < 0)
return ret;
} else {
if ((ret = asf_read_single_payload(s, asf_pkt)) < 0)
return ret;
}
} else {
for (i = 0; i <= asf->nb_streams; i++) {
if (asf->stream_index == asf->asf_st[i]->stream_index) {
asf_pkt = &asf->asf_st[i]->pkt;
break;
}
}
if (!asf_pkt)
return AVERROR_INVALIDDATA;
pkt->flags = asf_pkt->flags;
pkt->dts = asf_pkt->dts;
pkt->stream_index = asf->asf_st[i]->index;
if ((ret = asf_read_subpayload(s, pkt, 0)) < 0) // read subpayload without its header
return ret;
}
return 0;
}
static int asf_read_packet_header(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size;
uint32_t av_unused seq;
unsigned char error_flags, len_flags, pay_flags;
asf->packet_offset = avio_tell(pb);
error_flags = avio_r8(pb); // read Error Correction Flags
if (error_flags & ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT) {
if (!(error_flags & ASF_ERROR_CORRECTION_LENGTH_TYPE)) {
size = error_flags & ASF_PACKET_ERROR_CORRECTION_DATA_SIZE;
avio_skip(pb, size);
}
len_flags = avio_r8(pb);
} else
len_flags = error_flags;
asf->prop_flags = avio_r8(pb);
READ_LEN(len_flags & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE,
ASF_PPI_FLAG_PACKET_LENGTH_FIELD_, asf->packet_size_internal);
READ_LEN(len_flags & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE,
ASF_PPI_FLAG_SEQUENCE_FIELD_, seq);
READ_LEN(len_flags & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE,
ASF_PPI_FLAG_PADDING_LENGTH_FIELD_, asf->pad_len );
asf->send_time = avio_rl32(pb); // send time
avio_skip(pb, 2); // skip duration
if (len_flags & ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT) { // Multiple Payloads present
pay_flags = avio_r8(pb);
asf->nb_mult_left = (pay_flags & ASF_NUM_OF_PAYLOADS);
}
return 0;
}
static int asf_deinterleave(AVFormatContext *s, ASFPacket *asf_pkt, int st_num)
{
ASFContext *asf = s->priv_data;
ASFStream *asf_st = asf->asf_st[st_num];
unsigned char *p = asf_pkt->avpkt.data;
uint16_t pkt_len = asf->asf_st[st_num]->virtual_pkt_len;
uint16_t chunk_len = asf->asf_st[st_num]->virtual_chunk_len;
int nchunks = pkt_len / chunk_len;
AVPacket pkt;
int pos = 0, j, l, ret;
if ((ret = av_new_packet(&pkt, asf_pkt->data_size)) < 0)
return ret;
while (asf_pkt->data_size >= asf_st->span * pkt_len + pos) {
if (pos >= asf_pkt->data_size) {
break;
}
for (l = 0; l < pkt_len; l++) {
if (pos >= asf_pkt->data_size) {
break;
}
for (j = 0; j < asf_st->span; j++) {
if ((pos + chunk_len) >= asf_pkt->data_size)
break;
memcpy(pkt.data + pos,
p + (j * nchunks + l) * chunk_len,
chunk_len);
pos += chunk_len;
}
}
p += asf_st->span * pkt_len;
if (p > asf_pkt->avpkt.data + asf_pkt->data_size)
break;
}
av_packet_unref(&asf_pkt->avpkt);
asf_pkt->avpkt = pkt;
return 0;
}
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int ret, i;
if ((avio_tell(pb) >= asf->data_offset + asf->data_size) &&
!(asf->b_flags & ASF_FLAG_BROADCAST))
return AVERROR_EOF;
while (!pb->eof_reached) {
if (asf->state == PARSE_PACKET_HEADER) {
asf_read_packet_header(s);
if (pb->eof_reached)
break;
if (!asf->nb_mult_left)
asf->state = READ_SINGLE;
else
asf->state = READ_MULTI;
}
ret = asf_read_payload(s, pkt);
if (ret == AVERROR(EAGAIN)) {
asf->state = PARSE_PACKET_HEADER;
continue;
}
else if (ret < 0)
return ret;
switch (asf->state) {
case READ_SINGLE:
if (!asf->sub_left)
asf->state = PARSE_PACKET_HEADER;
break;
case READ_MULTI_SUB:
if (!asf->sub_left && !asf->nb_mult_left) {
asf->state = PARSE_PACKET_HEADER;
if (!asf->return_subpayload &&
(avio_tell(pb) <= asf->packet_offset +
asf->packet_size - asf->pad_len))
avio_skip(pb, asf->pad_len); // skip padding
if (asf->packet_offset + asf->packet_size > avio_tell(pb))
avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
} else if (!asf->sub_left)
asf->state = READ_MULTI;
break;
case READ_MULTI:
if (!asf->nb_mult_left) {
asf->state = PARSE_PACKET_HEADER;
if (!asf->return_subpayload &&
(avio_tell(pb) <= asf->packet_offset +
asf->packet_size - asf->pad_len))
avio_skip(pb, asf->pad_len); // skip padding
if (asf->packet_offset + asf->packet_size > avio_tell(pb))
avio_seek(pb, asf->packet_offset + asf->packet_size, SEEK_SET);
}
break;
}
if (asf->return_subpayload) {
asf->return_subpayload = 0;
return 0;
}
for (i = 0; i < s->nb_streams; i++) {
ASFPacket *asf_pkt = &asf->asf_st[i]->pkt;
if (asf_pkt && !asf_pkt->size_left && asf_pkt->data_size) {
if (asf->asf_st[i]->span > 1 &&
asf->asf_st[i]->type == AVMEDIA_TYPE_AUDIO)
if ((ret = asf_deinterleave(s, asf_pkt, i)) < 0)
return ret;
av_packet_move_ref(pkt, &asf_pkt->avpkt);
pkt->stream_index = asf->asf_st[i]->index;
pkt->flags = asf_pkt->flags;
pkt->dts = asf_pkt->dts - asf->preroll;
asf_pkt->data_size = 0;
asf_pkt->frame_num = 0;
return 0;
}
}
}
if (pb->eof_reached)
return AVERROR_EOF;
return 0;
}
static int asf_read_close(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
int i;
for (i = 0; i < ASF_MAX_STREAMS; i++) {
av_dict_free(&asf->asf_sd[i].asf_met);
if (i < asf->nb_streams) {
av_packet_unref(&asf->asf_st[i]->pkt.avpkt);
av_freep(&asf->asf_st[i]);
}
}
asf->nb_streams = 0;
return 0;
}
static void reset_packet_state(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
int i;
asf->state = PARSE_PACKET_HEADER;
asf->offset = 0;
asf->return_subpayload = 0;
asf->sub_left = 0;
asf->sub_header_offset = 0;
asf->packet_offset = asf->first_packet_offset;
asf->pad_len = 0;
asf->rep_data_len = 0;
asf->dts_delta = 0;
asf->mult_sub_len = 0;
asf->nb_mult_left = 0;
asf->nb_sub = 0;
asf->prop_flags = 0;
asf->sub_dts = 0;
for (i = 0; i < asf->nb_streams; i++) {
ASFPacket *pkt = &asf->asf_st[i]->pkt;
pkt->size_left = 0;
pkt->data_size = 0;
pkt->duration = 0;
pkt->flags = 0;
pkt->dts = 0;
pkt->duration = 0;
av_packet_unref(&pkt->avpkt);
av_init_packet(&pkt->avpkt);
}
}
/*
* Find a timestamp for the requested position within the payload
* where the pos (position) is the offset inside the Data Object.
* When position is not on the packet boundary, asf_read_timestamp tries
* to find the closest packet offset after this position. If this packet
* is a key frame, this packet timestamp is read and an index entry is created
* for the packet. If this packet belongs to the requested stream,
* asf_read_timestamp upgrades pos to the packet beginning offset and
* returns this packet's dts. So returned dts is the dts of the first key frame with
* matching stream number after given position.
*/
static int64_t asf_read_timestamp(AVFormatContext *s, int stream_index,
int64_t *pos, int64_t pos_limit)
{
ASFContext *asf = s->priv_data;
int64_t pkt_pos = *pos, pkt_offset, dts = AV_NOPTS_VALUE, data_end;
AVPacket pkt;
int n;
data_end = asf->data_offset + asf->data_size;
n = (pkt_pos - asf->first_packet_offset + asf->packet_size - 1) /
asf->packet_size;
n = av_clip(n, 0, ((data_end - asf->first_packet_offset) / asf->packet_size - 1));
pkt_pos = asf->first_packet_offset + n * asf->packet_size;
avio_seek(s->pb, pkt_pos, SEEK_SET);
pkt_offset = pkt_pos;
reset_packet_state(s);
while (avio_tell(s->pb) < data_end) {
int i, ret, st_found;
av_init_packet(&pkt);
pkt_offset = avio_tell(s->pb);
if ((ret = asf_read_packet(s, &pkt)) < 0) {
dts = AV_NOPTS_VALUE;
return ret;
}
// ASFPacket may contain fragments of packets belonging to different streams,
// pkt_offset is the offset of the first fragment within it.
if ((pkt_offset >= (pkt_pos + asf->packet_size)))
pkt_pos += asf->packet_size;
for (i = 0; i < asf->nb_streams; i++) {
ASFStream *st = asf->asf_st[i];
st_found = 0;
if (pkt.flags & AV_PKT_FLAG_KEY) {
dts = pkt.dts;
if (dts) {
av_add_index_entry(s->streams[pkt.stream_index], pkt_pos,
dts, pkt.size, 0, AVINDEX_KEYFRAME);
if (stream_index == st->index) {
st_found = 1;
break;
}
}
}
}
if (st_found)
break;
av_packet_unref(&pkt);
}
*pos = pkt_pos;
av_packet_unref(&pkt);
return dts;
}
static int asf_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
ASFContext *asf = s->priv_data;
int idx, ret;
if (s->streams[stream_index]->nb_index_entries && asf->is_simple_index) {
idx = av_index_search_timestamp(s->streams[stream_index], timestamp, flags);
if (idx < 0 || idx >= s->streams[stream_index]->nb_index_entries)
return AVERROR_INVALIDDATA;
avio_seek(s->pb, s->streams[stream_index]->index_entries[idx].pos, SEEK_SET);
} else {
if ((ret = ff_seek_frame_binary(s, stream_index, timestamp, flags)) < 0)
return ret;
}
reset_packet_state(s);
return 0;
}
static const GUIDParseTable *find_guid(ff_asf_guid guid)
{
int j, ret;
const GUIDParseTable *g;
swap_guid(guid);
g = gdef;
for (j = 0; j < FF_ARRAY_ELEMS(gdef); j++) {
if (!(ret = memcmp(guid, g->guid, sizeof(g->guid))))
return g;
g++;
}
return NULL;
}
static int detect_unknown_subobject(AVFormatContext *s, int64_t offset, int64_t size)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
const GUIDParseTable *g = NULL;
ff_asf_guid guid;
int ret;
while (avio_tell(pb) <= offset + size) {
if (avio_tell(pb) == asf->offset)
break;
asf->offset = avio_tell(pb);
if ((ret = ff_get_guid(pb, &guid)) < 0)
return ret;
g = find_guid(guid);
if (g) {
if ((ret = g->read_object(s, g)) < 0)
return ret;
} else {
GUIDParseTable g2;
g2.name = "Unknown";
g2.is_subobject = 1;
asf_read_unknown(s, &g2);
}
}
return 0;
}
static int asf_read_header(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
const GUIDParseTable *g = NULL;
ff_asf_guid guid;
int i, ret;
uint64_t size;
asf->preroll = 0;
asf->is_simple_index = 0;
ff_get_guid(pb, &guid);
if (ff_guidcmp(&guid, &ff_asf_header))
return AVERROR_INVALIDDATA;
avio_skip(pb, 8); // skip header object size
avio_skip(pb, 6); // skip number of header objects and 2 reserved bytes
asf->data_reached = 0;
/* 1 is here instead of pb->eof_reached because (when not streaming), Data are skipped
* for the first time,
* Index object is processed and got eof and then seeking back to the Data is performed.
*/
while (1) {
// for the cases when object size is invalid
if (avio_tell(pb) == asf->offset)
break;
asf->offset = avio_tell(pb);
if ((ret = ff_get_guid(pb, &guid)) < 0) {
if (ret == AVERROR_EOF && asf->data_reached)
break;
else
goto failed;
}
g = find_guid(guid);
if (g) {
asf->unknown_offset = asf->offset;
asf->is_header = 1;
if ((ret = g->read_object(s, g)) < 0)
goto failed;
} else {
size = avio_rl64(pb);
align_position(pb, asf->offset, size);
}
if (asf->data_reached &&
(!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
(asf->b_flags & ASF_FLAG_BROADCAST)))
break;
}
if (!asf->data_reached) {
av_log(s, AV_LOG_ERROR, "Data Object was not found.\n");
ret = AVERROR_INVALIDDATA;
goto failed;
}
if (pb->seekable & AVIO_SEEKABLE_NORMAL)
avio_seek(pb, asf->first_packet_offset, SEEK_SET);
for (i = 0; i < asf->nb_streams; i++) {
const char *rfc1766 = asf->asf_sd[asf->asf_st[i]->lang_idx].langs;
AVStream *st = s->streams[asf->asf_st[i]->index];
set_language(s, rfc1766, &st->metadata);
}
for (i = 0; i < ASF_MAX_STREAMS; i++) {
AVStream *st = NULL;
st = find_stream(s, i);
if (st) {
av_dict_copy(&st->metadata, asf->asf_sd[i].asf_met, AV_DICT_IGNORE_SUFFIX);
if (asf->asf_sd[i].aspect_ratio.num > 0 && asf->asf_sd[i].aspect_ratio.den > 0) {
st->sample_aspect_ratio.num = asf->asf_sd[i].aspect_ratio.num;
st->sample_aspect_ratio.den = asf->asf_sd[i].aspect_ratio.den;
}
}
}
return 0;
failed:
asf_read_close(s);
return ret;
}
AVInputFormat ff_asf_o_demuxer = {
.name = "asf_o",
.long_name = NULL_IF_CONFIG_SMALL("ASF (Advanced / Active Streaming Format)"),
.priv_data_size = sizeof(ASFContext),
.read_probe = asf_probe,
.read_header = asf_read_header,
.read_packet = asf_read_packet,
.read_close = asf_read_close,
.read_timestamp = asf_read_timestamp,
.read_seek = asf_read_seek,
.flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
};
|
/* Copyright (c) 2020 vesoft inc. All rights reserved.
*
* This source code is licensed under Apache 2.0 License.
*/
#pragma once
#include <folly/Benchmark.h>
#include <folly/Format.h>
#include <folly/container/Enumerate.h>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <chrono>
#include "clients/storage/GraphStorageClient.h"
#include "clients/storage/InternalStorageClient.h"
#include "codec/RowWriterV2.h"
#include "common/base/Base.h"
#include "common/expression/ConstantExpression.h"
#include "common/meta/SchemaManager.h"
#include "common/utils/NebulaKeyUtils.h"
#include "kvstore/LogEncoder.h"
#include "storage/transaction/TransactionUtils.h"
namespace nebula {
namespace storage {
struct TossTestUtils {
static std::vector<nebula::Value> genSingleVal(int n) {
boost::uuids::random_generator gen;
std::vector<nebula::Value> ret(2);
ret[0].setInt(n);
ret[1].setStr(boost::uuids::to_string(gen()));
return ret;
}
static std::vector<std::vector<nebula::Value>> genValues(size_t num) {
boost::uuids::random_generator gen;
std::vector<std::vector<nebula::Value>> ret(num);
for (auto i = 0U; i != num; ++i) {
ret[i].resize(2);
int32_t n = 1024 * (1 + i);
ret[i][0].setInt(n);
ret[i][1].setStr(boost::uuids::to_string(gen()));
}
return ret;
}
static std::string dumpDataSet(const DataSet& ds) {
std::stringstream oss;
for (auto&& it : folly::enumerate(ds.colNames)) {
oss << "\ncolNames[" << it.index << "]=" << *it;
}
oss << "\n";
oss << dumpRows(ds.rows);
return oss.str();
}
static std::string concatValues(const std::vector<nebula::Value>& vals) {
if (vals.empty()) {
return "";
}
std::ostringstream oss;
for (auto& val : vals) {
oss << val << ',';
}
std::string ret = oss.str();
return ret.substr(0, ret.size() - 1);
}
static std::string dumpValues(const std::vector<Value>& vals) {
std::stringstream oss;
oss << "vals.size() = " << vals.size() << "\n";
for (auto& val : vals) {
oss << val.toString() << "\n";
}
return oss.str();
}
static std::string dumpRows(const std::vector<Row>& rows) {
std::stringstream oss;
oss << "rows.size() = " << rows.size() << "\n";
for (auto& row : rows) {
oss << "row.size()=" << row.size() << "\n";
oss << row.toString() << "\n";
}
return oss.str();
}
static std::string hexVid(int64_t vid) {
std::string str(reinterpret_cast<char*>(&vid), sizeof(int64_t));
return folly::hexlify(str);
}
static std::string hexEdgeId(const cpp2::EdgeKey& ek) {
return hexVid(ek.get_src().getInt()) + hexVid(ek.get_dst().getInt());
}
static std::vector<std::string> splitNeiResults(std::vector<std::string>& svec) {
std::vector<std::string> ret;
for (auto& str : svec) {
auto sub = splitNeiResult(str);
ret.insert(ret.end(), sub.begin(), sub.end());
}
return ret;
}
static bool compareSize(const std::vector<std::string>& svec, size_t expect) {
auto equalSize = svec.size() == expect;
if (!equalSize) {
LOG(INFO) << "compareSize failed: expect=" << expect;
print_svec(svec);
}
return equalSize;
}
static std::vector<std::string> splitNeiResult(folly::StringPiece str) {
std::vector<std::string> ret;
auto begin = str.begin();
auto end = str.end();
if (str.startsWith("[[")) {
begin++;
begin++;
}
if (str.endsWith("]]")) {
end--;
end--;
}
str.assign(begin, end);
folly::split("],[", str, ret);
if (ret.size() == 1U && ret.back() == "__EMPTY__") {
ret.clear();
}
return ret;
}
static void print_svec(const std::vector<std::string>& svec) {
LOG(INFO) << "svec.size()=" << svec.size();
for (auto& str : svec) {
LOG(INFO) << str;
}
}
static cpp2::NewEdge toVertexIdEdge(const cpp2::NewEdge& e) {
cpp2::NewEdge ret(e);
(*ret.key_ref())
.set_src(std::string(reinterpret_cast<const char*>(&e.get_key().get_src().getInt()), 8));
(*ret.key_ref())
.set_dst(std::string(reinterpret_cast<const char*>(&e.get_key().get_dst().getInt()), 8));
return ret;
}
static cpp2::EdgeKey makeEdgeKeyS(const cpp2::EdgeKey& input) {
if (input.src.type() == Value::Type::STRING) {
return input;
}
cpp2::EdgeKey ret(input);
ret.set_src(std::string(reinterpret_cast<const char*>(&input.get_src().getInt()), 8));
ret.set_dst(std::string(reinterpret_cast<const char*>(&input.get_dst().getInt()), 8));
return ret;
}
static std::vector<nebula::Value> makeISValue(int64_t iVal) {
boost::uuids::random_generator gen;
std::vector<nebula::Value> vals(2);
vals[0].setInt(iVal);
vals[1].setStr(boost::uuids::to_string(gen()));
return vals;
}
// generate a vector of values, 1st is ant i64, 2nd is a random string.
static std::vector<std::vector<nebula::Value>> genISValues(size_t num) {
std::vector<std::vector<nebula::Value>> ret;
for (auto i = 0U; i != num; ++i) {
int32_t n = 1024 * (1 + i);
ret.emplace_back(makeISValue(n));
}
return ret;
}
// generate num different edges with same dst
// the first src is dst + 1, and increase 1 for each
static std::vector<cpp2::NewEdge> makeNeighborEdges(int64_t dst, int edgeType, size_t num) {
auto values = genISValues(num);
std::vector<cpp2::NewEdge> edges;
auto rank = 0;
for (auto i = 0U; i < num; ++i) {
auto src = dst + i + 1;
auto ekey = makeEdgeKeyI(src, edgeType, rank, dst);
edges.emplace_back();
edges.back().set_key(std::move(ekey));
edges.back().set_props(std::move(values[i]));
}
return edges;
}
static cpp2::NewEdge makeEdge(int64_t src, int edgeType) {
cpp2::NewEdge edge;
edge.set_key(makeEdgeKeyI(src, edgeType, 0, src + 1));
edge.set_props(makeISValue(1024));
return edge;
}
static cpp2::NewEdge makeEdgeS(int64_t src, int edgeType) {
cpp2::NewEdge edge = makeEdge(src, edgeType);
edge.key = makeEdgeKeyS(edge.key);
return edge;
}
static cpp2::NewEdge makeTwinEdge(const cpp2::NewEdge& oldEdge) {
cpp2::NewEdge newEdge(oldEdge);
auto newVal = makeISValue(newEdge.props[0].getInt() + 1024);
newEdge.set_props(newVal);
return newEdge;
}
static std::vector<std::string> makeColNames(size_t n) {
std::vector<std::string> colNames;
for (auto i = 0U; i < n; ++i) {
colNames.emplace_back(folly::sformat("c{}", i + 1));
}
return colNames;
}
static std::vector<meta::cpp2::ColumnDef> makeColDefs(
const std::vector<nebula::cpp2::PropertyType>& types) {
auto N = types.size();
auto colNames = makeColNames(N);
std::vector<meta::cpp2::ColumnDef> columnDefs(N);
for (auto i = 0U; i != N; ++i) {
columnDefs[i].set_name(colNames[i]);
meta::cpp2::ColumnTypeDef colTypeDef;
colTypeDef.set_type(types[i]);
columnDefs[i].set_type(colTypeDef);
columnDefs[i].set_nullable(true);
}
return columnDefs;
}
}; // end TossTestUtils
} // namespace storage
} // namespace nebula
|
#include <stdio.h>
#include <stdlib.h>
#include <cs50.h>
#include <stdint.h>
//defining the type byte
typedef uint8_t BYTE;
//defining the size of the block
#define block 512
//defining the size of the file name
#define filenamesize 8
bool is_start_of_jpeg(BYTE buffer[]);
int main(int argc, char *argv[])
{
//if it has no command-line argument
if (argc != 2)
{
printf("Missing command-line argument!\n");
return 1;
}
FILE *inside_file = fopen(argv[1], "r");
//if there is no file
if (inside_file == NULL)
{
printf("Missing file!\n");
return 1;
}
BYTE buffer[block];
bool found_first_jpeg = false;
int number_of_files = 0;
FILE *jpeg;
//reading the file and restoring the jpegs
while (fread(buffer, block, 1, inside_file))
{
//starts or close a jpeg file
if (is_start_of_jpeg(buffer))
{
if (!found_first_jpeg)
{
found_first_jpeg = true;
}
else
{
fclose(jpeg);
}
char filename[filenamesize];
sprintf(filename, "%03i.jpg", number_of_files++);
jpeg = fopen(filename, "w");
if (jpeg == NULL)
{
return 1;
}
fwrite(buffer, block, 1, jpeg);
}
//keeps writing in the same jpeg file
else if (found_first_jpeg)
{
fwrite(buffer, block, 1, jpeg);
}
}
fclose(jpeg);
fclose(inside_file);
}
//check if it is the beggining of a jpeg
bool is_start_of_jpeg(BYTE buffer[])
{
return buffer[0] == 0xff && buffer[1] == 0xd8 && buffer[2] == 0xff && (buffer[3] & 0xf0) == 0xe0;
}
|
/*
* This header is generated by classdump-dyld 1.5
* on Wednesday, April 14, 2021 at 2:38:54 PM Mountain Standard Time
* Operating System: Version 14.4 (Build 18K802)
* Image Source: /System/Library/PrivateFrameworks/WorkflowKit.framework/WorkflowKit
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <WorkflowKit/WorkflowKit-Structs.h>
#import <libobjc.A.dylib/NSCopying.h>
#import <libobjc.A.dylib/WFParameterState.h>
@protocol WFParameterState;
@class NSString;
@interface WFPropertyListParameterValue : NSObject <NSCopying, WFParameterState> {
long long _valueType;
id<WFParameterState> _state;
}
@property (nonatomic,readonly) long long valueType; //@synthesize valueType=_valueType - In the implementation block
@property (nonatomic,readonly) id<WFParameterState> state; //@synthesize state=_state - In the implementation block
@property (readonly) unsigned long long hash;
@property (readonly) Class superclass;
@property (copy,readonly) NSString * description;
@property (copy,readonly) NSString * debugDescription;
+(Class)classForValueType:(long long)arg1 ;
+(id)defaultStateForValueType:(long long)arg1 ;
+(Class)processedClassForValueType:(long long)arg1 ;
+(id)localizedTitleForValueType:(long long)arg1 ;
-(BOOL)isEqual:(id)arg1 ;
-(unsigned long long)hash;
-(id)copyWithZone:(NSZone*)arg1 ;
-(id)initWithArray:(id)arg1 ;
-(id)initWithObject:(id)arg1 ;
-(id)initWithString:(id)arg1 ;
-(id)initWithDictionary:(id)arg1 ;
-(id<WFParameterState>)state;
-(id)serializedRepresentation;
-(long long)valueType;
-(id)initWithNumber:(id)arg1 ;
-(void)processWithContext:(id)arg1 userInputRequiredHandler:(/*^block*/id)arg2 valueHandler:(/*^block*/id)arg3 ;
-(id)containedVariables;
-(id)initWithSerializedRepresentation:(id)arg1 variableProvider:(id)arg2 parameter:(id)arg3 ;
-(id)initWithType:(long long)arg1 state:(id)arg2 ;
-(id)initWithStringState:(id)arg1 ;
-(id)initWithDictionaryState:(id)arg1 ;
-(id)initWithArrayState:(id)arg1 ;
-(id)initWithNumberState:(id)arg1 ;
-(id)initWithBooleanState:(id)arg1 ;
-(id)initWithBoolean:(id)arg1 ;
@end
|
#import "OSPlatform.h"
NS_ASSUME_NONNULL_BEGIN
@interface OSImage (QRCode)
+ (OSImage *_Nullable )QRImageWithString:(NSString *)dataString
withSize:(CGSize)requestedSize;
- (NSString *)QRCodeString;
+ (void) QRImageWithString:(NSString*) dataString
scaledSize:(CGSize)requestedSize
completionQueue:(dispatch_queue_t _Nullable)completionQueue
completionBlock:(void (^)(OSImage * _Nullable image))completionBlock;
@end
NS_ASSUME_NONNULL_END
|
// Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
// Copyright (c) 2018-2019, The Qwertycoin developers
//
// This file is part of Qwertycoin.
//
// Qwertycoin is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Qwertycoin 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Qwertycoin. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <atomic>
#include <functional>
#include <map>
#include <string>
#include <thread>
#include <vector>
#include "BlockingQueue.h"
#include "ConsoleTools.h"
#ifndef _WIN32
#include <sys/select.h>
#endif
namespace Common {
class AsyncConsoleReader {
public:
AsyncConsoleReader();
~AsyncConsoleReader();
void start();
bool getline(std::string& line);
void stop();
bool stopped() const;
void pause();
void unpause();
private:
void consoleThread();
bool waitInput();
std::atomic<bool> m_stop;
std::thread m_thread;
BlockingQueue<std::string> m_queue;
};
class ConsoleHandler {
public:
~ConsoleHandler();
typedef std::function<bool(const std::vector<std::string> &)> ConsoleCommandHandler;
std::string getUsage() const;
void setHandler(const std::string& command, const ConsoleCommandHandler& handler, const std::string& usage = "");
void requestStop();
bool runCommand(const std::vector<std::string>& cmdAndArgs);
void start(bool startThread = true, const std::string& prompt = "", Console::Color promptColor = Console::Color::Default);
void stop();
void wait();
void pause();
void unpause();
private:
typedef std::map<std::string, std::pair<ConsoleCommandHandler, std::string>> CommandHandlersMap;
virtual void handleCommand(const std::string& cmd);
void handlerThread();
std::thread m_thread;
std::string m_prompt;
Console::Color m_promptColor = Console::Color::Default;
CommandHandlersMap m_handlers;
AsyncConsoleReader m_consoleReader;
};
}
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 17