hexsha stringlengths 40 40 | size int64 5 1.05M | ext stringclasses 588 values | lang stringclasses 305 values | max_stars_repo_path stringlengths 3 363 | max_stars_repo_name stringlengths 5 118 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:00:35 2022-03-31 23:43:49 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 12:37:38 2022-03-31 23:59:52 ⌀ | max_issues_repo_path stringlengths 3 363 | max_issues_repo_name stringlengths 5 118 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 363 | max_forks_repo_name stringlengths 5 135 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:02 2022-03-31 23:27:27 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 08:55:07 2022-03-31 23:59:24 ⌀ | content stringlengths 5 1.05M | avg_line_length float64 1.13 1.04M | max_line_length int64 1 1.05M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
a94d0adbdf37923ce95bdeeb990870a1a3aba75c | 20,131 | h | C | ChatKit/Class/Tool/LCCKServiceDefinition.h | YunzhanghuOpen/leanChat-yunzhanghu | dfbdc4ef0fff754405f71c5c80f6af90bedd781c | [
"MIT"
] | 1 | 2017-09-10T02:06:27.000Z | 2017-09-10T02:06:27.000Z | ChatKit/Class/Tool/LCCKServiceDefinition.h | YunzhanghuOpen/leanChat-yunzhanghu | dfbdc4ef0fff754405f71c5c80f6af90bedd781c | [
"MIT"
] | 11 | 2017-09-10T04:31:52.000Z | 2017-09-14T13:52:38.000Z | ChatKit/Class/Tool/LCCKServiceDefinition.h | YunzhanghuOpen/leanChat-yunzhanghu | dfbdc4ef0fff754405f71c5c80f6af90bedd781c | [
"MIT"
] | 2 | 2018-06-13T10:27:48.000Z | 2018-12-22T06:15:22.000Z | //
// LCCKServiceDefinition.h
// LeanCloudChatKit-iOS
//
// v0.8.5 Created by ElonChan on 16/2/22.
// Copyright © 2016年 LeanCloud. All rights reserved.
// All the Typedefine for all kinds of services.
#import <AVOSCloudIM/AVOSCloudIM.h>
#import "LCCKConstants.h"
#import "LCCKSingleton.h"
#import "LCCKMenuItem.h"
@class AVIMClient;
@class AVIMConversation;
@class AVIMSignature;
@class LCCKConversationViewController;
@class LCCKConversationListViewController;
@class LCCKMessage;
#pragma mark - LCCKSessionService
///=============================================================================
/// @name LCCKSessionService
///=============================================================================
@protocol LCCKSessionService <NSObject>
typedef void (^LCCKReconnectSessionCompletionHandler)(BOOL succeeded, NSError *error);
/*!
* @param granted granted fore single signOn
* 默认允许重连，error的code为4111时，需要额外请求权限，才可标记为YES。
*/
typedef void (^LCCKForceReconnectSessionBlock)(NSError *error, BOOL granted, __kindof UIViewController *viewController, LCCKReconnectSessionCompletionHandler completionHandler);
@property (nonatomic, copy, readonly) NSString *clientId;
@property (nonatomic, strong, readonly) AVIMClient *client;
@property (nonatomic, assign) BOOL disableSingleSignOn;
@property (nonatomic, copy) LCCKForceReconnectSessionBlock forceReconnectSessionBlock;
/*!
* @param clientId You can use the user id in your user system as clientId, ChatKit will get the current user's information by both this id and the method `-[LCCKChatService getProfilesForUserIds:callback:]`.
* @param callback Callback
*/
- (void)openWithClientId:(NSString *)clientId callback:(LCCKBooleanResultBlock)callback;
/*!
* @param force Just for Single Sign On
*/
- (void)openWithClientId:(NSString *)clientId force:(BOOL)force callback:(AVIMBooleanResultBlock)callback;
/*!
* @brief Close the client
* @param callback Callback
*/
- (void)closeWithCallback:(LCCKBooleanResultBlock)callback;
/*!
* set how you want to force reconnect session. It is usually usefully for losing session because of single sign-on, or weak network.
*/
- (void)setForceReconnectSessionBlock:(LCCKForceReconnectSessionBlock)forceReconnectSessionBlock;
@end
#pragma mark - LCCKUserSystemService
///=============================================================================
/// @name LCCKUserSystemService
///=============================================================================
@protocol LCCKUserSystemService <NSObject>
/*!
* @brief The block to execute with the users' information for the userIds. Always execute this block at some point when fetching profiles completes on main thread. Specify users' information how you want ChatKit to show.
* @attention If you fetch users fails, you should reture nil, meanwhile, give the error reason.
*/
typedef void(^LCCKFetchProfilesCompletionHandler)(NSArray<id<LCCKUserDelegate>> *users, NSError *error);
/*!
* @brief When LeanCloudChatKit wants to fetch profiles, this block will be invoked.
* @param userIds User ids
* @param completionHandler The block to execute with the users' information for the userIds. Always execute this block at some point during your implementation of this method on main thread. Specify users' information how you want ChatKit to show.
*/
typedef void(^LCCKFetchProfilesBlock)(NSArray<NSString *> *userIds, LCCKFetchProfilesCompletionHandler completionHandler);
@property (nonatomic, copy) LCCKFetchProfilesBlock fetchProfilesBlock;
/*!
* @brief Add the ablitity to fetch profiles.
* @attention You must get peer information by peer id with a synchronous implementation.
* If implemeted, this block will be invoked automatically by LeanCloudChatKit for fetching peer profile.
*/
- (void)setFetchProfilesBlock:(LCCKFetchProfilesBlock)fetchProfilesBlock;
/*!
* Remove all cached profiles.
*/
- (void)removeAllCachedProfiles;
/**
* remove person profile cache
*
* @param person id
*/
- (void)removeCachedProfileForPeerId:(NSString *)peerId;
- (void)getCachedProfileIfExists:(NSString *)userId name:(NSString **)name avatarURL:(NSURL **)avatarURL error:(NSError * __autoreleasing *)error;
- (NSArray<id<LCCKUserDelegate>> *)getCachedProfilesIfExists:(NSArray<NSString *> *)userIds error:(NSError * __autoreleasing *)error;
/*!
* 如果从缓存查询到的userids数量不相符，则返回nil
*/
- (NSArray<id<LCCKUserDelegate>> *)getCachedProfilesIfExists:(NSArray<NSString *> *)userIds shouldSameCount:(BOOL)shouldSameCount error:(NSError * __autoreleasing *)theError;
- (void)getProfileInBackgroundForUserId:(NSString *)userId callback:(LCCKUserResultCallBack)callback;
- (void)getProfilesInBackgroundForUserIds:(NSArray<NSString *> *)userIds callback:(LCCKUserResultsCallBack)callback;
- (NSArray<id<LCCKUserDelegate>> *)getProfilesForUserIds:(NSArray<NSString *> *)userIds error:(NSError * __autoreleasing *)error;
@end
#pragma mark - LCCKSignatureService
///=============================================================================
/// @name LCCKSignatureService
///=============================================================================
@protocol LCCKSignatureService <NSObject>
/*!
* @brief The block to execute with the signature information for session. Always execute this block at some point when fetching signature information completes on main thread. Specify signature information how you want ChatKit pin to these actions: open, start(create conversation), kick, invite.
* @attention If you fetch AVIMSignature fails, you should reture nil, meanwhile, give the error reason.
*/
typedef void(^LCCKGenerateSignatureCompletionHandler)(AVIMSignature *signature, NSError *error);
/*!
* @brief If implemeted, this block will be invoked automatically for pinning signature to these actions: open, start(create conversation), kick, invite.
* @param clientId - Id of operation initiator
* @param conversationId － Id of target conversation
* @param action － Kinds of action:
"open": log in an account
"start": create a conversation
"add": invite myself or others to the conversation
"remove": kick someone out the conversation
* @param clientIds － Target id list for the action
* @param completionHandler The block to execute with the signature information for session. Always execute this block at some point during your implementation of this method on main thread. Specify signature information how you want ChatKit pin to these actions: open, start(create conversation), kick, invite.
*/
typedef void(^LCCKGenerateSignatureBlock)(NSString *clientId, NSString *conversationId, NSString *action, NSArray *clientIds, LCCKGenerateSignatureCompletionHandler completionHandler);
@property (nonatomic, copy) LCCKGenerateSignatureBlock generateSignatureBlock;
/*!
* @brief Add the ablitity to pin signature to these actions: open, start(create conversation), kick, invite.
* @attention If implemeted, this block will be invoked automatically for pinning signature to these actions: open, start(create conversation), kick, invite.
*/
- (void)setGenerateSignatureBlock:(LCCKGenerateSignatureBlock)generateSignatureBlock;
@end
#pragma mark - LCCKUIService
///=============================================================================
/// @name LCCKUIService
///=============================================================================
#import "LCCKServiceDefinition.h"
@protocol LCCKUIService <NSObject>
/// 传递触发的UIViewController对象
#define LCCKPreviewImageMessageUserInfoKeyFromController @"LCCKPreviewImageMessageUserInfoKeyFromController"
/// 传递触发的UIView对象
#define LCCKPreviewImageMessageUserInfoKeyFromView @"LCCKPreviewImageMessageUserInfoKeyFromView"
/// 传递触发的UIView对象
#define LCCKPreviewImageMessageUserInfoKeyFromPlaceholderView @"LCCKPreviewImageMessageUserInfoKeyFromPlaceholderView"
/*!
* 打开某个profile的回调block
* @param userId 被点击的user 的 userId (clientId) ，与 user 属性中 clientId 的区别在于，本属性永远不为空，但 user可能为空。
* @param parentController 用于打开的顶层控制器
*/
typedef void(^LCCKOpenProfileBlock)(NSString *userId, id<LCCKUserDelegate> user, __kindof UIViewController *parentController);
@property (nonatomic, copy) LCCKOpenProfileBlock openProfileBlock;
/*!
* 打开某个profile的回调block
* @param userId 某个userId
* @param parentController 用于打开的顶层控制器
*/
- (void)setOpenProfileBlock:(LCCKOpenProfileBlock)openProfileBlock;
/*!
* 当ChatKit需要预览图片消息时，会调用这个block
* @param index 用户点击的图片消息在imageMessages中的下标
* @param allVisibleImages 元素可能是图片，也可能是NSURL，以及混合。
* @param userInfo 用来传递上下文信息，例如，从某个Controller触发，或者从某个view触发等，键值在下面定义
*/
typedef void(^LCCKPreviewImageMessageBlock)(NSUInteger index, NSArray *allVisibleImages, NSArray *allVisibleThumbs, NSDictionary *userInfo);
@property (nonatomic, copy) LCCKPreviewImageMessageBlock previewImageMessageBlock;
/// 传递触发的UIViewController对象
#define LCCKPreviewImageMessageUserInfoKeyFromController @"LCCKPreviewImageMessageUserInfoKeyFromController"
/// 传递触发的UIView对象
#define LCCKPreviewImageMessageUserInfoKeyFromView @"LCCKPreviewImageMessageUserInfoKeyFromView"
/// 传递触发的UIView对象
#define LCCKPreviewImageMessageUserInfoKeyFromPlaceholderView @"LCCKPreviewImageMessageUserInfoKeyFromPlaceholderView"
/*!
* 当ChatKit需要预览图片消息时，会调用这个block.
* 使用NSDictionary传递上下文信息，便于扩展
*/
- (void)setPreviewImageMessageBlock:(LCCKPreviewImageMessageBlock)previewImageMessageBlock;
/*!
* 当ChatKit需要预览地理位置消息时，会调用这个block
* @param location 地理位置坐标
* @param geolocations 地理位置的文字描述
* @param userInfo 用来传递上下文信息，例如，从某个Controller触发，或者从某个view触发等，键值在下面定义
*/
typedef void(^LCCKPreviewLocationMessageBlock)(CLLocation *location, NSString *geolocations, NSDictionary *userInfo);
@property (nonatomic, copy) LCCKPreviewLocationMessageBlock previewLocationMessageBlock;
/// 传递触发的UIViewController对象
#define LCCKPreviewLocationMessageUserInfoKeyFromController @"LCCKPreviewLocationMessageUserInfoKeyFromController"
/// 传递触发的UIView对象
#define LCCKPreviewLocationMessageUserInfoKeyFromView @"LCCKPreviewLocationMessageUserInfoKeyFromView"
/*!
* 当ChatKit需要预览地理位置消息时，会调用这个block.
* 使用NSDictionary传递上下文信息，便于扩展
*/
- (void)setPreviewLocationMessageBlock:(LCCKPreviewLocationMessageBlock)previewLocationMessageBlock;
//TODO:可自定义长按能响应的消息类型
/*!
* ChatKit会在长按消息时，调用这个block
* @param message 被长按的消息
* @param userInfo 用来传递上下文信息，例如，从某个Controller触发，或者从某个view触发等，键值在下面定义
*/
typedef NSArray<LCCKMenuItem *> *(^LCCKLongPressMessageBlock)(LCCKMessage *message, NSDictionary *userInfo);
@property (nonatomic, copy) LCCKLongPressMessageBlock longPressMessageBlock;
/// 传递触发的UIViewController对象
#define LCCKLongPressMessageUserInfoKeyFromController @"LCCKLongPressMessageUserInfoKeyFromController"
/// 传递触发的UIView对象
#define LCCKLongPressMessageUserInfoKeyFromView @"LCCKLongPressMessageUserInfoKeyFromView"
/*!
* ChatKit会在长按消息时，调用这个block
* 使用NSDictionary传递上下文信息，便于扩展
*/
- (void)setLongPressMessageBlock:(LCCKLongPressMessageBlock)longPressMessageBlock;
/**
* 当ChatKit需要显示通知时，会调用这个block。
* 开发者需要实现并设置这个block，以便给用户提示。
* @param viewController 当前的controller
* @param title 标题
* @param subtitle 子标题
* @param type 类型
*/
typedef void(^LCCKShowNotificationBlock)(__kindof UIViewController *viewController, NSString *title, NSString *subtitle, LCCKMessageNotificationType type);
@property (nonatomic, copy) LCCKShowNotificationBlock showNotificationBlock;
/**
* 当ChatKit需要显示通知时，会调用这个block。
* 开发者需要实现并设置这个block，以便给用户提示。
* @param viewController 当前的controller
* @param title 标题
* @param subtitle 子标题
* @param type 类型
*/
- (void)setShowNotificationBlock:(LCCKShowNotificationBlock)showNotificationBlock;
/**
* 当ChatKit需要显示通知时，会调用这个block。
* 开发者需要实现并设置这个block，以便给用户提示。
* @param viewController 当前的controller
* @param title 标题
* @param type 类型
*/
typedef void(^LCCKHUDActionBlock)(__kindof UIViewController *viewController, UIView *view, NSString *title, LCCKMessageHUDActionType type);
@property (nonatomic, copy) LCCKHUDActionBlock HUDActionBlock;
/**
* 当ChatKit需要显示通知时，会调用这个block。
* 开发者需要实现并设置这个block，以便给用户提示。
* @param viewController 当前的controller
* @param title 标题
* @param subtitle 子标题
* @param type 类型
*/
- (void)setHUDActionBlock:(LCCKHUDActionBlock)HUDActionBlock;
typedef CGFloat (^LCCKAvatarImageViewCornerRadiusBlock)(CGSize avatarImageViewSize);
@property (nonatomic, copy) LCCKAvatarImageViewCornerRadiusBlock avatarImageViewCornerRadiusBlock;
/*!
* 设置对话列表和聊天界面头像ImageView的圆角弧度
* 注意，请在需要圆角矩形时设置，对话列表和聊天界面头像默认圆形。
*/
- (void)setAvatarImageViewCornerRadiusBlock:(LCCKAvatarImageViewCornerRadiusBlock)avatarImageViewCornerRadiusBlock;
@end
#pragma mark - LCCKSettingService
///=============================================================================
/// @name LCCKSettingService
///=============================================================================
@protocol LCCKSettingService <NSObject>
/*!
* You should always use like this, never forgive to cancel log before publishing.
```
#ifndef __OPTIMIZE__
[[LCChatKit sharedInstance] setAllLogsEnabled:YES];
#endif
```
*/
+ (void)setAllLogsEnabled:(BOOL)enabled;
+ (BOOL)allLogsEnabled;
+ (NSString *)ChatKitVersion;
- (void)syncBadge;
/*!
* 禁止预览id
* 如果不设置，或者设置为NO，在群聊需要显示最后一条消息的发送者时，会在网络请求用户昵称成功前，先显示id，然后，成功后再显示昵称。
*/
@property (nonatomic, assign, getter=isDisablePreviewUserId) BOOL disablePreviewUserId;
/*!
* 是否使用开发证书去推送，默认为 NO。如果设为 YES 的话每条消息会带上这个参数，云代码利用 Hook 设置证书
* 参考 https://github.com/leancloud/leanchat-cloudcode/blob/master/cloud/mchat.js
*/
@property (nonatomic, assign) BOOL useDevPushCerticate;
- (void)setBackgroundImage:(UIImage *)image forConversationId:(NSString *)conversationId scaledToSize:(CGSize)scaledToSize;
@end
#pragma mark - LCCKConversationService
///=============================================================================
/// @name LCCKConversationService
///=============================================================================
typedef void (^LCCKConversationResultBlock)(AVIMConversation *conversation, NSError *error);
typedef void (^LCCKFetchConversationHandler) (AVIMConversation *conversation, LCCKConversationViewController *conversationController);
typedef void (^LCCKConversationInvalidedHandler) (NSString *conversationId, LCCKConversationViewController *conversationController, id<LCCKUserDelegate> administrator, NSError *error);
@protocol LCCKConversationService <NSObject>
@property (nonatomic, copy) LCCKFetchConversationHandler fetchConversationHandler;
/*!
* 设置获取 AVIMConversation 对象结束后的 Handler。 这里可以做异常处理，比如获取失败等操作。
* 获取失败时，LCCKConversationHandler 返回值中的AVIMConversation 为 nil，成功时为正确的 conversation 值。
*/
- (void)setFetchConversationHandler:(LCCKFetchConversationHandler)fetchConversationHandler;
@property (nonatomic, copy) LCCKConversationInvalidedHandler conversationInvalidedHandler;
/*!
* 会话失效的处理 block，如当群被解散或当前用户不再属于该会话时，对应会话会失效应当被删除并且关闭聊天窗口
*/
- (void)setConversationInvalidedHandler:(LCCKConversationInvalidedHandler)conversationInvalidedHandler;
typedef void (^LCCKFilterMessagesCompletionHandler)(NSArray *filteredMessages, NSError *error);
typedef void (^LCCKFilterMessagesBlock)(AVIMConversation *conversation, NSArray<AVIMTypedMessage *> *messages, LCCKFilterMessagesCompletionHandler completionHandler);
/*!
* 用于筛选消息，比如：群定向消息、筛选黑名单消息、黑名单消息
* @attention 同步方法异步方法皆可
*/
- (void)setFilterMessagesBlock:(LCCKFilterMessagesBlock)filterMessagesBlock;
@property (nonatomic, copy) LCCKFilterMessagesBlock filterMessagesBlock;
/*!
* @param granted 该消息允许被发送
* @param error 消息为何不允许被发送
*/
typedef void (^LCCKSendMessageHookCompletionHandler)(BOOL granted, NSError *error);
typedef void (^LCCKSendMessageHookBlock)(LCCKConversationViewController *conversationController, AVIMTypedMessage __kindof *message, LCCKSendMessageHookCompletionHandler completionHandler);
/*!
* 用于HOOK掉发送消息的行为，可以实现比如：禁止黑名单用户发消息、禁止发送包含敏感词掉消息
* @attention 同步方法异步方法皆可
*/
- (void)setSendMessageHookBlock:(LCCKSendMessageHookBlock)sendMessageHookBlock;
@property (nonatomic, copy) LCCKSendMessageHookBlock sendMessageHookBlock;
//TODO:未实现
typedef void (^LCCKLoadLatestMessagesHandler)(LCCKConversationViewController *conversationController, BOOL succeeded, NSError *error);
@property (nonatomic, copy) LCCKLoadLatestMessagesHandler loadLatestMessagesHandler;
/*!
* 设置获取历史纪录结束时的 Handler。 这里可以做异常处理，比如获取失败等操作。
* 获取失败时，LCCKViewControllerBooleanResultBlock 返回值中的 error 不为 nil，包含错误原因，成功时 succeeded 值为 YES。
*/
- (void)setLoadLatestMessagesHandler:(LCCKLoadLatestMessagesHandler)loadLatestMessagesHandler;
- (void)createConversationWithMembers:(NSArray *)members type:(LCCKConversationType)type unique:(BOOL)unique callback:(AVIMConversationResultBlock)callback;
- (void)didReceiveRemoteNotification:(NSDictionary *)userInfo;
/**
* 插入一条最近对话
* @param conversation
*/
- (void)insertRecentConversation:(AVIMConversation *)conversation;
/**
* 增加未读数
* @param conversation 相应对话
*/
- (void)increaseUnreadCountWithConversationId:(NSString *)conversationId;
/**
* 最近对话列表左滑删除本地数据库的对话，将不显示在列表
* @param conversation
*/
- (void)deleteRecentConversationWithConversationId:(NSString *)conversationId;
/**
* 清空未读数
* @param conversation 相应的对话
*/
- (void)updateUnreadCountToZeroWithConversationId:(NSString *)conversationId;
/**
* 删除全部缓存，比如当切换用户时，如果同一个人显示的名称和头像需要变更
*/
- (BOOL)removeAllCachedRecentConversations;
- (void)sendWelcomeMessageToPeerId:(NSString *)peerId text:(NSString *)text block:(LCCKBooleanResultBlock)block;
- (void)sendWelcomeMessageToConversationId:(NSString *)conversationId text:(NSString *)text block:(LCCKBooleanResultBlock)block;
@end
#pragma mark - LCCKConversationsListService
///=============================================================================
/// @name LCCKConversationsListService
///=============================================================================
@protocol LCCKConversationsListService <NSObject>
/*!
* 选中某个对话后的回调
* @param conversation 被选中的对话
*/
typedef void(^LCCKDidSelectConversationsListCellBlock)(NSIndexPath *indexPath, AVIMConversation *conversation, LCCKConversationListViewController *controller);
/*!
* 选中某个对话后的回调
*/
@property (nonatomic, copy) LCCKDidSelectConversationsListCellBlock didSelectConversationsListCellBlock;
/*!
* 设置选中某个对话后的回调
*/
- (void)setDidSelectConversationsListCellBlock:(LCCKDidSelectConversationsListCellBlock)didSelectConversationsListCellBlock;
/*!
* 删除某个对话后的回调
* @param conversation 被选中的对话
*/
typedef void(^LCCKDidDeleteConversationsListCellBlock)(NSIndexPath *indexPath, AVIMConversation *conversation, LCCKConversationListViewController *controller);
/*!
* 删除某个对话后的回调
*/
@property (nonatomic, copy) LCCKDidDeleteConversationsListCellBlock didDeleteConversationsListCellBlock;
/*!
* 设置删除某个对话后的回调
*/
- (void)setDidDeleteConversationsListCellBlock:(LCCKDidDeleteConversationsListCellBlock)didDeleteConversationsListCellBlock;
/*!
* 对话左滑菜单设置block
* @return 需要显示的菜单数组
* @param conversation, 对话
* @param editActions, 默认的菜单数组，成员为 UITableViewRowAction 类型
*/
typedef NSArray *(^LCCKConversationEditActionsBlock)(NSIndexPath *indexPath, NSArray<UITableViewRowAction *> *editActions, AVIMConversation *conversation, LCCKConversationListViewController *controller);
/*!
* 可以通过这个block设置对话列表中每个对话的左滑菜单，这个是同步调用的，需要尽快返回，否则会卡住UI
*/
@property (nonatomic, copy) LCCKConversationEditActionsBlock conversationEditActionBlock;
/*!
* 设置对话列表中每个对话的左滑菜单，这个是同步调用的，需要尽快返回，否则会卡住UI
*/
- (void)setConversationEditActionBlock:(LCCKConversationEditActionsBlock)conversationEditActionBlock;
typedef void(^LCCKMarkBadgeWithTotalUnreadCountBlock)(NSInteger totalUnreadCount, __kindof UIViewController *controller);
@property (nonatomic, copy) LCCKMarkBadgeWithTotalUnreadCountBlock markBadgeWithTotalUnreadCountBlock;
/*!
* 如果不是TabBar样式，请实现该Blcok。如果不实现，默认会把 App 当作是 TabBar 样式，修改 navigationController 的 tabBarItem 的 badgeValue 数字显示，数字超出99显示省略号。
*/
- (void)setMarkBadgeWithTotalUnreadCountBlock:(LCCKMarkBadgeWithTotalUnreadCountBlock)markBadgeWithTotalUnreadCountBlock;
@end
//TODO:CacheService;
| 39.08932 | 312 | 0.756396 |
45cbf1a9a9ceebfb6195dd3326db763e629eadab | 6,604 | c | C | wobj.c | qMSUZ/uRenderer | bbd40daca045916855c5719e2981d7b3265dcef8 | [
"MIT"
] | 1 | 2021-04-12T15:55:44.000Z | 2021-04-12T15:55:44.000Z | wobj.c | qMSUZ/uRenderer | bbd40daca045916855c5719e2981d7b3265dcef8 | [
"MIT"
] | null | null | null | wobj.c | qMSUZ/uRenderer | bbd40daca045916855c5719e2981d7b3265dcef8 | [
"MIT"
] | null | null | null | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "wobj.h"
twobj wobj_create_zero()
{
twobj t;
t.verts = 0;
t.faces = 0;
t.norms = 0;
t.uv = 0;
t.verts_ = NULL;
t.faces_ = NULL;
t.norms_ = NULL;
t.uv_ = NULL;
t.diffusemap_ = NULL;
t.normalmap_ = NULL;
t.specularmap_ = NULL;
return t;
}
void wobj_scan_file(char *fname, int *vs, int *fs, int *ns, int *us)
{
FILE *f = NULL;
char line[1024];
float x,y,z;
int v=0, n=0, fc=0, u=0;
int f1,f2,f3,f4,f5,f6,f7,f8, f9;
f = fopen(fname,"r");
if(f == NULL)
{
fprintf(stderr, "ERROR: Can't open file [%s] to scan.\n", fname);
return;
}
while( fgets(&line[0], 1024, f) != NULL)
{
//printf("%s", &line[0]);
if(strncmp(&line[0], "v ", 2) == 0)
{
sscanf(&line[2], "%f %f %f", &x, &y, &z);
//printf("[%4d] v %f %f %f\n", v, x, y, z);
v++;
}
if(strncmp(&line[0], "vn ", 3) == 0)
{
sscanf(&line[3], "%f %f %f", &x, &y, &z);
//printf("[%4d] vn %f %f %f\n", n, x, y, z);
n++;
}
if(strncmp(&line[0], "vt ", 3) == 0)
{
sscanf(&line[3], "%f %f %f", &x, &y, &z);
//printf("[%4d] vt %f %f %f\n", u, x, y, z);
u++;
}
if(strncmp(&line[0], "f ", 2) == 0)
{
//printf("[%4d] f ", fc);
f1=0; f2=0; f3=0; f4=0; f5=0; f6=0; f7=0; f8=0; f9=0;
//sscanf(&line[2], "%d//%d %d//%d %d//%d %d//%d", &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8);
//printf(" %d/%d %d/%d %d/%d %d/%d", f1, f2, f3, f4, f5, f6, f7, f8);
sscanf(&line[2], "%d/%d/%d %d/%d/%d %d/%d/%d", &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9);
//printf(" %d/%d/%d %d/%d/%d %d/%d/%d", f1, f2, f3, f4, f5, f6, f7, f8, f9);
//printf("\n");
fc++;
}
line[0]=0;
}
*vs = v;
*ns = n;
*fs = fc;
*us = u;
fclose(f);
}
twobj wobj_load_from_file(char *fname, int vs, int fs, int ns, int us)
{
FILE *f = NULL;
char line[1024];
float x,y,z;
int i, v=0, n=0, fc=0, u=0;
int f1, f2, f3, f4, f5, f6, f7, f8, f9;
twobj t, tzero;
t = wobj_create_zero();
tzero = wobj_create_zero();
f = fopen(fname, "r");
if(f == NULL)
{
fprintf(stderr, "ERROR: Can't open file [%s] to load.\n", fname);
return tzero;
}
memset(&line[0], 0, sizeof(line));
t.verts = vs;
t.faces = fs;
t.norms = ns;
t.uv = us;
t.verts_ = (tvec3d*)malloc( sizeof(tvec3d) * vs );
t.norms_ = (tvec3d*)malloc( sizeof(tvec3d) * ns );
t.uv_ = (tvec3d*)malloc( sizeof(tvec3d) * us );
t.faces_ = (tivec3d**)malloc( sizeof(tivec3d) * fs );
for(i=0;i<fs;i++)
{
t.faces_[i] = (tivec3d*)malloc( sizeof(tivec3d) * 3 );
}
while( fgets(&line[0], 1024, f) != NULL)
{
//printf("%s", &line[0]);
if(strncmp(&line[0], "v ", 2) == 0)
{
sscanf(&line[2], "%f %f %f", &x, &y, &z);
t.verts_[v].x = x;
t.verts_[v].y = y;
t.verts_[v].z = z;
v++;
}
if(strncmp(&line[0], "vn ", 3) == 0)
{
sscanf(&line[3], "%f %f %f", &x, &y, &z);
t.norms_[n].x = x;
t.norms_[n].y = y;
t.norms_[n].z = z;
n++;
}
if(strncmp(&line[0], "vt ", 3) == 0)
{
sscanf(&line[3], "%f %f %f", &x, &y, &z);
t.uv_[u].x = x;
t.uv_[u].y = y;
t.uv_[u].z = z;
u++;
}
if(strncmp(&line[0], "f ", 2) == 0)
{
f1=0; f2=0; f3=0; f4=0; f5=0; f6=0; f7=0; f8=0; f9=0;
sscanf(&line[2], "%d/%d/%d %d/%d/%d %d/%d/%d", &f1, &f2, &f3, &f4, &f5, &f6, &f7, &f8, &f9);
t.faces_[fc][0].x=f1 - 1;
t.faces_[fc][0].y=f2 - 1;
t.faces_[fc][0].z=f3 - 1;
t.faces_[fc][1].x=f4 - 1;
t.faces_[fc][1].y=f5 - 1;
t.faces_[fc][1].z=f6 - 1;
t.faces_[fc][2].x=f7 - 1;
t.faces_[fc][2].y=f8 - 1;
t.faces_[fc][2].z=f9 - 1;
fc++;
}
line[0]=0;
}
fclose(f);
return t;
}
int wobj_nverts(twobj *t)
{
return t->verts;
}
int wobj_nfaces(twobj *t)
{
return t->faces;
}
tvec3d wobj_normal(twobj *t, int iface, int nthvert)
{
tvec3d ret;
int idx = t->faces_[iface][nthvert].z;
ret = normalize_vec3d( t->norms_[idx] );
return ret;
}
/*
tvec3d wobj_normal_for_uv(twobj *t, tvec2d uv)
{
tvec3d ret;
//Vec2i uv(uvf[0]*normalmap_.get_width(), uvf[1]*normalmap_.get_height());
//TGAColor c = normalmap_.get(uv[0], uv[1]);
//Vec3f res;
//for (int i=0; i<3; i++)
// res[2-i] = (float)c[i]/255.f*2.f - 1.f;
//return res;
return ret;
}
*/
tvec3d wobj_vert(twobj *t, int i)
{
tvec3d ret;
ret = t->verts_[i];
return ret;
}
/*
tvec3d wobj_vert_nth(twobj *t, int iface, int nthvert)
{
tvec3d ret;
return ret;
}
*/
tivec2d wobj_uv(twobj *t, int iface, int nthvert)
{
tivec2d ret;
int idx = t->faces_[iface][nthvert].y;
ret.x = t->uv_[idx].x * tgaimage_get_width (t->diffusemap_);
ret.y = t->uv_[idx].y * tgaimage_get_height(t->diffusemap_);
return ret;
}
tgacolor wobj_diffuse(twobj *t, tivec2d uv)
{
tgacolor ret;
ret = tgaimage_get_color(t->diffusemap_, uv.x, uv.y);
return ret;
// return diffusemap_.get(uv.x, uv.y);
}
float wobj_specular(twobj *t, tivec2d uv)
{
return 0.0f;
}
tivec3d* wobj_face(twobj *t, int idx)
{
tivec3d* f = NULL;
f = t->faces_[idx];
return f;
}
void dump_wobj(twobj *t)
{
int i, j;
tvec3d v;
tivec3d *f;
printf("dump data");
printf("verts = %d\n",t->verts);
printf("faces = %d\n", t->faces);
printf("norms = %d\n", t->norms);
printf("uv; = %d\n", t->uv);
printf("\nverts dump\n");
for (i = 0; i < t->verts; i++)
{
v = wobj_vert(t, i);
printf("v %f %f %f\n", v.x, v.y, v.z);
}
printf("\nfaces/triangles dump\n");
for (i = 0; i < t->faces; i++)
{
f = wobj_face(t, i);
printf("f ");
for (j = 0; j < 3; j++)
{
printf("%d/%d/%d ",f[j].x+1, f[j].y+1, f[j].z+1);
}
printf("\n");
}
}
void destroy_wobj(twobj *t)
{
int i;
if( t->faces_ != NULL )
{
for( i=0; i<t->faces; i++ )
{
if(t->faces_[i] != NULL)
{
free(t->faces_[i]);
t->faces_[i] = NULL;
}
}
free( t->faces_ );
}
if ( t->verts_ != NULL )
free( t->verts_ );
if( t->norms_ != NULL )
free( t->norms_ );
if( t->uv_ != NULL )
free( t->uv_ );
if(t->diffusemap_ != NULL )
destroy_tgaimage( t->diffusemap_ );
if( t->normalmap_ != NULL )
destroy_tgaimage( t->normalmap_ );
if( t->specularmap_ != NULL )
destroy_tgaimage( t->specularmap_ );
}
| 17.848649 | 96 | 0.479255 |
04c756c4784c296f3ef56397831877ae09002bd8 | 529 | h | C | Main/lib/Memory/Remote/Function/RemoteFunctionExecuter.h | Y3t1y3t/CSGO-Extern | 854b11e749924124e1bba9020569e18e5812d4a9 | [
"MIT"
] | 17 | 2017-01-29T16:56:46.000Z | 2021-07-28T01:59:45.000Z | Main/lib/Memory/Remote/Function/RemoteFunctionExecuter.h | Y3t1y3t/CSGO-Extern | 854b11e749924124e1bba9020569e18e5812d4a9 | [
"MIT"
] | 3 | 2017-02-06T15:31:39.000Z | 2017-02-09T08:34:17.000Z | Main/lib/Memory/Remote/Function/RemoteFunctionExecuter.h | Y3t1y3t/CSGO-Extern | 854b11e749924124e1bba9020569e18e5812d4a9 | [
"MIT"
] | 4 | 2017-02-04T06:37:08.000Z | 2018-04-21T08:44:38.000Z | #ifndef _MEMORY_REMOTEFUNCTIONEXECUTER_H_
#define _MEMORY_REMOTEFUNCTIONEXECUTER_H_
#pragma once
#include "RemoteFunction.h"
namespace Memory
{
class RemoteFunctionExecuter
{
SharedRemoteProcessService _remoteProcessService;
public:
explicit RemoteFunctionExecuter( SharedRemoteProcessService remoteProcessService );
~RemoteFunctionExecuter() = default;
bool Execute( const std::unique_ptr<RemoteFunction>& data ) const;
};
}
#endif /* _MEMORY_REMOTEFUNCTIONEXECUTER_H_ */
| 22.041667 | 91 | 0.756144 |
a645dbbf9013ea887c66d7d08e7a76fdf77ec61e | 1,429 | h | C | source/numeric/Time.h | gitter-badger/slang | 08c98649c4f6562394e23cd86c0585508807d929 | [
"MIT"
] | null | null | null | source/numeric/Time.h | gitter-badger/slang | 08c98649c4f6562394e23cd86c0585508807d929 | [
"MIT"
] | null | null | null | source/numeric/Time.h | gitter-badger/slang | 08c98649c4f6562394e23cd86c0585508807d929 | [
"MIT"
] | null | null | null | //------------------------------------------------------------------------------
// Time.h
// Contains various time-related utilities and functions.
//
// File is under the MIT license; see LICENSE for details
//------------------------------------------------------------------------------
#pragma once
#include "util/Util.h"
namespace slang {
/// Scale unit for a time value.
enum class TimeUnit : uint8_t {
Seconds,
Milliseconds,
Microseconds,
Nanoseconds,
Picoseconds,
Femtoseconds
};
bool suffixToTimeUnit(string_view timeSuffix, TimeUnit& unit);
string_view timeUnitToSuffix(TimeUnit unit);
/// As allowed by SystemVerilog, time scales can be expressed
/// in one of only a few magnitudes.
enum class TimescaleMagnitude : uint8_t {
One = 1,
Ten = 10,
Hundred = 100
};
/// A combination of a unit and magnitude for a timescale value.
struct TimescaleValue {
TimeUnit unit;
TimescaleMagnitude magnitude;
TimescaleValue() = default;
TimescaleValue(TimeUnit unit, TimescaleMagnitude magnitude) :
unit(unit), magnitude(magnitude) {}
};
/// A collection of a base time and a precision value that
/// determines the scale of simulation time steps.
struct Timescale {
TimescaleValue base;
TimescaleValue precision;
Timescale() = default;
Timescale(TimescaleValue base, TimescaleValue precision) :
base(base), precision(precision) {}
};
} | 25.981818 | 80 | 0.63261 |
2eb3e483a0ab3275835e79fb4efef3c96cba2471 | 9,573 | c | C | BootloaderCorePkg/Library/MemoryAllocationLib/MemoryAllocationLib.c | smnarayanan/slimbootloader | 9f146afd47e0ca204521826a583d55388850b216 | [
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | 299 | 2018-09-13T23:17:25.000Z | 2022-03-19T14:25:54.000Z | BootloaderCorePkg/Library/MemoryAllocationLib/MemoryAllocationLib.c | smnarayanan/slimbootloader | 9f146afd47e0ca204521826a583d55388850b216 | [
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | 494 | 2018-09-18T19:31:55.000Z | 2022-03-30T16:52:52.000Z | BootloaderCorePkg/Library/MemoryAllocationLib/MemoryAllocationLib.c | smnarayanan/slimbootloader | 9f146afd47e0ca204521826a583d55388850b216 | [
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | 142 | 2018-09-13T23:43:17.000Z | 2022-03-25T03:40:13.000Z | /** @file
Support routines for memory allocation routines
based on PeiService for PEI phase drivers.
Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <PiPei.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/BootloaderCoreLib.h>
#define POOL_MIN_ALIGNMENT 0x10
/**
Update the Memory pool top address.
@param [in] Top Top address to update.
**/
VOID
InternalUpdateMemPoolTop (
IN UINT32 Top
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
LdrGlobal = GetLoaderGlobalDataPointer();
ASSERT (Top >= LdrGlobal->MemPoolCurrBottom);
LdrGlobal->MemPoolCurrTop = Top;
}
/**
Update the Memory pool bottom address.
@param [in] Bottom bottom address to update.
**/
VOID
InternalUpdateMemPoolBottom (
IN UINT32 Bottom
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
LdrGlobal = GetLoaderGlobalDataPointer();
ASSERT (LdrGlobal->MemPoolCurrTop >= Bottom);
LdrGlobal->MemPoolCurrBottom = Bottom;
}
/**
Allocates a buffer of type EfiBootServicesData.
Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
pointer to the allocated buffer. If AllocationSize is 0, LdrGlobal->MemPoolCurrTop is returned.
If there is not enough memory remaining to satisfy the request, InternalUpdateMemPoolTop ASSERTS
and the function does not return.
@param AllocationSize The number of bytes to allocate.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocatePool (
IN UINTN AllocationSize
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
UINT32 Top;
LdrGlobal = GetLoaderGlobalDataPointer();
Top = LdrGlobal->MemPoolCurrTop;
Top -= (UINT32)AllocationSize;
Top = ALIGN_DOWN (Top, POOL_MIN_ALIGNMENT);
InternalUpdateMemPoolTop (Top);
return (VOID *)(UINTN)Top;
}
/**
Allocates and zeros a buffer of type EfiBootServicesData.
Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
buffer with zeros, and returns a pointer to the allocated buffer. If AllocationSize is 0,
LdrGlobal->MemPoolCurrTop is returned. If there is not enough memory remaining to satisfy the
request, InternalUpdateMemPoolTop ASSERTS and the function does not return.
@param AllocationSize The number of bytes to allocate and zero.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocateZeroPool (
IN UINTN AllocationSize
)
{
VOID *Memory;
Memory = AllocatePool (AllocationSize);
if (Memory != NULL) {
Memory = ZeroMem (Memory, AllocationSize);
}
return Memory;
}
/**
Allocates one or more 4KB pages of type EfiBootServicesData.
Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the
allocated buffer. The buffer returned is aligned on a 4KB boundary. If Pages is 0, then
NULL is returned. If there is not enough memory remaining to satisfy the request,
InternalUpdateMemPoolTop ASSERTS and the function does not return.
@param Pages The number of 4 KB pages to allocate.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocatePages (
IN UINTN Pages
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
UINT32 Top;
if (Pages == 0) {
return NULL;
}
LdrGlobal = GetLoaderGlobalDataPointer();
Top = LdrGlobal->MemPoolCurrTop;
Top = ALIGN_DOWN (Top, EFI_PAGE_SIZE);
Top -= (UINT32)(Pages * EFI_PAGE_SIZE);
InternalUpdateMemPoolTop (Top);
return (VOID *)(UINTN)Top;
}
/**
Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
alignment specified by Alignment. The allocated buffer is returned. If Pages is 0, then
NULL is returned. If there is not enough memory remaining to satisfy the request,
InternalUpdateMemPoolTop ASSERTS and the function does not return.
If Alignment is not a power of two and Alignment is not zero, then ASSERT().
If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
@param Pages The number of 4 KB pages to allocate.
@param Alignment The requested alignment of the allocation. Must be a power of two.
If Alignment is zero, then byte alignment is used.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocateAlignedPages (
IN UINTN Pages,
IN UINTN Alignment
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
UINT32 Top;
if (Pages == 0) {
return NULL;
}
LdrGlobal = GetLoaderGlobalDataPointer();
Top = LdrGlobal->MemPoolCurrTop;
Top = ALIGN_DOWN (Top, EFI_PAGE_SIZE);
Top -= (UINT32)(Pages * EFI_PAGE_SIZE);
if (Alignment > EFI_PAGE_SIZE) {
Top = ALIGN_DOWN (Top, Alignment);
}
Top = ALIGN_DOWN (Top, EFI_PAGE_SIZE);
InternalUpdateMemPoolTop (Top);
return (VOID *)(UINTN)Top;
}
/**
This function allocates temporary memory pool.
@param[in] AllocationSize The memory pool size to allocate. If AllocationSize is 0,
LdrGlobal->MemPoolCurrBottom is returned. If there is not enough memory remaining to satisfy the
request, InternalUpdateMemPoolBottom ASSERTS and the function does not return.
@retval A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocateTemporaryMemory (
IN UINTN AllocationSize
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
UINT32 Bottom;
UINT32 NewBottom;
LdrGlobal = GetLoaderGlobalDataPointer();
Bottom = LdrGlobal->MemPoolCurrBottom;
Bottom = ALIGN_UP (Bottom, POOL_MIN_ALIGNMENT);
NewBottom = Bottom + (UINT32)AllocationSize;
InternalUpdateMemPoolBottom (NewBottom);
return (VOID *)(UINTN)Bottom;
}
/**
This function frees temporary memory pool.
@param[in] Buffer Temporary memory pool to free.
NULL indicates to free all temporary memory pool previously allocated
**/
VOID
EFIAPI
FreeTemporaryMemory (
IN VOID *Buffer
)
{
LOADER_GLOBAL_DATA *LdrGlobal;
UINT32 NewBottom;
LdrGlobal = GetLoaderGlobalDataPointer();
if (Buffer == NULL) {
LdrGlobal->MemPoolCurrBottom = LdrGlobal->MemPoolStart;
} else {
NewBottom = (UINT32)(UINTN)Buffer;
if (NewBottom < LdrGlobal->MemPoolCurrBottom) {
InternalUpdateMemPoolBottom (NewBottom);
}
}
}
/**
Frees one or more 4KB pages that were previously allocated with one of the page allocation
functions in the Memory Allocation Library.
Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer. Buffer
must have been allocated on a previous call to the page allocation services of the Memory
Allocation Library. If it is not possible to free allocated pages, then this function will
perform no actions.
If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
then ASSERT().
If Pages is zero, then ASSERT().
@param Buffer The pointer to the buffer of pages to free.
@param Pages The number of 4 KB pages to free.
**/
VOID
EFIAPI
FreePages (
IN VOID *Buffer,
IN UINTN Pages
)
{
}
/**
Frees a buffer that was previously allocated with one of the pool allocation functions in the
Memory Allocation Library.
Frees the buffer specified by Buffer. Buffer must have been allocated on a previous call to the
pool allocation services of the Memory Allocation Library. If it is not possible to free pool
resources, then this function will perform no actions.
If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
then ASSERT().
@param Buffer The pointer to the buffer to free.
**/
VOID
EFIAPI
FreePool (
IN VOID *Buffer
)
{
}
/**
Allocates one or more 4KB pages of type EfiRuntimeServicesData.
Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
allocated buffer. The buffer returned is aligned on a 4KB boundary. If Pages is 0, then NULL
is returned. If there is not enough memory remaining to satisfy the request, then NULL is
returned.
@param Pages The number of 4 KB pages to allocate.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocateRuntimePages (
IN UINTN Pages
)
{
return NULL;
}
/**
Allocates a buffer of type EfiRuntimeServicesData.
Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns
a pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is
returned. If there is not enough memory remaining to satisfy the request, then NULL is returned.
@param AllocationSize The number of bytes to allocate.
@return A pointer to the allocated buffer or NULL if allocation fails.
**/
VOID *
EFIAPI
AllocateRuntimePool (
IN UINTN AllocationSize
)
{
return NULL;
}
| 28.747748 | 100 | 0.697378 |
c8c48dbe891a962baa79c15991a78951d0de2cde | 4,614 | h | C | frameworks/bridge/codec/byte_buffer_operator.h | openharmony-gitee-mirror/ace_ace_engine | 78013960cdce81348d1910e466a3292605442a5e | [
"Apache-2.0"
] | null | null | null | frameworks/bridge/codec/byte_buffer_operator.h | openharmony-gitee-mirror/ace_ace_engine | 78013960cdce81348d1910e466a3292605442a5e | [
"Apache-2.0"
] | null | null | null | frameworks/bridge/codec/byte_buffer_operator.h | openharmony-gitee-mirror/ace_ace_engine | 78013960cdce81348d1910e466a3292605442a5e | [
"Apache-2.0"
] | 1 | 2021-09-13T12:07:42.000Z | 2021-09-13T12:07:42.000Z | /*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CODEC_BYTE_BUFFER_OPERATOR_H
#define FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CODEC_BYTE_BUFFER_OPERATOR_H
#include <cstdint>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/log/log.h"
#include "base/utils/noncopyable.h"
namespace OHOS::Ace::Framework {
class ByteBufferReader final {
public:
explicit ByteBufferReader(const std::vector<uint8_t>& buffer) : buffer_(buffer) {};
~ByteBufferReader() = default;
bool ReadData(uint8_t& value) const
{
return ReadValue(value);
}
bool ReadData(int32_t& value) const
{
return ReadValue(value);
}
bool ReadData(int64_t& value) const
{
return ReadValue(value);
}
bool ReadData(double& value) const
{
return ReadValue(value);
}
bool ReadData(std::string& value) const
{
return ReadArray(value);
}
bool ReadData(std::vector<int8_t>& dst) const
{
return ReadArray(dst);
}
bool ReadData(std::vector<int16_t>& dst) const
{
return ReadArray(dst);
}
bool ReadData(std::vector<int32_t>& dst) const
{
return ReadArray(dst);
}
bool ReadData(std::map<std::string, std::string>& dst) const;
bool ReadData(std::set<std::string>& dst) const;
private:
template<class T>
bool ReadValue(T& value) const
{
if (readPos_ + sizeof(T) > buffer_.size()) {
LOGW("Exceed buffer size, readPos = %{public}u, buffer size = %{public}zu", readPos_, buffer_.size());
return false;
}
value = *reinterpret_cast<const T*>(buffer_.data() + readPos_);
readPos_ += sizeof(T);
return true;
}
template<class T>
bool ReadArray(T& dst) const
{
int32_t length = -1;
if (!ReadData(length) || length < 0 || readPos_ + sizeof(typename T::value_type) * length > buffer_.size()) {
LOGW("Could not read array length or array length is invalid");
return false;
}
auto data = reinterpret_cast<const typename T::value_type*>(buffer_.data() + readPos_);
dst.assign(data, data + length);
readPos_ += sizeof(typename T::value_type) * length;
return true;
}
const std::vector<uint8_t>& buffer_;
mutable uint32_t readPos_ = 0;
ACE_DISALLOW_COPY_AND_MOVE(ByteBufferReader);
};
class ByteBufferWriter final {
public:
ByteBufferWriter(std::vector<uint8_t>& buffer) : buffer_(buffer) {};
~ByteBufferWriter() = default;
void WriteData(uint8_t value)
{
WriteValue(value);
}
void WriteData(int32_t value)
{
WriteValue(value);
}
void WriteData(int64_t value)
{
WriteValue(value);
}
void WriteData(double value)
{
WriteValue(value);
}
void WriteData(const std::string& src)
{
WriteArray(src);
}
void WriteData(const std::vector<int8_t>& src)
{
WriteArray(src);
}
void WriteData(const std::vector<int16_t>& src)
{
WriteArray(src);
}
void WriteData(const std::vector<int32_t>& src)
{
WriteArray(src);
}
void WriteData(const std::map<std::string, std::string>& mapValue);
void WriteData(const std::set<std::string>& setValue);
private:
template<class T>
void WriteValue(T value)
{
auto data = reinterpret_cast<uint8_t*>(&value);
buffer_.insert(buffer_.end(), data, data + sizeof(T));
}
template<class T>
void WriteArray(const T& array)
{
WriteData(static_cast<int32_t>(array.size()));
auto data = reinterpret_cast<const uint8_t*>(array.data());
buffer_.insert(buffer_.end(), data, data + sizeof(typename T::value_type) * array.size());
}
std::vector<uint8_t>& buffer_;
ACE_DISALLOW_COPY_AND_MOVE(ByteBufferWriter);
};
} // namespace OHOS::Ace::Framework
#endif // FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CODEC_BYTE_BUFFER_OPERATOR_H
| 26.982456 | 117 | 0.642176 |
087855ac9cb16b307bbb3809fe7f9e587a14194d | 4,697 | h | C | bsp/TC264D/Libraries/infineon_libraries/Infra/Sfr/TC26B/_Reg/IfxHsct_reg.h | GorgonMeducer/pikascript | fefe9afb17d14c1a3bbe75c4c6a83d65831f451e | [
"MIT"
] | 228 | 2021-09-11T06:09:43.000Z | 2022-03-30T08:09:01.000Z | bsp/TC264D/Libraries/infineon_libraries/Infra/Sfr/TC26B/_Reg/IfxHsct_reg.h | GorgonMeducer/pikascript | fefe9afb17d14c1a3bbe75c4c6a83d65831f451e | [
"MIT"
] | 48 | 2021-09-25T01:23:43.000Z | 2022-03-31T07:34:43.000Z | bsp/TC264D/Libraries/infineon_libraries/Infra/Sfr/TC26B/_Reg/IfxHsct_reg.h | GorgonMeducer/pikascript | fefe9afb17d14c1a3bbe75c4c6a83d65831f451e | [
"MIT"
] | 31 | 2021-09-17T12:06:45.000Z | 2022-03-19T16:10:11.000Z | /**
* \file IfxHsct_reg.h
* \brief
* \copyright Copyright (c) 2015 Infineon Technologies AG. All rights reserved.
*
* Version: TC26XB_UM_V1.2.R0
* Specification: tc26xB_um_v1.2_MCSFR.xml (Revision: UM_V1.2)
* MAY BE CHANGED BY USER [yes/no]: No
*
* IMPORTANT NOTICE
*
* Infineon Technologies AG (Infineon) is supplying this file for use
* exclusively with Infineon's microcontroller products. This file can be freely
* distributed within development tools that are supporting such microcontroller
* products.
*
* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
* INFINEON SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
* OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
*
* \defgroup IfxLld_Hsct_Cfg Hsct address
* \ingroup IfxLld_Hsct
*
* \defgroup IfxLld_Hsct_Cfg_BaseAddress Base address
* \ingroup IfxLld_Hsct_Cfg
*
* \defgroup IfxLld_Hsct_Cfg_Hsct 2-HSCT
* \ingroup IfxLld_Hsct_Cfg
*
*/
#ifndef IFXHSCT_REG_H
#define IFXHSCT_REG_H 1
/******************************************************************************/
#include "IfxHsct_regdef.h"
/******************************************************************************/
/** \addtogroup IfxLld_Hsct_Cfg_BaseAddress
* \{ */
/** \brief HSCT object */
#define MODULE_HSCT /*lint --e(923)*/ (*(Ifx_HSCT*)0xF0090000u)
/** \} */
/******************************************************************************/
/******************************************************************************/
/** \addtogroup IfxLld_Hsct_Cfg_Hsct
* \{ */
/** \brief FFFC, Access Enable Register 0 */
#define HSCT_ACCEN0 /*lint --e(923)*/ (*(volatile Ifx_HSCT_ACCEN0*)0xF009FFFCu)
/** \brief FFF8, Access Enable Register 1 */
#define HSCT_ACCEN1 /*lint --e(923)*/ (*(volatile Ifx_HSCT_ACCEN1*)0xF009FFF8u)
/** \brief 0, Clock Control Register */
#define HSCT_CLC /*lint --e(923)*/ (*(volatile Ifx_HSCT_CLC*)0xF0090000u)
/** \brief 30, Configuration physical layer register */
#define HSCT_CONFIGPHY /*lint --e(923)*/ (*(volatile Ifx_HSCT_CONFIGPHY*)0xF0090030u)
/** \brief 1C, Clear To Send Control Register */
#define HSCT_CTSCTRL /*lint --e(923)*/ (*(volatile Ifx_HSCT_CTSCTRL*)0xF009001Cu)
/** \brief 20, Transmission Disable Register */
#define HSCT_DISABLE /*lint --e(923)*/ (*(volatile Ifx_HSCT_DISABLE*)0xF0090020u)
/** \brief 8, Module Identification Register */
#define HSCT_ID /*lint --e(923)*/ (*(volatile Ifx_HSCT_ID*)0xF0090008u)
/** \brief 14, CPU transfer control register */
#define HSCT_IFCTRL /*lint --e(923)*/ (*(volatile Ifx_HSCT_IFCTRL*)0xF0090014u)
/** \brief 28, Interface Status Register */
#define HSCT_IFSTAT /*lint --e(923)*/ (*(volatile Ifx_HSCT_IFSTAT*)0xF0090028u)
/** \brief 10, Initialization register */
#define HSCT_INIT /*lint --e(923)*/ (*(volatile Ifx_HSCT_INIT*)0xF0090010u)
/** \brief 40, Interrupt register */
#define HSCT_IRQ /*lint --e(923)*/ (*(volatile Ifx_HSCT_IRQ*)0xF0090040u)
/** \brief 48, Interrupt clear register */
#define HSCT_IRQCLR /*lint --e(923)*/ (*(volatile Ifx_HSCT_IRQCLR*)0xF0090048u)
/** \brief 44, Interrupt enable register */
#define HSCT_IRQEN /*lint --e(923)*/ (*(volatile Ifx_HSCT_IRQEN*)0xF0090044u)
/** \brief FFF4, Reset Register 0 */
#define HSCT_KRST0 /*lint --e(923)*/ (*(volatile Ifx_HSCT_KRST0*)0xF009FFF4u)
/** \brief FFF0, Reset Register 1 */
#define HSCT_KRST1 /*lint --e(923)*/ (*(volatile Ifx_HSCT_KRST1*)0xF009FFF0u)
/** \brief FFEC, Reset Status Clear Register */
#define HSCT_KRSTCLR /*lint --e(923)*/ (*(volatile Ifx_HSCT_KRSTCLR*)0xF009FFECu)
/** \brief FFE8, OCDS Control and Status */
#define HSCT_OCS /*lint --e(923)*/ (*(volatile Ifx_HSCT_OCS*)0xF009FFE8u)
/** \brief 18, Sleep Control Register */
#define HSCT_SLEEPCTRL /*lint --e(923)*/ (*(volatile Ifx_HSCT_SLEEPCTRL*)0xF0090018u)
/** \brief 24, Status Register */
#define HSCT_STAT /*lint --e(923)*/ (*(volatile Ifx_HSCT_STAT*)0xF0090024u)
/** \brief 34, STATPHY */
#define HSCT_STATPHY /*lint --e(923)*/ (*(volatile Ifx_HSCT_STATPHY*)0xF0090034u)
/** \brief 50, Unsolicited Status Message Received */
#define HSCT_USMR /*lint --e(923)*/ (*(volatile Ifx_HSCT_USMR*)0xF0090050u)
/** \brief 54, Unsolicited Status Message Send */
#define HSCT_USMS /*lint --e(923)*/ (*(volatile Ifx_HSCT_USMS*)0xF0090054u)
/** \} */
/******************************************************************************/
/******************************************************************************/
#endif /* IFXHSCT_REG_H */
| 39.805085 | 85 | 0.632957 |
ecd261c73e2fa651215fd1c1a6c31b3a2d89d90b | 230 | h | C | include/memctl/symbol_finders.h | sonic414/memctl | be35f2fdbdd80079ef0e29755ab0fc677687c59c | [
"MIT"
] | 215 | 2017-10-24T13:19:49.000Z | 2022-03-30T08:29:10.000Z | include/memctl/symbol_finders.h | rhythmkay/memctl | be35f2fdbdd80079ef0e29755ab0fc677687c59c | [
"MIT"
] | 13 | 2018-01-03T18:43:30.000Z | 2020-09-19T18:32:08.000Z | include/memctl/symbol_finders.h | rhythmkay/memctl | be35f2fdbdd80079ef0e29755ab0fc677687c59c | [
"MIT"
] | 45 | 2017-09-16T07:33:26.000Z | 2022-03-30T08:29:23.000Z | #ifndef MEMCTL__SYMBOL_FINDERS_H_
#define MEMCTL__SYMBOL_FINDERS_H_
/*
* kernel_symbol_finders_init
*
* Description:
* Initialize libmemctl's special kernel symbol finders.
*/
void kernel_symbol_finders_init(void);
#endif
| 17.692308 | 57 | 0.8 |
ae9eb398f27378e735c7b118c0ada4d49d58019d | 1,643 | c | C | terminalio.c | aXises/Frogger | f273cbece050e1ede770396e15e367ae0ba62c2f | [
"MIT"
] | 1 | 2019-04-18T02:38:17.000Z | 2019-04-18T02:38:17.000Z | terminalio.c | aXises/Frogger | f273cbece050e1ede770396e15e367ae0ba62c2f | [
"MIT"
] | null | null | null | terminalio.c | aXises/Frogger | f273cbece050e1ede770396e15e367ae0ba62c2f | [
"MIT"
] | null | null | null | /*
* terminalio.c
*
* Author: Peter Sutton
*/
#include <stdio.h>
#include <stdint.h>
#include <avr/pgmspace.h>
#include "terminalio.h"
void move_cursor(int x, int y) {
printf_P(PSTR("\x1b[%d;%dH"), y, x);
}
void move_left(void) {
printf_P(PSTR("\x1b[%dD"), 1);
}
void normal_display_mode(void) {
printf_P(PSTR("\x1b[0m"));
}
void reverse_video(void) {
printf_P(PSTR("\x1b[7m"));
}
void clear_terminal(void) {
printf_P(PSTR("\x1b[2J"));
}
void clear_to_end_of_line(void) {
printf_P(PSTR("\x1b[K"));
}
void set_display_attribute(DisplayParameter parameter) {
printf_P(PSTR("\x1b[%dm"), parameter);
}
void hide_cursor() {
printf_P(PSTR("\x1b[?25l"));
}
void show_cursor() {
printf_P(PSTR("\x1b[?25h"));
}
void enable_scrolling_for_whole_display(void) {
printf_P(PSTR("\x1b[r"));
}
void set_scroll_region(int8_t y1, int8_t y2) {
printf_P(PSTR("\x1b[%d;%dr"), y1, y2);
}
void scroll_down(void) {
printf_P(PSTR("\x1bM")); // ESC-M
}
void scroll_up(void) {
printf_P(PSTR("\x1b\x44")); // ESC-D
}
void draw_horizontal_line(int8_t y, int8_t start_x, int8_t end_x) {
int8_t i;
move_cursor(start_x, y);
reverse_video();
for(i=start_x; i <= end_x; i++) {
printf(" "); /* No need to use printf_P - printing
* a single character gets optimised
* to a putchar call
*/
}
normal_display_mode();
}
void draw_vertical_line(int8_t x, int8_t start_y, int8_t end_y) {
int8_t i;
move_cursor(x, start_y);
reverse_video();
for(i=start_y; i < end_y; i++) {
printf(" ");
/* Move down one and back to the left one */
printf_P(PSTR("\x1b[B\x1b[D"));
}
printf(" ");
normal_display_mode();
}
| 18.054945 | 67 | 0.651248 |
2340b6dd7f232bd979581ed24eb20156d439b02c | 1,437 | h | C | aztec/include/Aztec_Lua_Bind.h | viccsneto/aztec | a49e269c53f19d2de22f0d297908c917f36c658d | [
"MIT"
] | null | null | null | aztec/include/Aztec_Lua_Bind.h | viccsneto/aztec | a49e269c53f19d2de22f0d297908c917f36c658d | [
"MIT"
] | null | null | null | aztec/include/Aztec_Lua_Bind.h | viccsneto/aztec | a49e269c53f19d2de22f0d297908c917f36c658d | [
"MIT"
] | null | null | null | #pragma once
/*
** Lua binding: lua_bind
** Generated automatically by tolua 5.1.4 on 06/07/12 04:09:01.
*/
#include <tolua.h>
/* Exported function */
using namespace Aztec;
/**
* Provides more info in the error messages of the binding
*/
#ifndef tolua_hacks
#define tolua_hacks
//OPTIMIZES INT TO BOOLEAN CONVERSION
#define tolua_toboolean(state, narg, def) (tolua_toboolean(state, narg, def) != 0)
//NECESSARY TO CONVERT THE LINE NUMBER TO STRING
#define __NUMBER_TO_STRING__(x) __NUMBER_TO_STRING__2__(x)
#define __NUMBER_TO_STRING__2__(x) #x
//DISPLAY MORE DEBUG INFO
#if 0
#define __Aztec__MORE_INFO__ \
"\nfile: "__FILE__ \
"\nfunction"__FUNCTION__ \
" ("__NUMBER_TO_STRING__(__LINE__) ")\n"
#define tolua_error(A, B, C) tolua_error(A, B __Aztec__MORE_INFO__, C)
#endif
#endif
/**
* Provides more info in the error messages of the binding
*/
TOLUA_API int tolua_Aztec_Lua_Bind(lua_State *tolua_S);
LUALIB_API int luaopen_Aztec_Lua_Bind(lua_State *tolua_S); | 35.925 | 180 | 0.512178 |
83c87e819020d0537dddf3dbb161e874a95df26f | 4,812 | h | C | tools/SourceKit/tools/sourcekitd/lib/API/DictionaryKeys.h | YogeshBharate/Swift | a14a836caa42b1652f8f30b725370eff2ad6d799 | [
"Apache-2.0"
] | 825 | 2015-12-09T05:44:26.000Z | 2021-11-13T15:01:11.000Z | tools/SourceKit/tools/sourcekitd/lib/API/DictionaryKeys.h | YogeshBharate/Swift | a14a836caa42b1652f8f30b725370eff2ad6d799 | [
"Apache-2.0"
] | 19 | 2015-12-10T00:57:59.000Z | 2021-05-25T15:57:05.000Z | tools/SourceKit/tools/sourcekitd/lib/API/DictionaryKeys.h | YogeshBharate/Swift | a14a836caa42b1652f8f30b725370eff2ad6d799 | [
"Apache-2.0"
] | 45 | 2015-12-10T14:21:43.000Z | 2017-05-26T02:43:30.000Z | //===--- DictionaryKeys.h - -------------------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SOURCEKITD_LIB_API_DICTIONARYKEYS_H
#define LLVM_SOURCEKITD_LIB_API_DICTIONARYKEYS_H
namespace SourceKit {
class UIdent;
}
namespace sourcekitd {
extern SourceKit::UIdent KeyVersionMajor;
extern SourceKit::UIdent KeyVersionMinor;
extern SourceKit::UIdent KeyResults;
extern SourceKit::UIdent KeyRequest;
extern SourceKit::UIdent KeyCompilerArgs;
extern SourceKit::UIdent KeyOffset;
extern SourceKit::UIdent KeySourceFile;
extern SourceKit::UIdent KeySourceText;
extern SourceKit::UIdent KeyModuleName;
extern SourceKit::UIdent KeyGroupName;
extern SourceKit::UIdent KeySynthesizedExtension;
extern SourceKit::UIdent KeyNotification;
extern SourceKit::UIdent KeyKeyword;
extern SourceKit::UIdent KeyName;
extern SourceKit::UIdent KeyNames;
extern SourceKit::UIdent KeyUIDs;
extern SourceKit::UIdent KeyEnableSyntaxMap;
extern SourceKit::UIdent KeyEnableDiagnostics;
extern SourceKit::UIdent KeySyntacticOnly;
extern SourceKit::UIdent KeyLength;
extern SourceKit::UIdent KeyKind;
extern SourceKit::UIdent KeyAccessibility;
extern SourceKit::UIdent KeySetterAccessibility;
extern SourceKit::UIdent KeyUSR;
extern SourceKit::UIdent KeyOriginalUSR;
extern SourceKit::UIdent KeyDefaultImplementationOf;
extern SourceKit::UIdent KeyInterestedUSR;
extern SourceKit::UIdent KeyLine;
extern SourceKit::UIdent KeyColumn;
extern SourceKit::UIdent KeyReceiverUSR;
extern SourceKit::UIdent KeyIsDynamic;
extern SourceKit::UIdent KeyIsTestCandidate;
extern SourceKit::UIdent KeyDescription;
extern SourceKit::UIdent KeyTypeName;
extern SourceKit::UIdent KeyRuntimeName;
extern SourceKit::UIdent KeySelectorName;
extern SourceKit::UIdent KeyOverrides;
extern SourceKit::UIdent KeyDocBrief;
extern SourceKit::UIdent KeyAssociatedUSRs;
extern SourceKit::UIdent KeyDocFullAsXML;
extern SourceKit::UIdent KeyGenericParams;
extern SourceKit::UIdent KeyGenericRequirements;
extern SourceKit::UIdent KeyAnnotatedDecl;
extern SourceKit::UIdent KeyFullyAnnotatedDecl;
extern SourceKit::UIdent KeyRelatedDecls;
extern SourceKit::UIdent KeyContext;
extern SourceKit::UIdent KeyModuleImportDepth;
extern SourceKit::UIdent KeyNumBytesToErase;
extern SourceKit::UIdent KeyNotRecommended;
extern SourceKit::UIdent KeyFilePath;
extern SourceKit::UIdent KeyModuleInterfaceName;
extern SourceKit::UIdent KeyHash;
extern SourceKit::UIdent KeyRelated;
extern SourceKit::UIdent KeyInherits;
extern SourceKit::UIdent KeyConforms;
extern SourceKit::UIdent KeyExtends;
extern SourceKit::UIdent KeyDependencies;
extern SourceKit::UIdent KeyEntities;
extern SourceKit::UIdent KeyDiagnostics;
extern SourceKit::UIdent KeySeverity;
extern SourceKit::UIdent KeyRanges;
extern SourceKit::UIdent KeyFixits;
extern SourceKit::UIdent KeyAnnotations;
extern SourceKit::UIdent KeyDiagnosticStage;
extern SourceKit::UIdent KeySyntaxMap;
extern SourceKit::UIdent KeyIsSystem;
extern SourceKit::UIdent KeyEnableStructure;
extern SourceKit::UIdent KeySubStructure;
extern SourceKit::UIdent KeyElements;
extern SourceKit::UIdent KeyNameOffset;
extern SourceKit::UIdent KeyNameLength;
extern SourceKit::UIdent KeyBodyOffset;
extern SourceKit::UIdent KeyBodyLength;
extern SourceKit::UIdent KeyThrowOffset;
extern SourceKit::UIdent KeyThrowLength;
extern SourceKit::UIdent KeyIsLocal;
extern SourceKit::UIdent KeyAttributes;
extern SourceKit::UIdent KeyAttribute;
extern SourceKit::UIdent KeyInheritedTypes;
extern SourceKit::UIdent KeyFormatOptions;
extern SourceKit::UIdent KeyCodeCompleteOptions;
extern SourceKit::UIdent KeyFilterRules;
extern SourceKit::UIdent KeyNextRequestStart;
extern SourceKit::UIdent KeyPopular;
extern SourceKit::UIdent KeyUnpopular;
extern SourceKit::UIdent KeyHide;
extern SourceKit::UIdent KeySimplified;
extern SourceKit::UIdent KeyIsUnavailable;
extern SourceKit::UIdent KeyIsDeprecated;
extern SourceKit::UIdent KeyIsOptional;
extern SourceKit::UIdent KeyPlatform;
extern SourceKit::UIdent KeyMessage;
extern SourceKit::UIdent KeyIntroduced;
extern SourceKit::UIdent KeyDeprecated;
extern SourceKit::UIdent KeyObsoleted;
extern SourceKit::UIdent KeyRemoveCache;
extern SourceKit::UIdent KeyTypeInterface;
extern SourceKit::UIdent KeyModuleGroups;
/// \brief Used for determining the printing order of dictionary keys.
bool compareDictKeys(SourceKit::UIdent LHS, SourceKit::UIdent RHS);
}
#endif
| 37.59375 | 80 | 0.815669 |
6c4e8c8a9e93c3939d0d648e4fde191cd9269fcc | 987 | h | C | System/Library/PrivateFrameworks/LoginPerformanceKit.framework/LPKPerformanceTestIntermediary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | 1 | 2020-11-04T15:43:01.000Z | 2020-11-04T15:43:01.000Z | System/Library/PrivateFrameworks/LoginPerformanceKit.framework/LPKPerformanceTestIntermediary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/LoginPerformanceKit.framework/LPKPerformanceTestIntermediary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, September 27, 2020 at 11:54:41 AM Mountain Standard Time
* Operating System: Version 14.0 (Build 18A373)
* Image Source: /System/Library/PrivateFrameworks/LoginPerformanceKit.framework/LoginPerformanceKit
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
@interface LPKPerformanceTestIntermediary : NSObject
+(long long)_enableKtrace;
+(BOOL)startUserSwitchTestForType:(unsigned long long)arg1 count:(long long)arg2 username:(id)arg3 password:(id)arg4 ;
+(long long)_disableKtrace;
+(long long)_dumpKtraceResult;
+(BOOL)endUserSwitchTest;
+(void)_removeStoredValues;
+(BOOL)startPerformanceTestForType:(unsigned long long)arg1 count:(long long)arg2 username:(id)arg3 password:(id)arg4 ;
+(id)endPerformanceTestAndDumpResults;
+(void)enableRestrictionlessLoginWithCompletionHandler:(/*^block*/id)arg1 ;
+(void)disableRestrictionlessLoginWithCompletionHandler:(/*^block*/id)arg1 ;
@end
| 42.913043 | 119 | 0.801418 |
9b354c7c9e6bc5f488ed7a52ef1e6f48f445095f | 1,361 | h | C | src/include/utils/relcache.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | src/include/utils/relcache.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | src/include/utils/relcache.h | emotionbug/incubator-age-pg | 676e3c735dec32ba0448fdd0faf9ace37c1fa792 | [
"BSD-4-Clause-UC"
] | null | null | null | /*-------------------------------------------------------------------------
*
* relcache.h--
* Relation descriptor cache definitions.
*
*
* Copyright (c) 1994, Regents of the University of California
*
* $Id: relcache.h,v 1.4 1996/11/10 03:06:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef RELCACHE_H
#define RELCACHE_H
#include <utils/rel.h>
/*
* relation lookup routines
*/
extern Relation RelationIdCacheGetRelation(Oid relationId);
extern Relation RelationNameCacheGetRelation(char *relationName);
extern Relation RelationIdGetRelation(Oid relationId);
extern Relation RelationNameGetRelation(char *relationName);
extern Relation getreldesc(char *relationName);
extern void RelationClose(Relation relation);
extern void RelationFlushRelation(Relation *relationPtr,
bool onlyFlushReferenceCountZero);
extern void RelationIdInvalidateRelationCacheByRelationId(Oid relationId);
extern void
RelationIdInvalidateRelationCacheByAccessMethodId(Oid accessMethodId);
extern void RelationCacheInvalidate(bool onlyFlushReferenceCountZero);
extern void RelationRegisterRelation(Relation relation);
extern void RelationPurgeLocalRelation(bool xactComitted);
extern void RelationInitialize(void);
extern void init_irels(void);
extern void write_irels(void);
#endif /* RELCACHE_H */
| 30.244444 | 75 | 0.717855 |
5345471a2ddd569fea26ce980a67dcea7607a9bc | 1,314 | h | C | Utility/DnDUtil.h | janimationd/DnD5ESoftwareSuite | 4af1ef876b00fba7bd67fe4187dde515e1876f86 | [
"Apache-2.0"
] | null | null | null | Utility/DnDUtil.h | janimationd/DnD5ESoftwareSuite | 4af1ef876b00fba7bd67fe4187dde515e1876f86 | [
"Apache-2.0"
] | null | null | null | Utility/DnDUtil.h | janimationd/DnD5ESoftwareSuite | 4af1ef876b00fba7bd67fe4187dde515e1876f86 | [
"Apache-2.0"
] | null | null | null | #pragma once
#define FLAG 5555555555u
#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
#define DIV_ROUND_DOWN(n, d) (int(floorf(float(n) / (d))))
namespace eAbility {
enum Type : uint32_t {
STR = 0, DEX, CON, INT, WIS, CHA, MAX
};
}
namespace eSkill {
enum Type : uint32_t {
ACROBATICS = 0,
ANIMAL_HANDLING,
ARCANA,
ATHLETICS,
DECEPTION,
HISTORY,
INSIGHT,
INTIMIDATION,
INVESTIGATION,
MEDICINE,
NATURE,
PERCEPTION,
PERFORMANCE,
PERSUASION,
RELIGION,
SLEIGHT_OF_HAND,
STEALTH,
SURVIVAL,
MAX
};
}
// all languages in 5th edition, copied from here: https://olddungeonmaster.wordpress.com/2012/06/27/dd-languages/
namespace eLanguage {
enum Type : uint32_t {
ABYSSAL = 0,
AQUAN,
AURAN,
CELESTIAL,
COMMON,
DEEP_SPEECH,
DRACONIC,
DRUIDIC,
DWARVISH,
ELVISH,
GIANT,
GNOMISH,
GOBLIN,
GNOLL,
HALFLING,
IGNAN,
INFERNAL,
ORC,
PRIMORDIAL,
SYLVAN,
TERRAN,
UNDERCOMMON,
MAX
};
};
// the different types of dice, useful for attack damage
namespace eDice {
enum Type : uint32_t {
D4 = 0,
D6,
D8,
D10,
D12,
D20,
D100,
MAX
};
} | 14.764045 | 114 | 0.582192 |
bb5069f5c1b7f1651a8cbd2341968492b7f711c5 | 444 | h | C | src/logging.h | SuprDewd/NineToFive | 5e04a08c7be2dd8de3320ba388708735a0cbdf85 | [
"MIT"
] | 4 | 2015-11-01T20:19:29.000Z | 2021-06-01T13:59:42.000Z | src/logging.h | SuprDewd/NineToFive | 5e04a08c7be2dd8de3320ba388708735a0cbdf85 | [
"MIT"
] | 1 | 2015-11-01T22:20:30.000Z | 2015-11-01T23:06:46.000Z | src/logging.h | SuprDewd/NineToFive | 5e04a08c7be2dd8de3320ba388708735a0cbdf85 | [
"MIT"
] | null | null | null | #ifndef LOGGING_H
#define LOGGING_H
#include <time.h>
#include <stdio.h>
void ensure_log_dir_exists(void);
void ensure_log_file_exists(const char *log_name);
char *get_log_file(const char *log_name);
int valid_log_name(const char *log_name);
FILE *open_log_file(const char *log_name, const char *mode);
void log_event(const char *log_name, time_t time, const char *event);
void log_event_now(const char *log_name, const char *event);
#endif
| 27.75 | 69 | 0.783784 |
4b32abe49f5073482bf5c3ecc6c2818d2bfb69ae | 2,841 | h | C | CoreDuet.framework/_CDInteraction.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | 4 | 2021-10-06T12:15:26.000Z | 2022-02-21T02:26:00.000Z | CoreDuet.framework/_CDInteraction.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | null | null | null | CoreDuet.framework/_CDInteraction.h | reels-research/iOS-Private-Frameworks | 9a4f4534939310a51fdbf5a439dd22487efb0f01 | [
"MIT"
] | 1 | 2021-10-08T07:40:53.000Z | 2021-10-08T07:40:53.000Z | /* Generated by RuntimeBrowser
Image: /System/Library/PrivateFrameworks/CoreDuet.framework/CoreDuet
*/
@interface _CDInteraction : NSObject <NSSecureCoding, _CDPDataPoint> {
NSString * _account;
NSArray * _attachments;
NSString * _bundleId;
NSURL * _contentURL;
long long _direction;
NSString * _domainIdentifier;
NSDate * _endDate;
bool _isResponse;
NSArray * _keywords;
NSString * _locationUUID;
long long _mechanism;
NSArray * _recipients;
_CDContact * _sender;
NSDate * _startDate;
NSString * _targetBundleId;
NSString * _uuid;
}
@property (retain) NSString *account;
@property (retain) NSArray *attachments;
@property (retain) NSString *bundleId;
@property (retain) NSURL *contentURL;
@property (readonly, copy) NSString *debugDescription;
@property (readonly, copy) NSString *description;
@property long long direction;
@property (retain) NSString *domainIdentifier;
@property (retain) NSDate *endDate;
@property (readonly) unsigned long long hash;
@property bool isResponse;
@property (retain) NSArray *keywords;
@property (retain) NSString *locationUUID;
@property long long mechanism;
@property (nonatomic, readonly) NSArray *peopleIdentifiers;
@property (retain) NSArray *recipients;
@property (retain) _CDContact *sender;
@property (retain) NSDate *startDate;
@property (readonly) Class superclass;
@property (retain) NSString *targetBundleId;
@property (nonatomic, readonly) NSDate *timestamp;
@property (nonatomic, readonly) NSString *title;
@property (nonatomic, readonly) bool userIsSender;
@property (nonatomic, readonly) bool userIsThreadInitiator;
@property (retain) NSString *uuid;
+ (bool)supportsSecureCoding;
- (void).cxx_destruct;
- (id)account;
- (id)attachments;
- (id)bundleId;
- (id)contentURL;
- (id)description;
- (id)descriptionOfArray:(id)arg1;
- (long long)direction;
- (id)domainIdentifier;
- (void)encodeWithCoder:(id)arg1;
- (id)endDate;
- (id)init;
- (id)initWithCoder:(id)arg1;
- (id)initWithINInteraction:(id)arg1 bundleID:(id)arg2;
- (bool)isResponse;
- (id)keywords;
- (id)locationUUID;
- (long long)mechanism;
- (id)peopleIdentifiers;
- (id)recipients;
- (id)sender;
- (void)setAccount:(id)arg1;
- (void)setAttachments:(id)arg1;
- (void)setBundleId:(id)arg1;
- (void)setContentURL:(id)arg1;
- (void)setDirection:(long long)arg1;
- (void)setDomainIdentifier:(id)arg1;
- (void)setEndDate:(id)arg1;
- (void)setIsResponse:(bool)arg1;
- (void)setKeywords:(id)arg1;
- (void)setLocationUUID:(id)arg1;
- (void)setMechanism:(long long)arg1;
- (void)setRecipients:(id)arg1;
- (void)setSender:(id)arg1;
- (void)setStartDate:(id)arg1;
- (void)setTargetBundleId:(id)arg1;
- (void)setUuid:(id)arg1;
- (id)startDate;
- (id)targetBundleId;
- (id)timestamp;
- (id)title;
- (bool)userIsSender;
- (bool)userIsThreadInitiator;
- (id)uuid;
@end
| 28.989796 | 71 | 0.734952 |
189e14d8645b56d2d4d1214474de6295f3fa10da | 741 | h | C | Pods/Headers/Typhoon/TyphoonDefinitionRegisterer.h | 422053362/Typhoon-example | e164aaa0ae0118063f1a3e756ea25952e88eddcd | [
"Apache-2.0"
] | null | null | null | Pods/Headers/Typhoon/TyphoonDefinitionRegisterer.h | 422053362/Typhoon-example | e164aaa0ae0118063f1a3e756ea25952e88eddcd | [
"Apache-2.0"
] | 1 | 2020-03-17T22:53:02.000Z | 2020-03-17T22:53:02.000Z | Pods/Headers/Typhoon/TyphoonDefinitionRegisterer.h | 422053362/Typhoon-example | e164aaa0ae0118063f1a3e756ea25952e88eddcd | [
"Apache-2.0"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////
//
// TYPHOON FRAMEWORK
// Copyright 2013, Jasper Blues & Contributors
// All Rights Reserved.
//
// NOTICE: The authors permit you to use, modify, and distribute this file
// in accordance with the terms of the license agreement accompanying it.
//
////////////////////////////////////////////////////////////////////////////////
#import <Foundation/Foundation.h>
@class TyphoonDefinition;
@class TyphoonComponentFactory;
/**
* @ingroup Factory
*
*/
@interface TyphoonDefinitionRegisterer : NSObject
- (id)initWithDefinition:(TyphoonDefinition *)definition componentFactory:(TyphoonComponentFactory *)componentFactory;
- (void)doRegistration;
@end | 26.464286 | 118 | 0.597841 |
bbb704912c272dde829aff5c9e61ff0313e1904c | 268 | h | C | src/nm_svg_map.h | arrowd/nemu | c74733ff15ba936c5b4251e3f34d2c60673f9b00 | [
"BSD-2-Clause"
] | null | null | null | src/nm_svg_map.h | arrowd/nemu | c74733ff15ba936c5b4251e3f34d2c60673f9b00 | [
"BSD-2-Clause"
] | null | null | null | src/nm_svg_map.h | arrowd/nemu | c74733ff15ba936c5b4251e3f34d2c60673f9b00 | [
"BSD-2-Clause"
] | null | null | null | #ifndef NM_SVG_MAP_H_
#define NM_SVG_MAP_H_
#include <nm_vector.h>
enum {
NM_SVG_LAYER_UP,
NM_SVG_LAYER_DOWN,
NM_SVG_LAYER_ALL
};
void nm_svg_map(const char *path, const nm_vect_t *veths, int layer);
#endif /* NM_SVG_MAP_H_ */
/* vim:set ts=4 sw=4: */
| 16.75 | 69 | 0.712687 |
a0ba3705a3d087e290216603b72588efdb315135 | 222 | c | C | sources/main.c | jerome-Dh/etoile-bleue-server | 7e186d0ac2c27013881c44491ba0bb2a632dad2e | [
"MIT"
] | 1 | 2020-10-24T04:15:45.000Z | 2020-10-24T04:15:45.000Z | sources/main.c | jerome-Dh/etoile-bleue-server | 7e186d0ac2c27013881c44491ba0bb2a632dad2e | [
"MIT"
] | null | null | null | sources/main.c | jerome-Dh/etoile-bleue-server | 7e186d0ac2c27013881c44491ba0bb2a632dad2e | [
"MIT"
] | null | null | null | /**
* Server side implementation
*
* @author Jerome Dh
* @date 05/09/2020
*/
#include <stdlib.h>
#include "server.h"
/**
* Main app
*/
int main()
{
init();
app();
end();
return EXIT_SUCCESS;
} | 9.652174 | 29 | 0.540541 |
6ff52ab3054c0adcaa732914f60cccca0e7f417d | 8,241 | c | C | src/cursor.c | dasfaha/sky | 4f2696e9abe54f4818f94337ed3bceae798e5a6d | [
"MIT"
] | 2 | 2018-01-16T07:26:53.000Z | 2021-12-08T03:12:40.000Z | src/cursor.c | dasfaha/sky | 4f2696e9abe54f4818f94337ed3bceae798e5a6d | [
"MIT"
] | null | null | null | src/cursor.c | dasfaha/sky | 4f2696e9abe54f4818f94337ed3bceae798e5a6d | [
"MIT"
] | null | null | null | #include "cursor.h"
#include "path.h"
#include "event.h"
#include "mem.h"
#include "dbg.h"
//==============================================================================
//
// Forward Declarations
//
//==============================================================================
int sky_cursor_set_ptr(sky_cursor *cursor, void *ptr);
int sky_cursor_set_eof(sky_cursor *cursor);
//==============================================================================
//
// Functions
//
//==============================================================================
//--------------------------------------
// Lifecycle
//--------------------------------------
// Creates a reference to a cursor.
//
// Returns a reference to the new cursor if successful.
sky_cursor *sky_cursor_create()
{
sky_cursor *cursor = calloc(sizeof(sky_cursor),1 ); check_mem(cursor);
return cursor;
error:
sky_cursor_free(cursor);
return NULL;
}
// Allocates memory for the cursor.
//
// Returns a reference to the new cursor if successful.
sky_cursor *sky_cursor_alloc()
{
return malloc(sizeof(sky_cursor));
}
// Initializes a cursor.
void sky_cursor_init(sky_cursor *cursor)
{
memset(cursor, 0, sizeof(sky_cursor));
}
// Removes a cursor reference from memory.
//
// cursor - The cursor to free.
void sky_cursor_free(sky_cursor *cursor)
{
if(cursor) {
if(cursor->paths) free(cursor->paths);
free(cursor);
}
}
//--------------------------------------
// Path Management
//--------------------------------------
// Assigns a single path to the cursor.
//
// cursor - The cursor.
// ptr - A pointer to the raw data where the path starts.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_set_path(sky_cursor *cursor, void *ptr)
{
int rc;
check(cursor != NULL, "Cursor required");
// If data is not null then create an array of one pointer.
void **ptrs;
if(ptr != NULL) {
ptrs = malloc(sizeof(void*)); check_mem(ptrs);
ptrs[0] = ptr;
rc = sky_cursor_set_paths(cursor, ptrs, 1);
check(rc == 0, "Unable to set path data to cursor");
}
// Otherwise clear out pointer paths.
else {
rc = sky_cursor_set_paths(cursor, NULL, 0);
check(rc == 0, "Unable to remove path data");
}
return 0;
error:
if(ptrs) free(ptrs);
return -1;
}
// Assigns a list of path pointers to the cursor.
//
// cursor - The cursor.
// ptrs - An array to pointers of raw paths.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_set_paths(sky_cursor *cursor, void **ptrs, int count)
{
int rc;
check(cursor != NULL, "Cursor required");
// Free old path list.
if(cursor->paths != NULL) {
free(cursor->paths);
}
// Assign path data list.
cursor->paths = ptrs;
cursor->path_count = count;
cursor->path_index = 0;
cursor->event_index = 0;
cursor->eof = (count == 0);
// Position the pointer at the first path if paths are passed.
if(count > 0) {
rc = sky_cursor_set_ptr(cursor, cursor->paths[0]);
check(rc == 0, "Unable to set paths");
}
// Otherwise clear out the pointer.
else {
cursor->ptr = NULL;
cursor->endptr = NULL;
}
return 0;
error:
return -1;
}
//--------------------------------------
// Pointer Management
//--------------------------------------
// Initializes the cursor to point at a new path at a given pointer.
//
// cursor - The cursor to update.
// ptr - The address of the start of a path.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_set_ptr(sky_cursor *cursor, void *ptr)
{
check(cursor != NULL, "Cursor required");
check(ptr != NULL, "Pointer required");
// Store position of first event and store position of end of path.
cursor->ptr = ptr + SKY_PATH_HEADER_LENGTH;
cursor->endptr = ptr + sky_path_sizeof_raw(ptr);
return 0;
error:
cursor->ptr = NULL;
cursor->endptr = NULL;
return -1;
}
//--------------------------------------
// Iteration
//--------------------------------------
int sky_cursor_next(sky_cursor *cursor)
{
int rc;
check(cursor != NULL, "Cursor required");
check(!cursor->eof, "No more events are available");
// Move to next event.
size_t event_length = sky_event_sizeof_raw(cursor->ptr);
cursor->ptr += event_length;
cursor->event_index++;
// If pointer is beyond the last event then move to next path.
if(cursor->ptr >= cursor->endptr) {
cursor->path_index++;
// Move to the next path if more paths are remaining.
if(cursor->path_index < cursor->path_count) {
rc = sky_cursor_set_ptr(cursor, cursor->paths[cursor->path_index]);
check(rc == 0, "Unable to set pointer to path");
}
// Otherwise set EOF.
else {
rc = sky_cursor_set_eof(cursor);
check(rc == 0, "Unable to set EOF on cursor");
}
}
// Make sure that we are point at an event.
if(!cursor->eof) {
sky_event_flag_t flag = *((sky_event_flag_t*)cursor->ptr);
check(flag & SKY_EVENT_FLAG_ACTION || flag & SKY_EVENT_FLAG_DATA, "Cursor pointing at invalid raw event data: %p", cursor->ptr);
}
return 0;
error:
return -1;
}
// Flags a cursor to say that it is at the end of all its paths.
//
// cursor - The cursor to set EOF on.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_set_eof(sky_cursor *cursor)
{
check(cursor != NULL, "Cursor required");
cursor->path_index = 0;
cursor->event_index = 0;
cursor->eof = true;
cursor->ptr = NULL;
cursor->endptr = NULL;
return 0;
error:
return -1;
}
//--------------------------------------
// Event Management
//--------------------------------------
// Retrieves a the action identifier of the current event.
//
// cursor - The cursor.
// action_id - A pointer to where the action id should be returned to.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_get_action_id(sky_cursor *cursor, sky_action_id_t *action_id)
{
check(cursor != NULL, "Cursor required");
check(!cursor->eof, "Cursor cannot be EOF");
check(action_id != NULL, "Action id return pointer required");
// Retrieve the action id.
if(*((sky_event_flag_t*)cursor->ptr) & SKY_EVENT_FLAG_ACTION) {
*action_id = *((sky_action_id_t*)(cursor->ptr + sizeof(sky_event_flag_t) + sizeof(sky_timestamp_t)));
}
else {
*action_id = 0;
}
return 0;
error:
*action_id = 0;
return -1;
}
// Retrieves the pointer to where the data section of an event starts as
// well of the length of the data.
//
// cursor - The cursor.
// data_ptr - A pointer to where the memory location of the data starts.
// data_length - The length of the data section.
//
// Returns 0 if successful, otherwise returns -1.
int sky_cursor_get_data_ptr(sky_cursor *cursor, void **data_ptr,
uint32_t *data_length)
{
check(cursor != NULL, "Cursor required");
check(!cursor->eof, "Cursor cannot be EOF");
check(data_ptr != NULL, "Data return pointer required");
check(data_length != NULL, "Data length return pointer required");
// Retrieve the data section if this event has data.
if(*((sky_event_flag_t*)cursor->ptr) & SKY_EVENT_FLAG_DATA) {
// Move past the initial header (flag, timestamp, action_id).
void *ptr = cursor->ptr;
ptr += sizeof(sky_event_flag_t) + sizeof(sky_timestamp_t);
if(*((sky_event_flag_t*)cursor->ptr) & SKY_EVENT_FLAG_ACTION) {
ptr += sizeof(sky_action_id_t);
}
// At the end of the header is the data length.
*data_length = *((sky_event_data_length_t*)(ptr));
// After the data length begins the data section.
*data_ptr = ptr + sizeof(sky_event_data_length_t);
}
// If this is an action-only event then return null.
else {
*data_ptr = NULL;
*data_length = 0;
}
return 0;
error:
*data_ptr = NULL;
*data_length = 0;
return -1;
}
| 26.329073 | 136 | 0.573838 |
a5ab230022974ff3f78c84b0587dbad69b87c058 | 1,677 | c | C | leetcode/addtwonumber.c | lanhuidong/c-learning | 648fbdca44be307ccebc7bdfd34f9c875d6d0b3b | [
"MIT"
] | 1 | 2015-05-12T13:55:55.000Z | 2015-05-12T13:55:55.000Z | leetcode/addtwonumber.c | lanhuidong/c-learning | 648fbdca44be307ccebc7bdfd34f9c875d6d0b3b | [
"MIT"
] | null | null | null | leetcode/addtwonumber.c | lanhuidong/c-learning | 648fbdca44be307ccebc7bdfd34f9c875d6d0b3b | [
"MIT"
] | null | null | null | #include<stdio.h>
#include<stdlib.h>
struct ListNode {
int val;
struct ListNode* next;
};
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2);
int main(void)
{
struct ListNode node1;
node1.next = NULL;
node1.val = 5;
struct ListNode node2;
node2.next = NULL;
node2.val = 5;
struct ListNode* l1 = &node1;
struct ListNode* l2 = &node2;
struct ListNode* result = addTwoNumbers(l1, l2);
while(result != NULL){
printf("%d\n", result->val);
result = result->next;
}
return 0;
}
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
struct ListNode* result = NULL;
struct ListNode* last;
struct ListNode* node;
int addOne = 0;
while(l1 != NULL || l2 != NULL){
int sum = 0;
if(l1 != NULL && l2 != NULL){
l1->val = l1->val + l2->val;
node = l1;
l1 = l1->next;
l2 = l2->next;
} else if(l1 != NULL){
node = l1;
l1 = l1->next;
} else if(l2 != NULL){
node = l2;
l2 = l2->next;
}
node->val = node->val + addOne;
if(node->val >= 10){
node->val = node->val - 10;
addOne = 1;
} else {
addOne = 0;
}
if(result == NULL){
result = node;
last = node;
} else {
last->next = node;
last = node;
}
}
if(addOne){
node = malloc(sizeof(struct ListNode));
node->val = 1;
last->next = node;
last = node;
}
last->next = NULL;
return result;
}
| 23.291667 | 73 | 0.486583 |
7792dadcc2382aee5af43c3e2613db8dc77f2ec5 | 90 | c | C | 295 C Questions/124.c | DevGithub007/My_Codes | e506050b97abc058fa8b1e24b3b936cc2315c664 | [
"MIT"
] | null | null | null | 295 C Questions/124.c | DevGithub007/My_Codes | e506050b97abc058fa8b1e24b3b936cc2315c664 | [
"MIT"
] | null | null | null | 295 C Questions/124.c | DevGithub007/My_Codes | e506050b97abc058fa8b1e24b3b936cc2315c664 | [
"MIT"
] | null | null | null | #include<stdio.h>
main()
{
char c;
int i;
i=10;
char j;
c='A';
j=c;
putchar(j);
}
| 6.923077 | 17 | 0.511111 |
8589512c972e3cfd1e973d53783313802b4db6ca | 5,772 | c | C | SOFTWARE/A64-TERES/linux-a64/drivers/md/bcache/movinggc.c | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | 2 | 2017-10-30T12:25:44.000Z | 2019-08-25T09:01:38.000Z | SOFTWARE/A64-TERES/linux-a64/drivers/md/bcache/movinggc.c | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | null | null | null | SOFTWARE/A64-TERES/linux-a64/drivers/md/bcache/movinggc.c | xloem/DIY-LAPTOP | f2a410706f7a919ac644de073c570629d5601203 | [
"Apache-2.0"
] | 4 | 2020-05-26T12:40:11.000Z | 2021-07-15T06:46:33.000Z | /*
* Moving/copying garbage collector
*
* Copyright 2012 Google, Inc.
*/
#include "bcache.h"
#include "btree.h"
#include "debug.h"
#include "request.h"
struct moving_io {
struct keybuf_key *w;
struct search s;
struct bbio bio;
};
static bool moving_pred(struct keybuf *buf, struct bkey *k)
{
struct cache_set *c = container_of(buf, struct cache_set,
moving_gc_keys);
unsigned i;
for (i = 0; i < KEY_PTRS(k); i++) {
struct cache *ca = PTR_CACHE(c, k, i);
struct bucket *g = PTR_BUCKET(c, k, i);
if (GC_SECTORS_USED(g) < ca->gc_move_threshold)
return true;
}
return false;
}
/* Moving GC - IO loop */
static void moving_io_destructor(struct closure *cl)
{
struct moving_io *io = container_of(cl, struct moving_io, s.cl);
kfree(io);
}
static void write_moving_finish(struct closure *cl)
{
struct moving_io *io = container_of(cl, struct moving_io, s.cl);
struct bio *bio = &io->bio.bio;
struct bio_vec *bv = bio_iovec_idx(bio, bio->bi_vcnt);
while (bv-- != bio->bi_io_vec)
__free_page(bv->bv_page);
pr_debug("%s %s", io->s.op.insert_collision
? "collision moving" : "moved",
pkey(&io->w->key));
bch_keybuf_del(&io->s.op.c->moving_gc_keys, io->w);
atomic_dec_bug(&io->s.op.c->in_flight);
closure_wake_up(&io->s.op.c->moving_gc_wait);
closure_return_with_destructor(cl, moving_io_destructor);
}
static void read_moving_endio(struct bio *bio, int error)
{
struct moving_io *io = container_of(bio->bi_private,
struct moving_io, s.cl);
if (error)
io->s.error = error;
bch_bbio_endio(io->s.op.c, bio, error, "reading data to move");
}
static void moving_init(struct moving_io *io)
{
struct bio *bio = &io->bio.bio;
bio_init(bio);
bio_get(bio);
bio_set_prio(bio, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
bio->bi_size = KEY_SIZE(&io->w->key) << 9;
bio->bi_max_vecs = DIV_ROUND_UP(KEY_SIZE(&io->w->key),
PAGE_SECTORS);
bio->bi_private = &io->s.cl;
bio->bi_io_vec = bio->bi_inline_vecs;
bch_bio_map(bio, NULL);
}
static void write_moving(struct closure *cl)
{
struct search *s = container_of(cl, struct search, cl);
struct moving_io *io = container_of(s, struct moving_io, s);
if (!s->error) {
trace_bcache_write_moving(&io->bio.bio);
moving_init(io);
io->bio.bio.bi_sector = KEY_START(&io->w->key);
s->op.lock = -1;
s->op.write_prio = 1;
s->op.cache_bio = &io->bio.bio;
s->writeback = KEY_DIRTY(&io->w->key);
s->op.csum = KEY_CSUM(&io->w->key);
s->op.type = BTREE_REPLACE;
bkey_copy(&s->op.replace, &io->w->key);
closure_init(&s->op.cl, cl);
bch_insert_data(&s->op.cl);
}
continue_at(cl, write_moving_finish, NULL);
}
static void read_moving_submit(struct closure *cl)
{
struct search *s = container_of(cl, struct search, cl);
struct moving_io *io = container_of(s, struct moving_io, s);
struct bio *bio = &io->bio.bio;
trace_bcache_read_moving(bio);
bch_submit_bbio(bio, s->op.c, &io->w->key, 0);
continue_at(cl, write_moving, bch_gc_wq);
}
static void read_moving(struct closure *cl)
{
struct cache_set *c = container_of(cl, struct cache_set, moving_gc);
struct keybuf_key *w;
struct moving_io *io;
struct bio *bio;
/* XXX: if we error, background writeback could stall indefinitely */
while (!test_bit(CACHE_SET_STOPPING, &c->flags)) {
w = bch_keybuf_next_rescan(c, &c->moving_gc_keys, &MAX_KEY);
if (!w)
break;
io = kzalloc(sizeof(struct moving_io) + sizeof(struct bio_vec)
* DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS),
GFP_KERNEL);
if (!io)
goto err;
w->private = io;
io->w = w;
io->s.op.inode = KEY_INODE(&w->key);
io->s.op.c = c;
moving_init(io);
bio = &io->bio.bio;
bio->bi_rw = READ;
bio->bi_end_io = read_moving_endio;
if (bch_bio_alloc_pages(bio, GFP_KERNEL))
goto err;
pr_debug("%s", pkey(&w->key));
closure_call(&io->s.cl, read_moving_submit, NULL, &c->gc.cl);
if (atomic_inc_return(&c->in_flight) >= 64) {
closure_wait_event(&c->moving_gc_wait, cl,
atomic_read(&c->in_flight) < 64);
continue_at(cl, read_moving, bch_gc_wq);
}
}
if (0) {
err: if (!IS_ERR_OR_NULL(w->private))
kfree(w->private);
bch_keybuf_del(&c->moving_gc_keys, w);
}
closure_return(cl);
}
static bool bucket_cmp(struct bucket *l, struct bucket *r)
{
return GC_SECTORS_USED(l) < GC_SECTORS_USED(r);
}
static unsigned bucket_heap_top(struct cache *ca)
{
return GC_SECTORS_USED(heap_peek(&ca->heap));
}
void bch_moving_gc(struct closure *cl)
{
struct cache_set *c = container_of(cl, struct cache_set, gc.cl);
struct cache *ca;
struct bucket *b;
unsigned i;
if (!c->copy_gc_enabled)
closure_return(cl);
mutex_lock(&c->bucket_lock);
for_each_cache(ca, c, i) {
unsigned sectors_to_move = 0;
unsigned reserve_sectors = ca->sb.bucket_size *
min(fifo_used(&ca->free), ca->free.size / 2);
ca->heap.used = 0;
for_each_bucket(b, ca) {
if (!GC_SECTORS_USED(b))
continue;
if (!heap_full(&ca->heap)) {
sectors_to_move += GC_SECTORS_USED(b);
heap_add(&ca->heap, b, bucket_cmp);
} else if (bucket_cmp(b, heap_peek(&ca->heap))) {
sectors_to_move -= bucket_heap_top(ca);
sectors_to_move += GC_SECTORS_USED(b);
ca->heap.data[0] = b;
heap_sift(&ca->heap, 0, bucket_cmp);
}
}
while (sectors_to_move > reserve_sectors) {
heap_pop(&ca->heap, b, bucket_cmp);
sectors_to_move -= GC_SECTORS_USED(b);
}
ca->gc_move_threshold = bucket_heap_top(ca);
pr_debug("threshold %u", ca->gc_move_threshold);
}
mutex_unlock(&c->bucket_lock);
c->moving_gc_keys.last_scanned = ZERO_KEY;
closure_init(&c->moving_gc, cl);
read_moving(&c->moving_gc);
closure_return(cl);
}
void bch_moving_init_cache_set(struct cache_set *c)
{
bch_keybuf_init(&c->moving_gc_keys, moving_pred);
}
| 22.635294 | 70 | 0.677408 |
8b80f42960d22a4ed941d819d398649e430b5026 | 5,164 | h | C | src/main/cpp/modbus_base.h | menucha-de/Util.Modbus | 16b5c9b5355671cf8d630f8271d59731480858e8 | [
"Apache-2.0"
] | null | null | null | src/main/cpp/modbus_base.h | menucha-de/Util.Modbus | 16b5c9b5355671cf8d630f8271d59731480858e8 | [
"Apache-2.0"
] | null | null | null | src/main/cpp/modbus_base.h | menucha-de/Util.Modbus | 16b5c9b5355671cf8d630f8271d59731480858e8 | [
"Apache-2.0"
] | null | null | null | #ifndef MODBUS_BASE_H
#define MODBUS_BASE_H
#include "modbus_mapping.h"
#include "common/Mutex.h"
#include "common/MutexLock.h"
#include <stdint.h>
#include <errno.h>
#include <sys/select.h> // fd_set
/*
* All method excl. client methods are thread safe.
*/
class ModbusBasePrivate;
class ModbusBase {
public:
// function codes
static const int MODBUS_FC_READ_COILS = 1;
static const int MODBUS_FC_READ_DISCRETE_INPUTS = 2;
static const int MODBUS_FC_READ_HOLDING_REGISTERS = 3;
static const int MODBUS_FC_READ_INPUT_REGISTERS = 4;
static const int MODBUS_FC_WRITE_SINGLE_COIL = 5;
static const int MODBUS_FC_WRITE_SINGLE_REGISTER = 6;
static const int MODBUS_FC_WRITE_MULTIPLE_COILS = 15;
static const int MODBUS_FC_WRITE_MULTIPLE_REGISTERS = 16;
static const int MODBUS_FC_WRITE_AND_READ_REGISTERS = 23;
// error numbers (getErrNo)
static const unsigned int ERRNO_EAGAIN = EAGAIN; // 11: Try again
static const unsigned int ERRNO_EPIPE = EPIPE; // 32: Broken pipe
static const unsigned int ERRNO_ECONNRESET = ECONNRESET; // 104: Connection reset by peer
static const unsigned int ERRNO_ETIMEDOUT = ETIMEDOUT; // 110: Connection timed out
static const unsigned int ERRNO_ECONNREFUSED = ECONNREFUSED; // 111: Connection refused
// exception codes (replyException)
static const unsigned int MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 1;
static const unsigned int MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS = 2;
static const unsigned int MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE = 3;
static const unsigned int MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE = 4;
static const unsigned int MODBUS_EXCEPTION_ACKNOWLEDGE = 5;
static const unsigned int MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY = 6;
static const unsigned int MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE = 7;
static const unsigned int MODBUS_EXCEPTION_MEMORY_PARITY = 8;
static const unsigned int MODBUS_EXCEPTION_NOT_DEFINED = 9;
static const unsigned int MODBUS_EXCEPTION_GATEWAY_PATH = 10;
static const unsigned int MODBUS_EXCEPTION_GATEWAY_TARGET = 11;
// modbus specific error numbers
static const unsigned int ERRNO_MODBUS_ENOBASE = 112345678;
static const unsigned int ERRNO_EMBXGTAR = (ERRNO_MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET);
static const unsigned int ERRNO_EMBBADDATA = (ERRNO_EMBXGTAR + 2); // 112345691: Invalid transaction or protocol ID
// common
virtual void free();
virtual void setDebug(bool debug);
virtual int setSlave(int slaveId);
virtual void setSocket(int socket);
virtual int getSocket();
virtual void setResponseTimeout(long timeout);
virtual uint8_t getByteFromBits(const uint8_t* src, int index, unsigned int nb);
virtual void setBitsFromByte(uint8_t* dest, int index, const uint8_t value);
virtual uint16_t getInt16FromInt8(const uint8_t* tabInt8, int index);
virtual uint32_t getInt32FromInt16(const uint16_t* tabInt16, int index);
virtual float getFloat(const uint16_t* src);
virtual void setFloat(float f, uint16_t* dest);
virtual int getHeaderLength();
virtual int getErrNo();
virtual const char* strError(int errNo);
// connection
virtual int connect();
virtual void close();
// client
virtual int readBits(int addr, int nb, uint8_t* returnDest);
virtual int readInputBits(int addr, int nb, uint8_t* returnDest);
virtual int readRegisters(int addr, int nb, uint16_t* returnDest);
virtual int readInputRegisters(int addr, int nb, uint16_t* returnDest);
virtual int writeBit(int addr, int status);
virtual int writeBits(int addr, int nb, const uint8_t* src);
virtual int writeRegister(int addr, int value);
virtual int writeRegisters(int addr, int nb, const uint16_t* src);
virtual int writeAndReadRegisters(int writeAddr, int writeNb, const uint16_t* src,
int readAddr, int readNb, uint16_t* dest);
// server
virtual ModbusMapping* mappingNew(int nbCoilStatus, int nbInputStatus,
int nbHoldingRegisters, int nbInputRegisters);
virtual void mappingFree(ModbusMapping* mbMapping);
virtual int receive(uint8_t* returnRequest);
virtual int reply(const uint8_t* request, int requestLength, ModbusMapping* mbMapping);
virtual int replyException(const uint8_t* request, unsigned int exceptionCode);
protected:
static const unsigned int SELECT_MASK_NONE = 0;
static const unsigned int SELECT_MASK_RECEIVE = 1;
static const unsigned int SELECT_MASK_ACCEPT = 4;
static const unsigned int SELECT_MASK_ALL = 5;
void* context; // set by "newRtu" or "newTcpPi", destroyed by "free"
int* sockets; // destroyed + initialized by "connect"/"tcpPiListen",
// filled by "connect"/"tcpPiAccept"
int socketCount;
int maxSocketCount;
int pipeFds[2];
int selectMask;
CommonNamespace::Mutex* mutex;
ModbusBase();
virtual ~ModbusBase();
virtual int wait4read(int fd, int selectMask, CommonNamespace::MutexLock& lock);
virtual int wait4read(fd_set* readFds, int fdMax, int selectMask, CommonNamespace::MutexLock& lock);
virtual void close(int socket, CommonNamespace::MutexLock& lock);
private:
ModbusBasePrivate* d;
};
#endif // MODBUS_BASE_H
| 43.394958 | 117 | 0.763943 |
8bcc43b0a6cbd7c30a7fc84e245c0042f64cf37e | 5,426 | h | C | iOSOpenDev/frameworks/PhotoLibrary.framework/Headers/PLExpandableView.h | bzxy/cydia | f8c838cdbd86e49dddf15792e7aa56e2af80548d | [
"MIT"
] | 678 | 2017-11-17T08:33:19.000Z | 2022-03-26T10:40:20.000Z | iOSOpenDev/frameworks/PhotoLibrary.framework/Headers/PLExpandableView.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 22 | 2019-04-16T05:51:53.000Z | 2021-11-08T06:18:45.000Z | iOSOpenDev/frameworks/PhotoLibrary.framework/Headers/PLExpandableView.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 170 | 2018-06-10T07:59:20.000Z | 2022-03-22T16:19:33.000Z | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/PhotoLibrary.framework/PhotoLibrary
*/
#import <PhotoLibrary/XXUnknownSuperclass.h>
#import <PhotoLibrary/PhotoLibrary-Structs.h>
@protocol PLExpandableViewDelegate;
@interface PLExpandableView : XXUnknownSuperclass {
id<PLExpandableViewDelegate> _delegate; // 48 = 0x30
CGRect _contractedFrame; // 52 = 0x34
CGRect _expandedFrame; // 68 = 0x44
CGPoint _leftTouchLocation; // 84 = 0x54
CGPoint _rightTouchLocation; // 92 = 0x5c
CGPoint _previousLeftLocation; // 100 = 0x64
CGPoint _previousRightLocation; // 108 = 0x6c
unsigned _leftTouchIndex; // 116 = 0x74
unsigned _rightTouchIndex; // 120 = 0x78
float _pinchVelocity; // 124 = 0x7c
double _trackingTimeInterval; // 128 = 0x80
float _expansionFraction; // 136 = 0x88
struct {
unsigned state : 3;
unsigned prevState : 3;
unsigned tracking : 1;
unsigned autorotationDisabled : 1;
unsigned animationDisabled : 1;
unsigned updateContractedFrame : 1;
unsigned updateExpandedFrame : 1;
unsigned allowsExpansion : 1;
unsigned delegateWillBeginExpanding : 1;
unsigned delegateWillCompleteExpanding : 1;
unsigned delegateDidCompleteExpanding : 1;
unsigned delegateWillCancelExpanding : 1;
unsigned delegateDidCancelExpanding : 1;
unsigned delegateDidBeginCollapsing : 1;
unsigned delegateWillCompleteCollapsing : 1;
unsigned delegateDidCompleteCollapsing : 1;
unsigned delegateWillCancelCollapsing : 1;
unsigned delegateDidCancelCollapsing : 1;
unsigned delegateExpandedFractionChanged : 1;
} _expandFlags; // 140 = 0x8c
}
@property(assign, nonatomic) BOOL allowsExpansion; // G=0x120a9; S=0x710dd;
@property(assign, nonatomic) CGRect expandedFrame; // G=0x70ff1; S=0x70f2d;
@property(assign, nonatomic) CGRect contractedFrame; // G=0x70e65; S=0x70da1;
@property(assign) id delegate; // G=0x70d91; S=0x70b79; converted property
@property(readonly, assign) float expansionFraction; // G=0x71139; converted property
- (BOOL)canCollapse; // 0x71195
- (BOOL)_canPinch; // 0x7115d
- (BOOL)isTracking; // 0x71149
// converted property getter: - (float)expansionFraction; // 0x71139
- (void)_setExpansionFraction:(float)fraction; // 0x71129
- (int)previousState; // 0x71115
- (int)state; // 0x71101
// declared property getter: - (BOOL)allowsExpansion; // 0x120a9
// declared property setter: - (void)setAllowsExpansion:(BOOL)expansion; // 0x710dd
// declared property getter: - (CGRect)expandedFrame; // 0x70ff1
// declared property setter: - (void)setExpandedFrame:(CGRect)frame; // 0x70f2d
// declared property getter: - (CGRect)contractedFrame; // 0x70e65
// declared property setter: - (void)setContractedFrame:(CGRect)frame; // 0x70da1
// converted property getter: - (id)delegate; // 0x70d91
// converted property setter: - (void)setDelegate:(id)delegate; // 0x70b79
- (void)expandWithAnimation:(BOOL)animation; // 0x70a49
- (void)collapseWithAnimation:(BOOL)animation; // 0x70959
- (float)completeTrackingPinch:(id)pinch toState:(int)state duration:(double)duration; // 0x70955
- (float)continueTrackingPinch:(id)pinch; // 0x70951
- (void)beginTrackingPinch:(id)pinch; // 0x7094d
- (CGRect)pinchRect:(CGRect)rect inView:(id)view insetTouches:(BOOL)touches; // 0x70539
- (void)updatePinchState:(id)state; // 0x70415
- (int)snapState:(BOOL)state; // 0x7033d
- (void)finishTransitionToState:(int)state; // 0x702d1
- (void)finishTransition; // 0x70281
- (void)canceledPinch:(id)pinch; // 0x70149
- (void)finishedPinch:(id)pinch; // 0x6ffed
- (void)continuedPinch:(id)pinch; // 0x6ff7d
- (void)startedPinch:(id)pinch; // 0x6fd89
- (void)notifyExpansionFraction:(float)fraction force:(BOOL)force; // 0x6fd0d
- (void)didMoveToWindow; // 0x16c8d
- (void)willMoveToWindow:(id)window; // 0x16c5d
- (void)stateDidChangeFrom:(int)state; // 0x6fd09
- (void)stateWillChangeTo:(int)state; // 0x6fd05
- (void)_setState:(int)state withDuration:(double)duration; // 0x6fab1
- (void)_transitionFromCompleteContract:(int)completeContract withDuration:(double)duration; // 0x6fa6d
- (void)_transitionFromCancelContract:(int)cancelContract withDuration:(double)duration; // 0x6fa29
- (void)_transitionFromContracting:(int)contracting withDuration:(double)duration; // 0x6f9ed
- (void)_transitionFromExpanded:(int)expanded withDuration:(double)duration; // 0x6f9d1
- (void)_transitionFromCancelExpand:(int)cancelExpand withDuration:(double)duration; // 0x6f98d
- (void)_transitionFromCompleteExpand:(int)completeExpand withDuration:(double)duration; // 0x6f949
- (void)_transitionFromExpanding:(int)expanding withDuration:(double)duration; // 0x6f90d
- (void)_transitionFromContracted:(int)contracted withDuration:(double)duration; // 0x6f8f1
- (void)_notifyDidCancelCollapsing; // 0x6f89d
- (void)_notifyDidCancelExpanding; // 0x6f849
- (void)_notifyWillBeginCollapsing; // 0x6f7f5
- (void)_notifyDidCompleteExpanding; // 0x6f7a1
- (void)_notifyWillCancelExpandingWithDuration:(double)_notify; // 0x6f755
- (void)_notifyWillCompleteExpandingWithDuration:(double)_notify; // 0x6f705
- (void)_notifyWillCompleteCollapsingWithDuration:(double)_notify; // 0x6f6b5
- (void)_notifyWillCancelCollapsingWithDuration:(double)_notify; // 0x6f665
- (void)_notifyWillBeginExpanding; // 0x6f611
- (void)_notifyDidCompleteCollapsing; // 0x6f5bd
- (void)_setAutorotationDisabled:(BOOL)disabled; // 0x6f529
- (id)initWithFrame:(CGRect)frame; // 0x11545
@end
| 50.240741 | 103 | 0.770549 |
275956ea407dd0650632e6d2490a4e6f5e54884a | 759 | h | C | src/materials/matte.h | lyinch/pbrt-subset | 98fdc2ce0791fcd33b7aff246da12faf43c360cb | [
"Unlicense"
] | null | null | null | src/materials/matte.h | lyinch/pbrt-subset | 98fdc2ce0791fcd33b7aff246da12faf43c360cb | [
"Unlicense"
] | null | null | null | src/materials/matte.h | lyinch/pbrt-subset | 98fdc2ce0791fcd33b7aff246da12faf43c360cb | [
"Unlicense"
] | null | null | null | //
// Created by Thierry Backes on 2019-06-27.
//
#ifndef PBRT_WHITTED_MATTE_H
#define PBRT_WHITTED_MATTE_H
#include "main.h"
#include "material.h"
namespace pbrt{
class MatteMaterial : public Material {
public:
MatteMaterial(const std::shared_ptr<Texture<Spectrum>> &Kd,
const std::shared_ptr<Texture<float>> &sigma)
: Kd(Kd), sigma(sigma) {}
void ComputeScatteringFunctions(SurfaceInteraction *si, MemoryArena &arena,
TransportMode mode,
bool allowMultipleLobes) const;
private:
std::shared_ptr<Texture<Spectrum>> Kd;
std::shared_ptr<Texture<float>> sigma;
};
}
#endif //PBRT_WHITTED_MATTE_H
| 27.107143 | 83 | 0.608696 |
e9ad3c8661d199ddab0a025544e4c81081ceac80 | 7,195 | c | C | rrp_multi_core/RRP-XenV3/set_schedule.c | pvpk1994/Xen-Schedule-Entry-Setup | 6d4c68c2fc9eab23a5d0e64f641d260e72ecf3f6 | [
"MIT"
] | null | null | null | rrp_multi_core/RRP-XenV3/set_schedule.c | pvpk1994/Xen-Schedule-Entry-Setup | 6d4c68c2fc9eab23a5d0e64f641d260e72ecf3f6 | [
"MIT"
] | null | null | null | rrp_multi_core/RRP-XenV3/set_schedule.c | pvpk1994/Xen-Schedule-Entry-Setup | 6d4c68c2fc9eab23a5d0e64f641d260e72ecf3f6 | [
"MIT"
] | null | null | null | #include <xenctrl.h>
#include <xen/sysctl.h>
#include <uuid/uuid.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_CPU_NUM 5
#define LINE_SIZE 2048
// #define TIME_SLICE_LENGTH 50
/* ********** XEN #DEFINEs ************** */
// #define NUM_MINOR_FRAMES 2
typedef int64_t s_time_t;
#define MICROSECS(_us) ((s_time_t)((_us) * 1000ULL))
// #define MILLISECS(_ms) (((s_time_t)(_ms)) * 1000000UL )
#define MILLISECS(_ms) ((s_time_t)((_ms) * 1000000ULL))
#define DOMN_RUNTIME(_runtime) (_runtime*MICROSECS(1000)) // Example: DOMN_RUNTIME(30) ~30ms ~ 30*pow(10,3)ns
#define DOMN_RUNTIME_US (DOMN_RUNTIME*MICROSECS(1000))
#define TIME_SLICE_LENGTH MILLISECS(1)
#define LIBXL_CPUPOOL_POOLID_ANY 0xFFFFFFFF
#define UUID_READ 1024
/* *************************************** */
int poolid(char* fileName)
{
int pool_id;
FILE* filer = fopen(fileName, "r");
if(filer == NULL)
{
perror("fopen(pool_id.txt)\n");
}
fscanf(filer, "%d", &pool_id);
printf("Reading... cpupool ID is: %d\n", pool_id);
fclose(filer);
return pool_id;
}
void getCPUInfo(char* buff, struct xen_sysctl_aaf_schedule* s_now)
{
//printf("Getting CPU Info\n");
char line[LINE_SIZE];
strcpy(line, buff);
char s[2] = ",";
char* token;
token = strtok(line, s);
if(token==NULL)
printf("%s not found in %s\n", s, line);
s_now->cpu_id = atoi(token);
token = strtok(NULL, s);
s_now->num_schedule_entries = atoi(token);
s_now->hyperperiod = s_now->num_schedule_entries * TIME_SLICE_LENGTH;
}
void getScheduleEntry(char* line, struct xen_sysctl_aaf_schedule* s_now)
{
//printf("Rertrieving entries\n");
char s[2] = ",";
char* token;
int counter = 0, ret_val;
token = strtok(line, s);
while(token)
{
//printf("%s; %s\n", line, token);
//printf("Entry now: %s\n", token);
//printf("Length: %u\n", strlen(token));
if(strlen(token)>36)
printf("%d\n", token[36]);
if(strcmp(token, "-1")==0 || strcmp(token, " -1")==0)
{
strcpy(s_now->schedule[counter].dom_handle, "");
//strcpy(s_now->schedule[counter].dom_handle, "0");
s_now->schedule[counter].vcpu = 0;
}
else
{
//strcpy(s_now->schedule[counter].dom_handle, token);
char temp[100];
strcpy(temp, token);
printf("This entry: %s\n", temp);
char domId[100], vcpu[100];
char * mid = strchr(temp, ':');
*mid = '\0';
strcpy(domId, temp);
strcpy(vcpu, mid+1);
printf("DomID:%s; ", domId);
printf("VCPU:%s\n", vcpu);
ret_val = uuid_parse(domId, s_now->schedule[counter].dom_handle);
s_now->schedule[counter].vcpu_id = atoi(vcpu);
//ret_val = uuid_parse(token, s_now->schedule[counter].dom_handle);
if(ret_val < 0)
{
printf("Wrong in parsing the uuid: %s\n", token);
return;
}
}
//printf("Entry stored: %s\n", s_now->schedule[counter].dom_handle);
//printf("Entry stored: %X\n", *s_now->schedule[counter].dom_handle);
/*
char temp[20];
sprintf(temp, "%X", *s_now->schedule[counter].dom_handle);
int CPU = s_now->cpu_id;
//printf("Test: %s", temp);
// hardcoding VCPU ID for each domain and each PCPU
if(strcmp(temp, "B")==0)
{
if(CPU==1)
{
s_now->schedule[counter].vcpu_id = 0;
}
else if(CPU==3)
{
s_now->schedule[counter].vcpu_id = 1;
}
else if(CPU==5)
{
s_now->schedule[counter].vcpu_id = 2;
}
else
{
s_now->schedule[counter].vcpu_id = 100;
}
}
else if(strcmp(temp, "DE")==0)
{
if(CPU==1)
{
s_now->schedule[counter].vcpu_id = 0;
}
else if(CPU==3)
{
s_now->schedule[counter].vcpu_id = 1;
}
else if(CPU==5)
{
s_now->schedule[counter].vcpu_id = 2;
}
else
{
s_now->schedule[counter].vcpu_id = 100;
}
}
else if(strcmp(temp, "C1")==0)
{
if(CPU==1)
{
s_now->schedule[counter].vcpu_id = 1;
}
else if(CPU==3)
{
s_now->schedule[counter].vcpu_id = 2;
}
else if(CPU==5)
{
s_now->schedule[counter].vcpu_id = 0;
}
else
{
s_now->schedule[counter].vcpu_id = 100;
}
}
*/
s_now->schedule[counter].wcet = TIME_SLICE_LENGTH;
//s_now->schedule[counter].vcpu_id = 0;
counter ++;
token = strtok(NULL, s);
/*
char sep[2] = ":";
char* temp;
temp = strtok(token, sep);
ret_val = uuid_parse(temp, s_now->schedule[counter].dom_handle);
if(ret_val < 0)
{
printf("Wrong in parsing the uuid!");
return;
}
printf("Parsed: %u\n", s_now->schedule[counter].dom_handle);
strcpy(s_now->schedule[counter].dom_handle, temp);
printf("Parse: %s\n", s_now->schedule[counter].dom_handle);
temp = strtok(NULL, sep);
s_now->schedule[counter].vcpu_id = atoi(temp);
s_now->schedule[counter].wcet = TIME_SLICE_LENGTH;
counter ++;
token = strtok(NULL, s);
*/
}
}
void parse(char* fileName)
{
xc_interface *xci = xc_interface_open(NULL, NULL, 0);
FILE *fp = NULL;
fp = fopen(fileName, "r");
if (fp==NULL)
{
printf("Cannot open %s!\n", fileName);
return;
}
struct xen_sysctl_scheduler_op ops;
struct xen_sysctl_aaf_schedule sched_aaf[MAX_CPU_NUM];
char buff[LINE_SIZE];
char* token;
int lineCounter = 0;
//while (!feof(fp))
while(fgets(buff, LINE_SIZE, fp))
{
buff[strlen(buff) - 1] = 0;
int index = lineCounter / 2;
//printf("%s\n", buff);
if(lineCounter%2 == 0)
{
// extract CPU info
getCPUInfo(buff, &sched_aaf[lineCounter / 2]);
}
else
{
// extract schedule info
getScheduleEntry(buff, &sched_aaf[lineCounter / 2]);
}
lineCounter ++;
}
for(int i=0; i<lineCounter/2; i++)
{
printf("CPU: %d, Entries: %d \n", sched_aaf[i].cpu_id, sched_aaf[i].num_schedule_entries);
for(int j=0; j<sched_aaf[i].num_schedule_entries; j++)
{
printf("%X : %d , ",*sched_aaf[i].schedule[j].dom_handle, sched_aaf[i].schedule[j].vcpu_id);
}
printf("\n");
int cpu_pool_id = poolid("config_files/pool_uuid/pool_id.txt");
// set schedule here
//#define RRP_SCHED_SET_ENABLE
#ifdef RRP_SCHED_SET_ENABLE
int set_result = xc_sched_aaf_schedule_set(xci, cpu_pool_id, &sched_aaf[i]);
printf("------------------------------\n");
printf("Schedule Set for LT PCPU: %d is: %d\n", sched_aaf[i].cpu_id, set_result);
printf("------------------------------\n");
#endif
// GET-ZONE
#ifdef RRP_HED_GET_ENABLE
int get_result = xc_sched_aaf_schedule_get(xci, cpu_pool_id, &sched_aaf[i]);
#endif
}
}
int main()
{
parse("out.txt");
}
| 27.996109 | 109 | 0.55066 |
6b875995b1c8eaf3143688fb23bb9fc1c0c41172 | 2,414 | h | C | php_api.h | DusanZokic/pecl-database-mysql_xdevapi-trunk | e49aef311ba04ea3e70190c026d0c9ee8d1d3947 | [
"PHP-3.01"
] | 14 | 2017-11-16T03:13:31.000Z | 2022-03-10T14:59:53.000Z | php_api.h | DusanZokic/pecl-database-mysql_xdevapi-trunk | e49aef311ba04ea3e70190c026d0c9ee8d1d3947 | [
"PHP-3.01"
] | 8 | 2018-03-02T06:08:27.000Z | 2022-01-18T10:34:43.000Z | php_api.h | DusanZokic/pecl-database-mysql_xdevapi-trunk | e49aef311ba04ea3e70190c026d0c9ee8d1d3947 | [
"PHP-3.01"
] | 18 | 2018-03-01T13:45:16.000Z | 2022-03-10T06:30:02.000Z | /*
+----------------------------------------------------------------------+
| PHP Version 7 |
+----------------------------------------------------------------------+
| Copyright (c) The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Darek Slusarczyk <marines@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef MYSQL_XDEVAPI_PHP_API_H
#define MYSQL_XDEVAPI_PHP_API_H
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
#ifdef PHP_WIN32
#pragma warning( push )
#pragma warning( disable : 4018 4244 4706)
#endif // PHP_WIN32
extern "C" {
#include <php.h>
#undef DELETE
#undef ERROR
#undef add_method
#undef inline
#undef min
#undef max
}
#include <inttypes.h>
#define MYSQLX_LLU_SPEC "%" PRIu64
#ifdef PHP_WIN32
#pragma warning( pop )
#endif // PHP_WIN32
#include "util/compiler_utils.h"
#ifdef PHP_WIN32
#define MYSQLX_HASH_FOREACH_VAL(ht, _val) \
MYSQLX_SUPPRESS_MSVC_WARNINGS(4127) \
ZEND_HASH_FOREACH_VAL(ht, _val) \
MYSQLX_RESTORE_WARNINGS()
#define MYSQLX_HASH_FOREACH_PTR(ht, _ptr) \
MYSQLX_SUPPRESS_MSVC_WARNINGS(4127) \
ZEND_HASH_FOREACH_PTR(ht, _ptr) \
MYSQLX_RESTORE_WARNINGS()
#define MYSQLX_HASH_FOREACH_STR_KEY_VAL(ht, _key, _val) \
MYSQLX_SUPPRESS_MSVC_WARNINGS(4127) \
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, _key, _val) \
MYSQLX_RESTORE_WARNINGS()
#else // UNIX OSes
#define MYSQLX_HASH_FOREACH_VAL ZEND_HASH_FOREACH_VAL
#define MYSQLX_HASH_FOREACH_PTR ZEND_HASH_FOREACH_PTR
#define MYSQLX_HASH_FOREACH_STR_KEY_VAL ZEND_HASH_FOREACH_STR_KEY_VAL
#endif
namespace mysqlx::util {
using raw_zval = zval;
}
#endif // MYSQL_XDEVAPI_PHP_API_H
| 29.802469 | 74 | 0.583679 |
3d95bd809d45076f90e2e945538c45520c490de2 | 285 | h | C | parser/parser.h | emekoi/svm | c57823299cc9eed62f98c5713f47cc2b810a0797 | [
"MIT"
] | null | null | null | parser/parser.h | emekoi/svm | c57823299cc9eed62f98c5713f47cc2b810a0797 | [
"MIT"
] | null | null | null | parser/parser.h | emekoi/svm | c57823299cc9eed62f98c5713f47cc2b810a0797 | [
"MIT"
] | null | null | null | /**
* Copyright (c) 2017 emekoi
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the MIT license. See LICENSE for details.
*/
#ifndef PARSER_H
#define PARSER_H
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#endif
| 16.764706 | 74 | 0.708772 |
5c21be27d23b2ba42ce54dec94a8d787dbecf100 | 11,294 | h | C | tensorflow/core/kernels/warp-ctc/include/contrib/moderngpu/include/mgpudevice.h | brycearden/tensorflow | 325a4b622f28cd36aed9a40f4a5175c59267107e | [
"Apache-2.0"
] | null | null | null | tensorflow/core/kernels/warp-ctc/include/contrib/moderngpu/include/mgpudevice.h | brycearden/tensorflow | 325a4b622f28cd36aed9a40f4a5175c59267107e | [
"Apache-2.0"
] | null | null | null | tensorflow/core/kernels/warp-ctc/include/contrib/moderngpu/include/mgpudevice.h | brycearden/tensorflow | 325a4b622f28cd36aed9a40f4a5175c59267107e | [
"Apache-2.0"
] | null | null | null | /******************************************************************************
* Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the NVIDIA CORPORATION nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/******************************************************************************
*
* Code and text by Sean Baxter, NVIDIA Research
* See http://nvlabs.github.io/moderngpu for repository and documentation.
*
******************************************************************************/
#pragma once
#include "mgpuenums.h"
#include "device/deviceutil.h"
namespace mgpu {
////////////////////////////////////////////////////////////////////////////////
// device/loadstore.cuh
// For 0 <= i < VT:
// index = NT * i + tid;
// reg[i] = data[index];
// Synchronize after load.
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceSharedToReg(InputIt data, int tid, T* reg,
bool sync = true);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) reg[i] = data[index];
// No synchronize after load.
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToReg(int count, InputIt data, int tid,
T* reg, bool sync = false);
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToRegDefault(int count, InputIt data, int tid,
T* reg, T init, bool sync = false);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) reg[i] = data[index];
// No synchronize after load.
template<int NT, int VT0, int VT1, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToReg(int count, InputIt data, int tid,
T* reg, bool sync = false);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) reg[i] = data[index];
// No synchronize after load.
template<int NT, int VT0, int VT1, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToRegDefault2(int count, InputIt data, int tid,
T* reg, T init, bool sync = false);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) reg[i] = data[index];
// No synchronize after load.
// No optimized code path for count < NV (smaller generated code).
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToRegLoop(int count, InputIt data, int tid,
T* reg, bool sync = false);
// For 0 <= i < VT:
// index = VT * tid + i.
// if(index < count) reg[i] = data[index];
// No synchronize after load.
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToThread(int count, InputIt data, int tid,
T* reg);
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToThreadDefault(int count, InputIt data, int tid,
T* reg, T init);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) data[index] = reg[i];
// Synchronize after load.
template<int NT, int VT, typename OutputIt, typename T>
MGPU_DEVICE void DeviceRegToShared(const T* reg, int tid, OutputIt dest,
bool sync = true);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count) data[index] = reg[i];
// No synchronize after load.
template<int NT, int VT, typename OutputIt, typename T>
MGPU_DEVICE void DeviceRegToGlobal(int count, const T* reg, int tid,
OutputIt dest, bool sync = false);
// For 0 <= index < count:
// dest[index] = source[index];
// This function is intended to replace DeviceGlobalToShared in cases where
// count is much less than NT * VT.
template<int NT, typename InputIt, typename OutputIt>
MGPU_DEVICE void DeviceMemToMemLoop(int count, InputIt source, int tid,
OutputIt dest, bool sync = true);
// For 0 <= index < count:
// dest[index] = source[index];
// Synchronize after store.
template<int NT, int VT, typename T, typename OutputIt>
MGPU_DEVICE void DeviceSharedToGlobal(int count, const T* source, int tid,
OutputIt dest, bool sync = true);
// For 0 <= index < count:
// dest[index] = source[index];
// Synchronize after store.
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToShared(int count, InputIt source, int tid,
T* dest, bool sync = true);
template<int NT, int VT0, int VT1, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToShared2(int count, InputIt source, int tid,
T* dest, bool sync = true);
// For 0 <= index < count:
// dest[index] = source[index];
// Synchronize after store.
// No optimized code path for count < NV (smaller generated code).
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToSharedLoop(int count, InputIt source, int tid,
T* dest, bool sync = true);
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToSharedDefault(int count, InputIt source, int tid,
T* dest, T init, bool sync = true);
template<int NT, int VT0, int VT1, typename InputIt, typename T>
MGPU_DEVICE void DeviceGlobalToSharedDefault2(int count, InputIt source,
int tid, T* dest, T init, bool sync = true);
// For 0 <= index < count:
// dest[index] = source[index];
// No synchronize.
template<int NT, int VT, typename InputIt, typename OutputIt>
MGPU_DEVICE void DeviceGlobalToGlobal(int count, InputIt source, int tid,
OutputIt dest, bool sync = false);
// Transponse VT elements in NT threads (x) into thread-order registers (y)
// using only NT * VT / 2 elements of shared memory.
template<int NT, int VT, typename T>
MGPU_DEVICE void HalfSmemTranspose(const T* x, int tid, T* shared, T* y);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count)
// gather = indices[index];
// reg[i] = data[gather];
// Synchronize after load.
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGather(int count, InputIt data, int indices[VT],
int tid, T* reg, bool sync = true);
template<int NT, int VT, typename InputIt, typename T>
MGPU_DEVICE void DeviceGatherDefault(int count, InputIt data, int indices[VT],
int tid, T* reg, T identity, bool sync = true);
// For 0 <= i < VT:
// index = NT * i + tid;
// if(index < count)
// scatter = indices[index];
// data[scatter] = reg[i];
// Synchronize after store.
template<int NT, int VT, typename T, typename OutputIt>
MGPU_DEVICE void DeviceScatter(int count, const T* reg, int tid,
int indices[VT], OutputIt data, bool sync = true);
// For 0 <= i < VT:
// shared[VT * tid + i] = threadReg[i];
// Synchronize after store.
// Note this function moves data in THREAD ORDER.
// (DeviceRegToShared moves data in STRIDED ORDER).
template<int VT, typename T>
MGPU_DEVICE void DeviceThreadToShared(const T* threadReg, int tid, T* shared,
bool sync = true);
// For 0 <= i < VT:
// threadReg[i] = shared[VT * tid + i];
// Synchronize after load.
// Note this function moves data in THREAD ORDER.
// (DeviceSharedToReg moves data in STRIDED ORDER).
template<int VT, typename T>
MGPU_DEVICE void DeviceSharedToThread(const T* shared, int tid, T* threadReg,
bool sync = true);
// For 0 <= index < aCount:
// shared[index] = a_global[index];
// For 0 <= index < bCount:
// shared[aCount + index] = b_global[index];
// VT0 is the lower-bound for predication-free execution:
// If count >= NT * VT0, a predication-free branch is taken.
// VT1 is the upper-bound for loads:
// NT * VT1 must >= aCount + bCount.
template<int NT, int VT0, int VT1, typename T>
MGPU_DEVICE void DeviceLoad2ToReg(const T* a_global, int aCount,
const T* b_global, int bCount, int tid, T* reg, bool sync = false);
template<int NT, int VT0, int VT1, typename T>
MGPU_DEVICE void DeviceLoad2ToShared(const T* a_global, int aCount,
const T* b_global, int bCount, int tid, T* shared, bool sync = true);
template<int NT, int VT0, int VT1, typename InputIt1, typename InputIt2,
typename T>
MGPU_DEVICE void DeviceLoad2ToReg(InputIt1 a_global, int aCount,
InputIt2 b_global, int bCount, int tid, T* reg, bool sync = false);
template<int NT, int VT0, int VT1, typename InputIt1, typename InputIt2,
typename T>
MGPU_DEVICE void DeviceLoad2ToShared(InputIt1 a_global, int aCount,
InputIt2 b_global, int bCount, int tid, T* shared, bool sync = true);
// For 0 <= i < VT
// index = NT * i + tid;
// if(index < count)
// gather = indices_shared[index];
// dest_global[index] = data_global[gather];
// Synchronize after load.
template<int NT, int VT, typename InputIt, typename OutputIt>
MGPU_DEVICE void DeviceGatherGlobalToGlobal(int count, InputIt data_global,
const int* indices_shared, int tid, OutputIt dest_global,
bool sync = true);
// For 0 <= i < VT
// index = NT * i + tid
// if(index < count)
// gather = indices[index];
// if(gather < aCount) data = a_global[gather];
// else data = b_global[gather - aCount];
// dest_global[index] = data;
// Synchronize after load.
template<int NT, int VT, typename InputIt1, typename InputIt2,
typename T>
MGPU_DEVICE void DeviceTransferMergeValuesReg(int count, InputIt1 a_global,
InputIt2 b_global, int bStart, const int* indices, int tid,
T* reg, bool sync = false);
template<int NT, int VT, typename InputIt1, typename InputIt2,
typename OutputIt>
MGPU_DEVICE void DeviceTransferMergeValuesShared(int count, InputIt1 a_global,
InputIt2 b_global, int bStart, const int* indices_shared, int tid,
OutputIt dest_global, bool sync = true);
template<int NT, int VT, typename T>
MGPU_DEVICE void DeviceTransferMergeValuesReg(int count, const T* a_global,
const T* b_global, int bStart, const int* indices, int tid,
T* reg, bool sync = false);
template<int NT, int VT, typename T, typename OutputIt>
MGPU_DEVICE void DeviceTransferMergeValuesShared(int count, const T* a_global,
const T* b_global, int bStart, const int* indices_shared, int tid,
OutputIt dest_global, bool sync = true);
} // namespace mgpu
#include "device/loadstore.h"
#include "device/ctasegscan.h"
| 38.944828 | 80 | 0.691252 |
e1fe33aa3d7409178fa4928f12baceebdf4b493a | 1,532 | h | C | base/assert.h | r10r/libcx | 4266b987a1f6c4f04c2552a94ee06ab77ccf6c2f | [
"BSD-3-Clause"
] | 1 | 2017-07-06T05:47:07.000Z | 2017-07-06T05:47:07.000Z | base/assert.h | r10r/libcx | 4266b987a1f6c4f04c2552a94ee06ab77ccf6c2f | [
"BSD-3-Clause"
] | null | null | null | base/assert.h | r10r/libcx | 4266b987a1f6c4f04c2552a94ee06ab77ccf6c2f | [
"BSD-3-Clause"
] | 1 | 2021-04-22T10:12:25.000Z | 2021-04-22T10:12:25.000Z | #ifndef _CX_ASSERT_H
#define _CX_ASSERT_H
#include <assert.h>
#ifndef _CX_ASSERT
#define cx_assert(cond) (void)(cond)
#define XCHECK(condition, message) UNUSED(condition)
#define XCHECK_EQUALS_INT(expected, actual, message) UNUSED(expected)
#define XFCHECK(condition, format, ...) UNUSED(condition)
#define XASSERT(condition, message) UNUSED(condition)
#define XFASSERT(condition, format, ...) UNUSED(condition)
#else
#define cx_assert(cond) assert(cond)
/*
* Print message to stderr when assertion fails.
*/
#define XCHECK(condition, message) \
if (!(condition)) \
fprintf(stderr, "XCHECK:(%s):%s:%d - %s\n", \
__func__, __FILE__, __LINE__, message)
#define XCHECK_EQUALS_INT(expected, actual, message) \
if (expected != actual) \
fprintf(stderr, "XFCHECK:(%s):%s:%d - [%s (expected %d, was %d)]\n", \
__func__, __FILE__, __LINE__, message, expected, actual)
#define XFCHECK(condition, format, ...) \
if (!(condition)) \
fprintf(stderr, "XFCHECK:(%s):%s:%d - " format "\n", \
__func__, __FILE__, __LINE__, __VA_ARGS__); \
/*
* Print message to stderr and exit with XEXIT_CODE when assertion fails.
*/
#define XASSERT(condition, message) \
if (!(condition)) \
{ \
fprintf(stderr, "XASSERT:(%s):%s:%d - " message "\n", \
__func__, __FILE__, __LINE__); \
exit(XEXIT_CODE); \
}
#define XFASSERT(condition, format, ...) \
if (!(condition)) { \
fprintf(stderr, "XASSERT:(%s):%s:%d - " format "\n", \
__func__, __FILE__, __LINE__, __VA_ARGS__); \
exit(XEXIT_CODE); \
}
#endif
#endif
| 25.533333 | 73 | 0.674935 |
d4a8de9fd97083379ae996e9e253bd78a39ef1c3 | 7,079 | c | C | tests/board/ubirch1r03/test_rgb_flexio.c | ubirch/ubirch-board-firmware | 90cb144f9d239304af2331e60206e021794c200d | [
"Apache-2.0"
] | 2 | 2016-11-23T14:42:17.000Z | 2016-12-23T12:34:58.000Z | tests/board/ubirch1r03/test_rgb_flexio.c | ubirch/ubirch-board-firmware | 90cb144f9d239304af2331e60206e021794c200d | [
"Apache-2.0"
] | 4 | 2016-06-10T12:27:58.000Z | 2016-10-16T18:22:34.000Z | tests/board/ubirch1r03/test_rgb_flexio.c | ubirch/ubirch-board-firmware | 90cb144f9d239304af2331e60206e021794c200d | [
"Apache-2.0"
] | 1 | 2016-12-23T12:35:06.000Z | 2016-12-23T12:35:06.000Z | #include <fsl_port.h>
#include <fsl_flexio_uart.h>
#include <fsl_debug_console.h>
#include <math.h>
#include <arm_math.h>
#include "support.h"
#define WS2812B_CLOCK_FREQ 800000U
#define FLEXIO_SRC_CLOCK kCLOCK_CoreSysClk
#define FLEXIO_SRC_CLOCK_FRQ CLOCK_GetFreq(FLEXIO_SRC_CLOCK)
#define FLEXIO_CLOCK_DIVIDER (FLEXIO_SRC_CLOCK_FRQ/WS2812B_CLOCK_FREQ)
#define FLEXIO_SHIFT_BITS(n) ((((n) * 2 - 1) << 8) | ((FLEXIO_CLOCK_DIVIDER / 2) - 1))
#define FLEXIO_SHIFTER 0
#define FIO_CLOCK 0
#define FLEXIO_0_TIMER 1
#define FLEXIO_1_TIMER 2
#define FLEXIO_SHIFTER_PIN 2
#define FLEXIO_CLOCK_PIN 3
#define FLEXIO_DATA_PIN 20
#define LEDS 8
// calculate count from nanoseconds
// (!) can't use USEC_TO_COUNT with floats as the the value is cast to uint64_t)
#define NSEC_TO_COUNT(ns, frq) (USEC_TO_COUNT(ns, (frq))/1000U)
static void delay(volatile uint32_t nof) {
nof *= 10000;
while(nof!=0) {
__asm("NOP");
nof--;
}
}
void init_flexio() {
// signal 0 and 1 high/low counter values,
const uint32_t T0H = (uint32_t) NSEC_TO_COUNT(375, FLEXIO_SRC_CLOCK_FRQ) - 1;
const uint32_t T0L = (uint32_t) NSEC_TO_COUNT(875, FLEXIO_SRC_CLOCK_FRQ) - 1;
const uint32_t T1H = (uint32_t) NSEC_TO_COUNT(750, FLEXIO_SRC_CLOCK_FRQ) - 1;
const uint32_t T1L = (uint32_t) NSEC_TO_COUNT(500, FLEXIO_SRC_CLOCK_FRQ) - 1;
PRINTF("T0H=%d T0L=%d T1H=%d T1L=%d\r\n", T0H, T0L, T1H, T1L);
CLOCK_SetFlexio0Clock(FLEXIO_SRC_CLOCK);
CLOCK_EnableClock(kCLOCK_Flexio0);
FLEXIO_Reset(FLEXIO0);
// shifter
const flexio_shifter_config_t shifter_config = {
.inputSource = kFLEXIO_ShifterInputFromPin,
.shifterStop = kFLEXIO_ShifterStopBitDisable,
.shifterStart = kFLEXIO_ShifterStartBitDisabledLoadDataOnShift,
.timerSelect = FIO_CLOCK,
.timerPolarity = kFLEXIO_ShifterTimerPolarityOnPositive,
.pinConfig = kFLEXIO_PinConfigOutput,
.pinSelect = FLEXIO_SHIFTER_PIN,
.pinPolarity = kFLEXIO_PinActiveHigh,
.shifterMode = kFLEXIO_ShifterModeTransmit
};
FLEXIO_SetShifterConfig(FLEXIO0, FLEXIO_SHIFTER, &shifter_config);
// clock generator
const flexio_timer_config_t timer_clock_config = {
.timerCompare = FLEXIO_SHIFT_BITS(24),
.timerOutput = kFLEXIO_TimerOutputZeroNotAffectedByReset,
.timerDecrement = kFLEXIO_TimerDecSrcOnFlexIOClockShiftTimerOutput,
.timerReset = kFLEXIO_TimerResetNever,
.timerDisable = kFLEXIO_TimerDisableOnTimerCompare,
.timerEnable = kFLEXIO_TimerEnableOnTriggerHigh,
.timerStop = kFLEXIO_TimerStopBitDisabled,
.timerStart = kFLEXIO_TimerStartBitDisabled,
.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_SHIFTnSTAT(FLEXIO_SHIFTER),
.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveLow,
.triggerSource = kFLEXIO_TimerTriggerSourceInternal,
.pinConfig = kFLEXIO_PinConfigOutput,
.pinSelect = FLEXIO_CLOCK_PIN,
.pinPolarity = kFLEXIO_PinActiveHigh,
.timerMode = kFLEXIO_TimerModeDual8BitBaudBit,
};
FLEXIO_SetTimerConfig(FLEXIO0, FIO_CLOCK, &timer_clock_config);
// timer to generate the 0 wave form (short pulse), triggered by clock
const flexio_timer_config_t timer_t0_config = {
.timerCompare = (T0L << 8) | T0H,
.timerOutput = kFLEXIO_TimerOutputOneNotAffectedByReset,
.timerDecrement = kFLEXIO_TimerDecSrcOnFlexIOClockShiftTimerOutput,
.timerReset = kFLEXIO_TimerResetNever,
.timerDisable = kFLEXIO_TimerDisableOnTimerCompare,
.timerEnable = kFLEXIO_TimerEnableOnTriggerRisingEdge,
.timerStop = kFLEXIO_TimerStopBitDisabled,
.timerStart = kFLEXIO_TimerStartBitDisabled,
.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_PININPUT(FLEXIO_CLOCK_PIN),
.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveHigh,
.triggerSource = kFLEXIO_TimerTriggerSourceInternal,
.pinConfig = kFLEXIO_PinConfigOutput,
.pinSelect = FLEXIO_DATA_PIN,
.pinPolarity = kFLEXIO_PinActiveHigh,
.timerMode = kFLEXIO_TimerModeDual8BitPWM,
};
FLEXIO_SetTimerConfig(FLEXIO0, FLEXIO_0_TIMER, &timer_t0_config);
// timer to generate the 1 wave form (long pulse), triggered by shifter
const flexio_timer_config_t timer_t1_config = {
.timerCompare = (T1L << 8) | T1H,
.timerOutput = kFLEXIO_TimerOutputOneNotAffectedByReset,
.timerDecrement = kFLEXIO_TimerDecSrcOnFlexIOClockShiftTimerOutput,
.timerReset = kFLEXIO_TimerResetNever,
.timerDisable = kFLEXIO_TimerDisableOnTriggerFallingEdge,
.timerEnable = kFLEXIO_TimerEnableOnTriggerRisingEdge,
.timerStop = kFLEXIO_TimerStopBitDisabled,
.timerStart = kFLEXIO_TimerStartBitDisabled,
.triggerSelect = FLEXIO_TIMER_TRIGGER_SEL_PININPUT(FLEXIO_SHIFTER_PIN),
.triggerPolarity = kFLEXIO_TimerTriggerPolarityActiveHigh,
.triggerSource = kFLEXIO_TimerTriggerSourceInternal,
.pinConfig = kFLEXIO_PinConfigOutput,
.pinSelect = FLEXIO_DATA_PIN,
.pinPolarity = kFLEXIO_PinActiveHigh,
.timerMode = kFLEXIO_TimerModeDual8BitPWM,
};
FLEXIO_SetTimerConfig(FLEXIO0, FLEXIO_1_TIMER, &timer_t1_config);
FLEXIO_Enable(FLEXIO0, true);
//NVIC_EnableIRQ(FLEXIO0_IRQn);
}
void transmit(uint32_t *leds, int n) {
FLEXIO0->TIMCMP[FIO_CLOCK] = FLEXIO_SHIFT_BITS(24);
while (n--) {
while (!(FLEXIO_GetShifterStatusFlags(FLEXIO0) & (1U << FLEXIO_SHIFTER))) {}
// if this is the last junk of data, shift a single bit more than necessary to drive signal low
if (!n) FLEXIO0->TIMCMP[FIO_CLOCK] = FLEXIO_SHIFT_BITS(25);
FLEXIO0->TIMSTAT |= FLEXIO_TIMSTAT_TSF(1U << FIO_CLOCK);
// we use the bit swapped shift buffer to send data
FLEXIO0->SHIFTBUFBIS[0] = (*leds++) << 8;
}
}
void test_rgb_flexio(void) {
#if TEST_RGB_FXIO
if (!yesno("RGB (FlexIO) test?")) return;
CLOCK_EnableClock(kCLOCK_PortA);
CLOCK_EnableClock(kCLOCK_PortB);
PORT_SetPinMux(PORTB, 2U, kPORT_MuxAlt7);
PORT_SetPinMux(PORTB, 3U, kPORT_MuxAlt7);
PORT_SetPinMux(PORTB, 10U, kPORT_MuxAlt7);
PORT_SetPinMux(PORTA, 14U, kPORT_MuxAlt5);
init_flexio();
// colors off
uint32_t colors[LEDS] = {0, 0, 0, 0, 0, 0, 0, 0};
transmit(colors, LEDS);
delay(10);
transmit(colors, LEDS);
for(int k = 0; k < 10; k++) {
for (int i = 0; i < LEDS; i++) {
memset(colors, 0, sizeof(colors));
colors[i] = 0x005500;
transmit(colors, LEDS);
delay(40);
}
for (int i = LEDS - 1; i >= 0; i--) {
memset(colors, 0, sizeof(colors));
colors[i] = 0x005500;
transmit(colors, LEDS);
delay(40);
}
delay(1);
}
delay(1000);
// do some rainbow coloring...
int phase = 0;
int length = 8;
int center = 128, width = 127;
float frequency = PI * 2 / length;
while (true) {
for (int i = 0; i < length; ++i) {
for(int l = 0; l < 8; l++) {
uint8_t r = (uint8_t) (sin(frequency * (i+l) + 0 + phase) * width + center);
uint8_t g = (uint8_t) (sin(frequency * (i+l) + 2 + phase) * width + center);
uint8_t b = (uint8_t) (sin(frequency * (i+l) + 4 + phase) * width + center);
colors[l] = g << 16 | r << 8 | b;
}
transmit(colors, 8);
delay(100);
}
}
#endif
}
| 35.044554 | 99 | 0.720582 |
b4bfd75dab3804fd58d18dcabaec8c3b4d6b0c5c | 28,254 | c | C | dev/interrupt/gic_v3/gic_v3.c | wtliang110/lk_hv | fbbbb280114c44bf321b8f02301a84e3c469d8a2 | [
"MIT"
] | 4 | 2022-02-24T06:16:42.000Z | 2022-02-24T23:49:29.000Z | dev/interrupt/gic_v3/gic_v3.c | wtliang110/lk_hv | fbbbb280114c44bf321b8f02301a84e3c469d8a2 | [
"MIT"
] | null | null | null | dev/interrupt/gic_v3/gic_v3.c | wtliang110/lk_hv | fbbbb280114c44bf321b8f02301a84e3c469d8a2 | [
"MIT"
] | null | null | null | /*
* develop by pwang for gicv3 for none secure
*/
#include <assert.h>
#include <lk/bits.h>
#include <lk/err.h>
#include <sys/types.h>
#include <lk/debug.h>
#include <dev/interrupt/arm_gic.h>
#include <lk/reg.h>
#include <kernel/thread.h>
#include <kernel/debug.h>
#include <lk/init.h>
#include <platform/interrupts.h>
#include <arch/ops.h>
#include <platform/gic.h>
#include <lk/trace.h>
#include <vgic_gic.h>
#if WITH_LIB_SM
#include <lib/sm.h>
#include <lib/sm/sm_err.h>
#endif
#include <vgic_gic.h>
#include <hv_vgic.h>
#define LOCAL_TRACE 0
#if ARCH_ARM
#include <arch/arm.h>
#define iframe arm_iframe
#define IFRAME_PC(frame) ((frame)->pc)
#endif
#if ARCH_ARM64
#include <arch/arm64.h>
#define iframe arm64_iframe_short
#define IFRAME_PC(frame) ((frame)->elr)
#endif
#define GIC_MAX_PER_CPU_INT 32
/* distributor regs */
#define GICD_CTLR (GICD_OFFSET + 0x000)
#define GICD_TYPER (GICD_OFFSET + 0x004)
#define GICD_IIDR (GICD_OFFSET + 0x008)
#define GICD_TYPER2 (GICD_OFFSET + 0x00C)
#define GICD_STATUSR (GICD_OFFSET + 0x010)
#define GICD_SETSPI_NSR (GICD_OFFSET + 0x040)
#define GICD_CLRSPI_NSR (GICD_OFFSET + 0x048)
#define GICD_SETSPI_SR (GICD_OFFSET + 0x050)
#define GICD_CLRSPI_SR (GICD_OFFSET + 0x058)
#define GICD_IGROUPR(n) (GICD_OFFSET + 0x080 + (n) * 4)
#define GICD_ISENABLER(n) (GICD_OFFSET + 0x100 + (n) * 4)
#define GICD_ICENABLER(n) (GICD_OFFSET + 0x180 + (n) * 4)
#define GICD_ISPENDR(n) (GICD_OFFSET + 0x200 + (n) * 4)
#define GICD_ICPENDR(n) (GICD_OFFSET + 0x280 + (n) * 4)
#define GICD_ISACTIVER(n) (GICD_OFFSET + 0x300 + (n) * 4)
#define GICD_ICACTIVER(n) (GICD_OFFSET + 0x380 + (n) * 4)
#define GICD_IPRIORITYR(n) (GICD_OFFSET + 0x400 + (n) * 4)
#define GICD_ITARGETSR(n) (GICD_OFFSET + 0x800 + (n) * 4)
#define GICD_ICFGR(n) (GICD_OFFSET + 0xc00 + (n) * 4)
#define GICD_NSACR(n) (GICD_OFFSET + 0xe00 + (n) * 4)
#define GICD_SGIR (GICD_OFFSET + 0xf00)
#define GICD_CPENDSGIR(n) (GICD_OFFSET + 0xf10 + (n) * 4)
#define GICD_SPENDSGIR(n) (GICD_OFFSET + 0xf20 + (n) * 4)
#define GICD_IGROUPR_E(n) (GICD_OFFSET + 0x1000 + (n) * 4)
#define GICD_ISENABLER_E(n) (GICD_OFFSET + 0x1200 + (n) * 4)
#define GICD_ICENABLER_E(n) (GICD_OFFSET + 0x1400 + (n) * 4)
#define GICD_ISPENDR_E(n) (GICD_OFFSET + 0x1600 + (n) * 4)
#define GICD_ICPENDR_E(n) (GICD_OFFSET + 0x1800 + (n) * 4)
#define GICD_ISACTIVER_E(n) (GICD_OFFSET + 0x1a00 + (n) * 4)
#define GICD_ICACTIVER_E(n) (GICD_OFFSET + 0x1c00 + (n) * 4)
#define GICD_IPRIORITYR_E(n) (GICD_OFFSET + 0x2000 + (n) * 4)
#define GICD_ICFGR_E(n) (GICD_OFFSET + 0x3000 + (n) * 4)
#define GICD_IGRPMODR_E(n) (GICD_OFFSET + 0x3400 + (n) * 4)
#define GICD_NSACR_E(n) (GICD_OFFSET + 0x3600 + (n) * 4)
#define GICD_IROUTER(n) (GICD_OFFSET + 0x6100 + (n) * 8)
#define GICD_IROUTER_E(n) (GICD_OFFSET + 0x8000 + (n) * 8)
/* redistributor regs */
#define GICR_OFFSET(cpu_id) (GICR_BASE + GICR_FRAME * 2 * cpu_id)
#define GICR_CTLR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0000)
#define GICR_IIDR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0004)
#define GICR_TYPER(cpu_id) (GICR_OFFSET(cpu_id) + 0x0008)
#define GICR_STATUSR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0010)
#define GICR_WAKER(cpu_id) (GICR_OFFSET(cpu_id) + 0x0014)
#define GICR_MPAMIDR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0018)
#define GICR_PARTIDR(cpu_id) (GICR_OFFSET(cpu_id) + 0x001c)
#define GICR_SETLPIR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0040)
#define GICR_CLRLPIR(cpu_id) (GICR_OFFSET(cpu_id) + 0x0048)
#define GICR_PROPBASER(cpu_id) (GICR_OFFSET(cpu_id) + 0x0070)
#define GICR_PENDBASER(cpu_id) (GICR_OFFSET(cpu_id) + 0x0078)
#define GICR_INVLPIR(cpu_id) (GICR_OFFSET(cpu_id) + 0x00a0)
#define GICR_INVALLR(cpu_id) (GICR_OFFSET(cpu_id) + 0x00b0)
#define GICR_SYNCR(cpu_id) (GICR_OFFSET(cpu_id) + 0x00c0)
#if 0
/* this is version 4, currently is version 3 */
#define GICR_VPROPBASER (VLPI_OFFSET + 0x0070)
#define GICR_VPENDBASER (VLPI_OFFSET + 0x0078)
#define GICR_VSGIR (VLPI_OFFSET + 0x0080)
#define GICR_VSGIPENDR (VLPI_OFFSET + 0x0088)
#endif
#define SGI_OFFSET(cpu_id) GICR_OFFSET(cpu_id) + GICR_FRAME
#define GICR_IGROUPR0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0080)
#define GICR_IGROUPR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0084 + (n) * 4)
#define GICR_ISENABLER0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0100)
#define GICR_ISENABLER_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0104 + (n) * 4)
#define GICR_ICENABLER_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0184 + (n) * 4)
#define GICR_ICENABLER0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0180)
#define GICR_ISPENDR0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0200)
#define GICR_ISPENDR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0204 + (n) * 4)
#define GICR_ICPENDR0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0280)
#define GICR_ICPENDR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0284 + (n) * 4)
#define GICR_ISACTIVER0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0300)
#define GICR_ISACTIVER_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0304 + (n) * 4)
#define GICR_ICACTIVER0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0380)
#define GICR_ICACTIVER_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0384 + (n) * 4)
#define GICR_IPRIORITYR(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0400 + (n) * 4)
#define GICR_IPRIORITYR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0420 + (n) * 4)
#define GICR_ICFGR0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0c00)
#define GICR_ICFGR1(cpu_id) (SGI_OFFSET(cpu_id) + 0x0c04)
#define GICR_ICFGR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0C08 + (n) * 4)
#define GICR_IGRPMODR0(cpu_id) (SGI_OFFSET(cpu_id) + 0x0D00 )
#define GICR_IGRPMODR_E(cpu_id, n) (SGI_OFFSET(cpu_id) + 0x0D04 + (n) + 4)
#define GICR_NSACR(cpu_id) (SGI_OFFSET(cpu_id) + 0x0E00)
#define MAX_PPI_VEC 31
#define MAX_SGI_VEC 15
#define MAX_SPI_VEC 1019
/* main cpu regs */
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
#define GIC_REG_COUNT(bit_per_reg) DIV_ROUND_UP(MAX_INT, (bit_per_reg))
#define DEFINE_GIC_SHADOW_REG(name, bit_per_reg, init_val, init_from) \
uint32_t (name)[GIC_REG_COUNT(bit_per_reg)] = { \
[(init_from / bit_per_reg) ... \
(GIC_REG_COUNT(bit_per_reg) - 1)] = (init_val) \
}
#if WITH_LIB_SM
static DEFINE_GIC_SHADOW_REG(gicd_igroupr, 32, ~0U, 0);
#endif
static DEFINE_GIC_SHADOW_REG(gicd_itargetsr, 4, 0x01010101, 32);
#define GICR_WAKER_PS (uint32_t) (1 << 1) /* process sleep */
#define GICR_WAKER_CAS (uint32_t) (1 << 2)
#define GICC_SRE_SRE (uint64_t) (1 << 0) /* enable system register */
#define GICC_SRE_DFB (uint64_t) (1 << 1) /* disable fiq bypass */
#define GICC_SRE_DIB (uint64_t) (1 << 2) /* disable irq bypass */
#define GICC_SRE_ENABLE (uint64_t) (1 << 3) /* enable lower exception access GICC_SRE_EL2 */
#define GICC_SRE_DEFAULT GICC_SRE_SRE|GICC_SRE_DFB|GICC_SRE_DIB|GICC_SRE_ENABLE
#define GICC_PMR_DEFAULT (uint64_t)(0XFF) /* default value, the minium one */
#define GICC_BPR_DEFAULT 0
#define GICC_IGRPEN1_ENABLE (uint64_t)(1)
#define ICC_PMR_EL1 S3_0_C4_C6_0
#define ICC_DIR_EL1 S3_0_C12_C11_1
#define ICC_SGI1R_EL1 S3_0_C12_C11_5
#define ICC_EOIR1_EL1 S3_0_C12_C12_1
#define ICC_IAR1_EL1 S3_0_C12_C12_0
#define ICC_BPR1_EL1 S3_0_C12_C12_3
#define ICC_CTLR_EL1 S3_0_C12_C12_4
#define ICC_SRE_EL1 S3_0_C12_C12_5
#define ICC_IGRPEN1_EL1 S3_0_C12_C12_7
#define ICH_VSEIR_EL2 S3_4_C12_C9_4
#define ICC_SRE_EL2 S3_4_C12_C9_5
#define ICH_HCR_EL2 S3_4_C12_C11_0
#define ICH_VTR_EL2 S3_4_C12_C11_1
#define ICH_MISR_EL2 S3_4_C12_C11_2
#define ICH_EISR_EL2 S3_4_C12_C11_3
#define ICH_ELSR_EL2 S3_4_C12_C11_5
#define ICH_VMCR_EL2 S3_4_C12_C11_7
#define ICC_RPR_EL1 S3_0_C12_C11_3
#define ICC_CTLR_EOImode (uint64_t)(1 << 1)
static spin_lock_t gicd_lock;
#if WITH_LIB_SM
#define GICD_LOCK_FLAGS SPIN_LOCK_FLAG_IRQ_FIQ
#else
#define GICD_LOCK_FLAGS SPIN_LOCK_FLAG_INTERRUPTS
#endif
static uint64_t cpu_id_map[SMP_MAX_CPUS] = {0};
#define gic_lock(state) spin_lock_save(&gicd_lock, &state, GICD_LOCK_FLAGS);
#define gic_unlock(state) spin_unlock_restore(&gicd_lock, state, GICD_LOCK_FLAGS);
struct int_handler_struct {
int_handler handler;
void *arg;
};
static struct int_handler_struct int_handler_table_per_cpu[GIC_MAX_PER_CPU_INT][SMP_MAX_CPUS];
static struct int_handler_struct int_handler_table_shared[MAX_INT-GIC_MAX_PER_CPU_INT];
uint32_t read_gicd_iidr(void)
{
return GICREG(GICD_IIDR);
}
uint32_t read_gicr_iidr(void)
{
return GICREG(GICR_IIDR(arch_curr_cpu_num()));
}
static struct int_handler_struct *get_int_handler(unsigned int vector, uint cpu)
{
struct int_handler_struct *handler = NULL;
if (vector < GIC_MAX_PER_CPU_INT)
handler = &int_handler_table_per_cpu[vector][cpu];
else
handler = &int_handler_table_shared[vector - GIC_MAX_PER_CPU_INT];
return handler;
}
static bool arm_gic_interrupt_change_allowed(int irq)
{
return true;
}
void gic_set_enable(uint vector, bool enable)
{
int cpu_id = arch_curr_cpu_num();
int reg = vector / 32;
uint32_t mask = 1ULL << (vector % 32);
uint64_t reg_ise = 0;
uint64_t reg_ice = 0;
if (vector > MAX_PPI_VEC) {
reg_ise = GICD_ISENABLER(reg);
reg_ice = GICD_ICENABLER(reg);
} else {
reg_ise = GICR_ISENABLER0(cpu_id);
reg_ice = GICR_ICENABLER0(cpu_id);
}
/* written 0 has no effect */
if (enable) {
LTRACEF("gic set enable %u enable %d\n", vector, enable);
LTRACEF("set 0x%llx mask %x reg id %d\n", reg_ise, mask, reg);
GICREG(reg_ise) = mask;
} else {
GICREG(reg_ice) = mask;
while(GICREG(GICD_CTLR) & GICD_CTRL_RWP);
}
}
void gic_trigger_interrupt(int vector)
{
int reg = vector / 32;
uint32_t mask = 1ULL << (vector % 32);
int cpu_id = arch_curr_cpu_num();
uint64_t reg_isp;
if (vector > MAX_PPI_VEC)
reg_isp = GICD_ISPENDR(reg);
else
reg_isp = GICR_ISPENDR0(cpu_id);
printf("will set interrupt %d\n", vector);
/* written 0 has no effect */
GICREG(reg_isp) = mask;
}
/* clear pending */
void gic_clear_pending(int vector)
{
int reg = vector >> 5;
uint32_t mask = 1ULL << (vector & 0x1f);
int cpu_id = arch_curr_cpu_num();
uint64_t reg_isp;
if (vector > MAX_PPI_VEC)
reg_isp = GICD_ICPENDR(reg);
else
reg_isp = GICR_ICPENDR0(cpu_id);
//printf("will clear interrupt %d\n", vector);
/* written 0 has no effect */
GICREG(reg_isp) = mask;
}
/* clear pending */
void gic_set_isactiver(int vector)
{
int reg = vector / 32;
uint32_t mask = 1ULL << (vector % 32);
int cpu_id = arch_curr_cpu_num();
uint64_t reg_isp;
if (vector > MAX_PPI_VEC)
reg_isp = GICD_ISACTIVER(reg);
else
reg_isp = GICR_ISACTIVER0(cpu_id);
//printf("set isactiver for %d\n", vector);
/* written 0 has no effect */
GICREG(reg_isp) = mask;
}
void gic_set_icactiver(int vector)
{
int reg = vector >> 5;
uint32_t mask = 1ULL << (vector & 0x1f);
int cpu_id = arch_curr_cpu_num();
uint64_t reg_isp;
if (vector > MAX_PPI_VEC)
reg_isp = GICD_ICACTIVER(reg);
else
reg_isp = GICR_ICACTIVER0(cpu_id);
//printf("set isactiver for %d\n", vector);
/* written 0 has no effect */
GICREG(reg_isp) = mask;
}
static void gic_set_priority(uint32_t vector,
unsigned char priority, int cpu_id)
{
uint64_t ipriority;
if (vector < MAX_PPI_VEC)
ipriority = GICR_IPRIORITYR(cpu_id, 0) + vector;
else
ipriority = GICD_IPRIORITYR(0) + vector;
LTRACEF("gic set priority irq %u priority %d cpu_id %d\n",
vector, priority, cpu_id);
LTRACEF("ipriority %llx\n", ipriority);
GICREG_BYTE(ipriority) = priority;
}
/* configure a cpu type
* @type :
* 0 : level
* 1 : edge */
void gic_set_cfg(uint32_t vector, int is_edge, int cpu_id)
{
uint64_t icfgr = 0;
uint32_t icfgr_val = 0;
int icfg_n, icfg_off;
spin_lock_saved_state_t state;
LTRACEF("set cfg irq %u is_edge %d cpu_id %d\n",
vector, is_edge, cpu_id);
icfg_n = vector >> 4;
icfg_off = vector & 0xf;
//printf("icfg_off is %d vector %u is_edge %d\n",
// icfg_off, vector, is_edge);
if (vector <= MAX_PPI_VEC)
if (icfg_n == 0)
icfgr = GICR_ICFGR0(cpu_id);
else
icfgr = GICR_ICFGR1(cpu_id);
else
icfgr = GICD_ICFGR(icfg_n);
gic_lock(state);
icfgr_val = GICREG(icfgr);
if (is_edge)
icfgr_val = icfgr_val | (1 << (2 * icfg_off + 1));
else
icfgr_val = icfgr_val & (~(1 << (2 * icfg_off + 1)));
GICREG(icfgr) = icfgr_val;
gic_unlock(state);
LTRACEF("set cfg value %llx to %x\n", icfgr, icfgr_val);
}
/* set affinity of a vector
* @is_cluster is 1, affinity is the cluster,
* which is cpu_id in
* must ensure vector is SPI */
void gic_set_affinity(uint32_t vector, int cpu_id, int is_cluster)
{
/* default to all cpu cpus current cluster */
uint64_t cpu_map = cpu_id_map[cpu_id];
uint64_t iroute = 0;
LTRACEF("set cfg irq %u is_cluster %d cpu_id %d\n",
vector, is_cluster, cpu_id);
if (is_cluster)
iroute = iroute | 1 << 31;
else
iroute = cpu_map;
GICREG_64(GICD_IROUTER(vector)) = iroute;
LTRACEF("set affity %llx to %llx\n", iroute, GICD_IROUTER(vector));
}
/* init and interrupt whose vector is @vector
* default group is ns-group1
* target : default one is to all of cpus */
int gic_set_irq(uint32_t vector, int priority,
int is_edge, int enable,
int_handler handler, void *arg)
{
struct int_handler_struct *h;
int cpu_id = arch_curr_cpu_num();
spin_lock_saved_state_t state;
if (vector >= MAX_INT)
panic("gic_set_irq: vector out of range %d\n", vector);
gic_set_cfg(vector, is_edge, cpu_id);
gic_set_priority(vector, priority, cpu_id);
gic_set_enable(vector, 1);
if (vector > MAX_PPI_VEC)
gic_set_affinity(vector, cpu_id, 0);
spin_lock_save(&gicd_lock, &state, GICD_LOCK_FLAGS);
if (arm_gic_interrupt_change_allowed(vector)) {
LTRACEF("set callback functions\n");
h = get_int_handler(vector, cpu_id);
h->handler = handler;
h->arg = arg;
}
spin_unlock_restore(&gicd_lock, state, GICD_LOCK_FLAGS);
return 0;
}
/* api : interface */
void register_int_handler(unsigned int vector, int_handler handler, void *arg)
{
int priority;
if (vector >= MAX_INT)
panic("register_int_handler: vector out of range %d\n", vector);
priority = GIC_PRI_IRQ;
/* TODO IPI priority set */
gic_set_irq(vector, priority, 1, 1, handler, arg);
return;
}
/* read ispendr for irq @vector */
int gic_read_ispendr(unsigned int vector)
{
int reg_id = vector >> 5;
int reg_off = vector & 0x1f;
unsigned int ispendr = 0;
unsigned int cpu_id = arch_curr_cpu_num();
if (vector > MAX_PPI_VEC)
ispendr = GICREG(GICD_ISPENDR(reg_id));
else
ispendr = GICREG(GICR_ISPENDR0(cpu_id));
return ispendr & (1 << reg_off);
}
/* init cpu map */
static void init_cpu_map(uint32_t cpu_id)
{
uint64_t mpidr;
if (cpu_id >= SMP_MAX_CPUS)
return;
mpidr = ARM64_READ_SYSREG(MPIDR_EL1);
mpidr = mpidr & 0xff00ffffff;
cpu_id_map[cpu_id] = mpidr;
}
/* init percpu */
/* about the pe init, please refer */
static void arm_gic_init_percpu(uint32_t level)
{
uint32_t cpu_id = 0;
uint32_t waker = 0;
uint64_t val = 0;
int i = 0;
cpu_id = arch_curr_cpu_num();
/* redistributor init */
printf("waker addr for cpu %u is %llx\n", cpu_id, GICR_WAKER(cpu_id));
waker = GICREG(GICR_WAKER(cpu_id));
GICREG(GICR_WAKER(cpu_id)) = (waker & ~GICR_WAKER_PS);
/* cpu interface init first */
val = ARM64_READ_SYSREG(ICC_SRE_EL2);
val = val|GICC_SRE_SRE;
ARM64_WRITE_SYSREG(ICC_SRE_EL2, val);
ISB;
/* set priority*/
ARM64_WRITE_SYSREG(ICC_PMR_EL1, GICC_PMR_DEFAULT);
/* use all of bit */
ARM64_WRITE_SYSREG(ICC_BPR1_EL1, GICC_BPR_DEFAULT);
/* set EOI mode hypervisor need to set this */
val = ARM64_READ_SYSREG(ICC_CTLR_EL1);
val = val | ICC_CTLR_EOImode;
ARM64_WRITE_SYSREG(ICC_CTLR_EL1, val);
/* disable all of ppi and sigs */
GICREG(GICR_ICENABLER0(cpu_id)) = (uint32_t)(-1);
GICREG(GICR_ICACTIVER0(cpu_id)) = (uint32_t)(-1);
/* ppi or spi should be all ns-group 1 */
GICREG(GICR_IGROUPR0(cpu_id)) = (uint32_t)(-1);
/* SGI or PPI set interrupt */
for (i = 0; i <= MAX_SGI_VEC; i++) {
gic_set_cfg(i, 1, cpu_id);
gic_set_priority(i, GIC_PRI_IPI, cpu_id);
gic_set_enable(i, 1);
}
/* Enable signaling of each interrupt group */
ARM64_WRITE_SYSREG(ICC_IGRPEN1_EL1, GICC_IGRPEN1_ENABLE);
init_cpu_map(cpu_id);
ISB;
/* vgic init */
vgic_gic_init();
return;
}
LK_INIT_HOOK_FLAGS(arm_gic_init_percpu,
arm_gic_init_percpu,
LK_INIT_LEVEL_PLATFORM_EARLY, LK_INIT_FLAG_SECONDARY_CPUS);
static int arm_gic_max_cpu(void)
{
return (GICREG(GICD_TYPER) >> 5) & 0x7;
}
static uint32_t get_max_ints(void)
{
int max_ints;
uint32_t typer;
typer = GICREG(GICD_TYPER);
max_ints = (typer & 0x1f);
//max_ints = 32 * (max_ints + 1) -1;
return max_ints;
}
uint32_t get_max_spi(void)
{
uint32_t max_ints;
max_ints = get_max_ints();
max_ints = 32 * (max_ints + 1) -1;
return max_ints;
}
/* gic init */
void arm_gic_init(void)
{
uint32_t i;
uint32_t max_ints;
uint32_t reg_num;
max_ints = get_max_ints();
reg_num = max_ints + 1;
/* disable all of shared interrupt */
for (i = 0; i < reg_num; i++)
GICREG(GICD_ICENABLER(i)) = (uint32_t)(-1);
while(GICREG(GICD_CTLR) & GICD_CTRL_RWP) ;
/* SPI should be all none-secure group1 */
for (i = 0; i < reg_num; i++)
GICREG(GICD_IGROUPR(i)) = (uint32_t)(-1);
/* SPI should target to this primary cpu ????? */
GICREG(GICD_CTLR) = (GICD_CTRL_ARE_NS|GICD_CTRL_EnableGrp1NS);
while(GICREG(GICD_CTLR) & GICD_CTRL_RWP) ;
arm_gic_init_percpu(0);
return;
}
#define MPIDR_AFF0_MASK ((uint64_t)(0xff))
/* each cluster should less than 16 cpus */
uint16_t calc_tglist(uint32_t *cpu_mask, uint64_t cluster)
{
uint32_t i = 0;
uint16_t tglist = 0;
uint64_t cluster_id;
uint32_t cpu;
for (i = 0; i < sizeof(*cpu_mask); i++) {
if (!(*cpu_mask & (1 << i)))
continue;
cluster_id = cpu_id_map[i] & (~MPIDR_AFF0_MASK);
cpu = cpu_id_map[i] & MPIDR_AFF0_MASK;
if (cluster_id != cluster)
continue;
tglist = tglist | (1 << cpu);
*cpu_mask = *cpu_mask & (~(1 << i));
}
return tglist;
}
/* api interface : send sgi
* maybe does not need flags, only send ns-group1 sgi,
* so the max cpu is 32 because of cpu_mask size */
/* NSATT */
status_t arm_gic_sgi(u_int irq, u_int flags, u_int cpu_mask)
{
/* ICC_SGI1R_EL1 */
uint32_t i = 0;
uint64_t cluster;
uint16_t tglist = 0;
uint64_t val;
for (i = 0; i < sizeof(cpu_mask); i++) {
if (!(cpu_mask & (1 << i)))
continue;
cluster = cpu_id_map[i] & (~MPIDR_AFF0_MASK);
tglist = calc_tglist(&cpu_mask, cluster);
val = (cluster & 0xff00000000) << (48 - 32)|
(cluster & 0x0000ff0000) << (32 - 16)|
(cluster & 0x000000ff00) << (16 - 8)|
irq << 24|tglist;
ARM64_WRITE_SYSREG(ICC_SGI1R_EL1, val);
}
return NO_ERROR;
}
status_t mask_interrupt(unsigned int vector)
{
if (vector >= MAX_INT)
return ERR_INVALID_ARGS;
if (arm_gic_interrupt_change_allowed(vector))
gic_set_enable(vector, false);
return NO_ERROR;
}
status_t unmask_interrupt(unsigned int vector)
{
if (vector >= MAX_INT)
return ERR_INVALID_ARGS;
if (arm_gic_interrupt_change_allowed(vector))
gic_set_enable(vector, true);
return NO_ERROR;
}
static enum handler_return __platform_irq(struct iframe *frame)
{
// get the current vector
uint32_t iar = ARM64_READ_SYSREG(ICC_IAR1_EL1);
unsigned int vector = iar & 0x3ff;
uint32_t cpu = arch_curr_cpu_num();
struct int_handler_struct *handler = NULL;
if (vector >= 0x3fe) {
// spurious
return INT_NO_RESCHEDULE;
}
LTRACEF("platform irq\n");
THREAD_STATS_INC(interrupts);
KEVLOG_IRQ_ENTER(vector);
cpu = arch_curr_cpu_num();
LTRACEF_LEVEL(2, "iar 0x%x cpu %u currthread %p vector %d pc 0x%lx\n", iar, cpu,
get_current_thread(), vector, (uintptr_t)IFRAME_PC(frame));
// deliver the interrupt
enum handler_return ret;
ret = INT_NO_RESCHEDULE;
handler = get_int_handler(vector, cpu);
if (handler->handler) {
void *arg = handler->arg;
/* virtual interrupt routing needs irq as interrupt */
if (handler->arg == (void *)INT_IRQ)
arg = (void *)(long)vector;
ret = handler->handler(arg);
}
/* 2 steps interrupt deactive */
ARM64_WRITE_SYSREG(ICC_EOIR1_EL1, iar); /* first lower the priority */
/* hypervisor interrupt deactive them here, guest irq will be deactive by eoi from guest */
if (handler->arg != (void *)INT_IRQ)
ARM64_WRITE_SYSREG(ICC_DIR_EL1, iar);
LTRACEF_LEVEL(2, "cpu %u exit %d\n", cpu, ret);
KEVLOG_IRQ_EXIT(vector);
return ret;
}
enum handler_return platform_irq(struct iframe *frame)
{
hv_virq_from_lrs();
return __platform_irq(frame);
}
void platform_fiq(struct iframe *frame)
{
PANIC_UNIMPLEMENTED;
}
/* interrupt debug related code */
#include <lib/console.h>
int inter_enable(int argc, const console_cmd_args *argv)
{
int vector = argv[1].i;
int enable = argv[2].i;
printf("vector %d %d\n", vector, enable);
gic_set_enable(vector, enable);
return 0;
}
int inter_triger(int argc, const console_cmd_args *argv)
{
int vector = argv[1].i;
printf("enable vector %d\n", vector);
gic_set_enable(vector, 1);
printf("triger vector %d\n", vector);
gic_trigger_interrupt(vector);
return 0;
}
/* interrupts tests */
#define GIC_TEST_IRQ 100
enum handler_return test_irq_handler(void *arg)
{
printf("<<<<<<<<<<<<<<<<test irq is coming>>>>>>>>>>>>>>>\n");
return 0;
}
enum handler_return test_sig_handler(void *arg)
{
printf("<<<<<<<<<<<<<<<<test sgi is coming>>>>>>>>>>>>>>>>>\n");
return 0;
}
/* dump the status */
void gic_dump_status(uint32_t vector, int cpu_id)
{
int reg_id;
int reg_id1;
printf("information related to %u cpu _id %d:\n", vector, cpu_id);
printf("GICD_CTLR : 0x%x\n", GICREG(GICD_CTLR));
printf("GICR_WAKER : 0x%x\n", GICREG(GICR_WAKER(cpu_id)));
printf("ICC_SRE_EL2 : 0x%llx\n", ARM64_READ_SYSREG(ICC_SRE_EL2));
printf("ICC_PMR_EL1 : 0x%llx\n", ARM64_READ_SYSREG(ICC_PMR_EL1));
printf("ICC_BPR1_EL1 : 0x%llx\n", ARM64_READ_SYSREG(ICC_BPR1_EL1));
printf("ICC_RPR1_EL1: %llx\n", ARM64_READ_SYSREG(ICC_RPR_EL1));
printf("ICC_IGRPEN1_EL1: %llx\n", ARM64_READ_SYSREG(ICC_IGRPEN1_EL1));
reg_id = vector >> 5;
reg_id1 = vector >> 4;
if (vector > MAX_PPI_VEC) {
printf("GICD_ISENABLER(%d): %llx value %x\n", reg_id, GICD_ISENABLER(reg_id), GICREG(GICD_ISENABLER(reg_id)));
printf("GICD_ICENABLER(%d): %llx value %x\n", reg_id, GICD_ICENABLER(reg_id), GICREG(GICD_ICENABLER(reg_id)));
printf("GICD_IPRIORITYR: %llx value %x\n", GICD_IPRIORITYR(0) + vector,
GICREG_BYTE(GICD_IPRIORITYR(0) + vector));
printf("GICD_IROUTE(%d): %llx\n", vector, GICREG_64(GICD_IROUTER(vector)));
printf("GICD_IGROUPR(%d): %x\n", reg_id, GICREG(GICD_IGROUPR(reg_id)));
printf("GICD_ISACTIVER(%d): %x\n", reg_id, GICREG(GICD_ISACTIVER(reg_id)));
printf("GICD_ISPENDR(%d): %x\n", reg_id, GICREG(GICD_ISPENDR(reg_id)));
printf("GICD_ICFGR(%d): %x\n", reg_id1, GICREG(GICD_ICFGR(reg_id1)));
} else {
printf("GICR_ISENABLER0: %llx value %x\n", GICR_ISENABLER0(cpu_id), GICREG(GICR_ISENABLER0(cpu_id)));
printf("GICR_ICENABLER0: %llx value %x\n", GICR_ICENABLER0(cpu_id), GICREG(GICR_ICENABLER0(cpu_id)));
printf("GICR_IPRIORITYR: %llx value %x\n", GICR_IPRIORITYR(cpu_id, 0) + vector,
GICREG_BYTE(GICR_IPRIORITYR(cpu_id, 0) + vector));
printf("GICR_IGROUPR0: %x\n", GICREG(GICR_IGROUPR0(cpu_id)));
printf("GICR_ISACTIVER0: %x\n", GICREG(GICR_ISACTIVER0(cpu_id)));
printf("GICR_ISPENDR0: %x\n", GICREG(GICR_ISPENDR0(cpu_id)));
printf("GICR_ICFGR(%d): %x\n", 0, GICREG(GICR_ICFGR0(cpu_id)));
printf("GICR_ICFGR(%d): %x\n", 1, GICREG(GICR_ICFGR1(cpu_id)));
}
//printf("iar is %llx\n", ARM64_READ_SYSREG(ICC_IAR1_EL1));
}
void gic_ints_test(void)
{
printf("-----------------------------gic ints test start--------------------------\n");
register_int_handler(GIC_TEST_IRQ, test_irq_handler, NULL);
gic_trigger_interrupt(GIC_TEST_IRQ);
gic_dump_status(GIC_TEST_IRQ, arch_curr_cpu_num());
printf("-----------------------------gic ints test end---------------------------\n");
}
//LK_INIT_HOOK(gic_ints_test, &gic_ints_test, LK_INIT_LEVEL_KERNEL);
int gic_irq_test(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
printf("-----------------------------gic ints test start--------------------------\n");
printf("irq is %d\n", irq);
register_int_handler(irq, test_sig_handler, NULL);
if (irq < MAX_SGI_VEC)
arm_gic_sgi(irq, 0, 1);
else
gic_trigger_interrupt(irq);
gic_dump_status(irq, arch_curr_cpu_num());
printf("-----------------------------gic ints test end---------------------------\n");
return 0;
}
int gic_test_sgi(int argc, const console_cmd_args *argv)
{
int irq, cpu;
spin_lock_saved_state_t state;
struct int_handler_struct *h;
if (argc < 3) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
cpu = argv[2].i;
printf("-------------------gic sgi test start cpu %d irq %d-------------\n", cpu, irq);
spin_lock_save(&gicd_lock, &state, GICD_LOCK_FLAGS);
h = get_int_handler(irq, cpu);
h->handler = test_sig_handler;
h->arg = NULL;
spin_unlock_restore(&gicd_lock, state, GICD_LOCK_FLAGS);
arm_gic_sgi(irq, 0, 1 << cpu);
printf("-----------------------------gic sgi test end---------------------------\n");
return 0;
}
int gic_dump_lr(int argc, const console_cmd_args *argv)
{
int lr;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
lr = argv[1].i;
printf("------------------dump lr %d-------------\n", lr);
printf("lr value is %llx\n", vgic_read_lr_reg(0));
return 0;
}
int gic_dump_irq(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
printf("------------------dump irq %d status-------------\n", irq);
gic_dump_status(irq, 0);
return 0;
}
int gic_clear_irq(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
printf("------------------dump irq %d status-------------\n", irq);
gic_clear_pending(irq);
return 0;
}
int gic_active_irq(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
printf("------------------set active irq %d-------------\n", irq);
gic_set_isactiver(irq);
return 0;
}
int gic_deactive_irq(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
printf("------------------deactive irq %d -------------\n", irq);
gic_set_icactiver(irq);
return 0;
}
int gic_level_test(int argc, const console_cmd_args *argv)
{
int irq;
if (argc < 2) {
printf("lacks of args\n");
return -1;
}
irq = argv[1].i;
gic_set_irq(irq, 0xa0, 0, 1, test_irq_handler, NULL);
return -1;
}
STATIC_COMMAND_START
STATIC_COMMAND("enable", "enable/disable interrupt", &inter_enable)
STATIC_COMMAND("triger", "set interrupt pending", &inter_triger)
STATIC_COMMAND("testirq", "test irq sending", &gic_irq_test)
STATIC_COMMAND("testsgi", "test sgi sending", &gic_test_sgi)
STATIC_COMMAND("dumplr", "dump lr value", &gic_dump_lr)
STATIC_COMMAND("dumpirq", "dump irq value", &gic_dump_irq)
STATIC_COMMAND("cpend", "clear irq pending", &gic_clear_irq)
STATIC_COMMAND("active", "active irq", &gic_active_irq)
STATIC_COMMAND("deactive", "deactive irq", &gic_deactive_irq)
STATIC_COMMAND("testlirq", "test level irq ", &gic_level_test)
STATIC_COMMAND_END(gic);
| 29.278756 | 113 | 0.667445 |
c31e981346d88f612d3a0ddf81232e9a405ca6b7 | 3,305 | h | C | libraries/RingBuf/RingBuf.h | ponty/arduino-sketchbook | 1312e7b68846f378281e022e89afa9fbb59aaf64 | [
"BSD-2-Clause"
] | null | null | null | libraries/RingBuf/RingBuf.h | ponty/arduino-sketchbook | 1312e7b68846f378281e022e89afa9fbb59aaf64 | [
"BSD-2-Clause"
] | null | null | null | libraries/RingBuf/RingBuf.h | ponty/arduino-sketchbook | 1312e7b68846f378281e022e89afa9fbb59aaf64 | [
"BSD-2-Clause"
] | null | null | null | /*
RingBuf.h - Library for implementing a simple Ring Buffer on Arduino boards.
Created by D. Aaron Wisner (daw268@cornell.edu)
January 17, 2015.
Released into the public domain.
*/
#ifndef RingBuf_h
#define RingBuf_h
#include "Arduino.h"
#ifndef __cplusplus
#ifndef bool
#define bool uint8_t
#endif
#endif
#if defined(ARDUINO_ARCH_AVR)
#include <util/atomic.h>
#define RB_ATOMIC_START ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
#define RB_ATOMIC_END }
#elif defined(ARDUINO_ARCH_ESP8266)
#ifndef __STRINGIFY
#define __STRINGIFY(a) #a
#endif
#ifndef xt_rsil
#define xt_rsil(level) (__extension__({uint32_t state; __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (state)); state;}))
#endif
#ifndef xt_wsr_ps
#define xt_wsr_ps(state) __asm__ __volatile__("wsr %0,ps; isync" :: "a" (state) : "memory")
#endif
#define RB_ATOMIC_START do { uint32_t _savedIS = xt_rsil(15) ;
#define RB_ATOMIC_END xt_wsr_ps(_savedIS) ;} while(0);
#else
#error “This library only supports AVR and ESP8266 Boards.”
#endif
typedef struct RingBuf RingBuf;
typedef struct RingBuf
{
// Invariant: end and start is always in bounds
unsigned char *buf;
unsigned int len, size, start, end, elements;
// Private:
int (*next_end_index) (RingBuf*);
int (*incr_end_index) (RingBuf*);
int (*incr_start_index) (RingBuf*);
//public:
// Returns true if full
bool (*isFull) (RingBuf*);
// Returns true if empty
bool (*isEmpty) (RingBuf*);
// Returns number of elemnts in buffer
unsigned int (*numElements)(RingBuf*);
// Add Event, Returns index where added in buffer, -1 on full buffer
int (*add) (RingBuf*, const void*);
// Returns pointer to nth element, NULL when nth element is empty
void *(*peek) (RingBuf*, unsigned int);
// Removes element and copies it to location pointed to by void *
// Returns pointer passed in, NULL on empty buffer
void *(*pull) (RingBuf*, void *);
} RingBuf;
#ifdef __cplusplus
extern "C" {
#endif
RingBuf *RingBuf_new(int size, int len);
int RingBuf_init(RingBuf *self, int size, int len);
int RingBuf_delete(RingBuf *self);
int RingBufNextEndIndex(RingBuf *self);
int RingBufIncrEnd(RingBuf *self);
int RingBufIncrStart(RingBuf *self);
int RingBufAdd(RingBuf *self, const void *object);
void *RingBufPeek(RingBuf *self, unsigned int num);
void *RingBufPull(RingBuf *self, void *object);
bool RingBufIsFull(RingBuf *self);
bool RingBufIsEmpty(RingBuf *self);
unsigned int RingBufNumElements(RingBuf *self);
#ifdef __cplusplus
}
#endif
// For those of you who cant live without pretty C++ objects....
#ifdef __cplusplus
class RingBufC
{
public:
RingBufC(int size, int len) { buf = RingBuf_new(size, len); }
~RingBufC() { RingBuf_delete(buf); }
bool isFull() { return RingBufIsFull(buf); }
bool isEmpty() { return RingBufIsEmpty(buf); }
unsigned int numElements() { return RingBufNumElements(buf); }
unsigned int add(const void *object) { return RingBufAdd(buf, object); }
void *peek(unsigned int num) { return RingBufPeek(buf, num); }
void *pull(void *object) { return RingBufPull(buf, object); }
// Use this to check if memory allocation failed
bool allocFailed() { return !buf; }
private:
RingBuf *buf;
};
#endif
#endif
| 26.44 | 140 | 0.702572 |
988710c81962a486cf70c64fc7b8cf42bda24418 | 645 | h | C | src/cpp/glbEffectFactory.h | mikkame/EffekseerForWebGL | f672039cca2b8037e2b0716b9205db6207e02542 | [
"MIT"
] | null | null | null | src/cpp/glbEffectFactory.h | mikkame/EffekseerForWebGL | f672039cca2b8037e2b0716b9205db6207e02542 | [
"MIT"
] | null | null | null | src/cpp/glbEffectFactory.h | mikkame/EffekseerForWebGL | f672039cca2b8037e2b0716b9205db6207e02542 | [
"MIT"
] | null | null | null |
#pragma once
#include "glTFglbEffectFactory.h"
class glbEffectFactory : public glTFglmEffectFactory
{
protected:
struct glbData
{
uint8_t* bin = nullptr;
glTFData gltf;
bool Load(const void* data, int32_t size);
};
public:
glbEffectFactory() = default;
virtual ~glbEffectFactory() = default;
bool OnCheckIsBinarySupported(const void* data, int32_t size) override;
bool OnLoading(Effekseer::Effect* effect, const void* data, int32_t size, float magnification, const EFK_CHAR* materialPath) override;
void OnLoadingResource(Effekseer::Effect* effect, const void* data, int32_t size, const EFK_CHAR* materialPath) override;
}; | 24.807692 | 135 | 0.767442 |
98951bb55e24b9e17eee3c649ac58e381acedf9a | 2,887 | c | C | audio/src/main.c | isage/samples | edf47645e5a63f02b8a8b5ef7a9fec49c1d6a3de | [
"CC0-1.0"
] | 234 | 2015-10-08T12:52:37.000Z | 2022-03-28T10:28:20.000Z | audio/src/main.c | isage/samples | edf47645e5a63f02b8a8b5ef7a9fec49c1d6a3de | [
"CC0-1.0"
] | 45 | 2015-09-23T19:24:00.000Z | 2022-03-25T01:39:52.000Z | audio/src/main.c | isage/samples | edf47645e5a63f02b8a8b5ef7a9fec49c1d6a3de | [
"CC0-1.0"
] | 138 | 2016-03-25T05:59:03.000Z | 2022-01-31T21:15:57.000Z | #include <stdint.h>
#include <math.h>
#include <psp2/ctrl.h>
#include <psp2/audioout.h>
#include <psp2/kernel/processmgr.h>
#include "debugScreen.h"
#define countof(A) sizeof(A)/sizeof(*A)
#define MIN(A,B) ((A)<(B)?(A):(B))
#define MAX(A,B) ((A)>(B)?(A):(B))
#define printf psvDebugScreenPrintf
double gen_sqr(double p){return p>.5?-1.:1.;}
double gen_tri(double p){return p*2;}
double gen_nul(double p){return 0.;}
double gen_sin(double p){return sin(2*M_PI*p);}
typedef double (*wav_gen)(double);
void wave_set(int16_t*buffer, size_t size, wav_gen generator){
for (size_t smpl = 0; smpl < size; ++smpl)
buffer[smpl] = 0x7FFF*generator((float)smpl/(float)size);
}
int main(void) {
psvDebugScreenInit();
int freqs[] = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000};
int size = 256;
int freq = 8;
int mode = SCE_AUDIO_OUT_MODE_MONO;
int vol = SCE_AUDIO_VOLUME_0DB;
int port = sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_BGM, size, freqs[freq], mode);
sceAudioOutSetVolume(port, SCE_AUDIO_VOLUME_FLAG_L_CH |SCE_AUDIO_VOLUME_FLAG_R_CH, (int[]){vol,vol});
int16_t wave_buf[SCE_AUDIO_MAX_LEN]={0};
wav_gen gen=gen_nul;
SceCtrlData ctrl_peek, ctrl_press;
do{
ctrl_press = ctrl_peek;
sceCtrlPeekBufferPositive(0, &ctrl_peek, 1);
ctrl_press.buttons = ctrl_peek.buttons & ~ctrl_press.buttons;
if(ctrl_press.buttons == SCE_CTRL_CIRCLE)
gen=gen_sin;
if(ctrl_press.buttons == SCE_CTRL_SQUARE)
gen=gen_sqr;
if(ctrl_press.buttons == SCE_CTRL_TRIANGLE)
gen=gen_tri;
if(ctrl_press.buttons == SCE_CTRL_CROSS)
gen=gen_nul;
if(ctrl_press.buttons & (SCE_CTRL_CROSS|SCE_CTRL_TRIANGLE|SCE_CTRL_SQUARE|SCE_CTRL_CIRCLE))
wave_set(wave_buf,size,gen);
if(ctrl_press.buttons == SCE_CTRL_RIGHT)
freq = MIN(countof(freqs)-1, freq+1);
if(ctrl_press.buttons == SCE_CTRL_LEFT)
freq = MAX(0, freq-1);
if(ctrl_press.buttons == SCE_CTRL_RTRIGGER)
size = MIN(SCE_AUDIO_MAX_LEN,size+1000);
if(ctrl_press.buttons == SCE_CTRL_LTRIGGER)
size = MAX(SCE_AUDIO_MIN_LEN,size-1000);
if(ctrl_press.buttons & (SCE_CTRL_RIGHT|SCE_CTRL_LEFT|SCE_CTRL_LTRIGGER|SCE_CTRL_RTRIGGER)){
sceAudioOutSetConfig(port, size, freqs[freq], mode);
wave_set(wave_buf,size,gen);
}
if(ctrl_press.buttons == SCE_CTRL_UP)
vol = MIN(vol+1024,SCE_AUDIO_VOLUME_0DB);
if(ctrl_press.buttons == SCE_CTRL_DOWN)
vol = MAX(vol-1024,0);
if(ctrl_press.buttons & (SCE_CTRL_UP|SCE_CTRL_DOWN))
sceAudioOutSetVolume(port, SCE_AUDIO_VOLUME_FLAG_L_CH |SCE_AUDIO_VOLUME_FLAG_R_CH, (int[]){vol,vol});
sceAudioOutOutput(port, wave_buf);
printf("freq:%-5i size:%-5i vol:%-5i wave:{%+6i..%+6i..%6i..%+6i }\r",
freqs[freq], size, vol, wave_buf[0*size/4], wave_buf[1*size/4], wave_buf[2*size/4], wave_buf[3*size/4]);//\e[H
}while(ctrl_press.buttons != SCE_CTRL_START);
sceAudioOutReleasePort(port);
sceKernelExitProcess(0);
return 0;
} | 33.569767 | 120 | 0.724281 |
98ae2a4345dbc8559ede50cfdf457fe5440b62c5 | 2,244 | h | C | Engine/Source/Editor/BlueprintGraph/Public/BlueprintGraphDefinitions.h | PopCap/GameIdea | 201e1df50b2bc99afc079ce326aa0a44b178a391 | [
"BSD-2-Clause"
] | null | null | null | Engine/Source/Editor/BlueprintGraph/Public/BlueprintGraphDefinitions.h | PopCap/GameIdea | 201e1df50b2bc99afc079ce326aa0a44b178a391 | [
"BSD-2-Clause"
] | 2 | 2015-06-21T17:38:11.000Z | 2015-06-22T20:54:42.000Z | Engine/Source/Editor/BlueprintGraph/Public/BlueprintGraphDefinitions.h | PopCap/GameIdea | 201e1df50b2bc99afc079ce326aa0a44b178a391 | [
"BSD-2-Clause"
] | null | null | null | // Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
#include "EdGraphSchema_K2.h"
#include "EdGraphSchema_K2_Actions.h"
#include "K2Node_ActorBoundEvent.h"
#include "K2Node_AddComponent.h"
#include "K2Node_AddDelegate.h"
#include "K2Node_AssignmentStatement.h"
#include "K2Node_BaseAsyncTask.h"
#include "K2Node_BaseMCDelegate.h"
#include "K2Node_BreakStruct.h"
#include "K2Node_CallArrayFunction.h"
#include "K2Node_CallDataTableFunction.h"
#include "K2Node_CallDelegate.h"
#include "K2Node_CallFunction.h"
#include "K2Node_CallFunctionOnMember.h"
#include "K2Node_CallMaterialParameterCollectionFunction.h"
#include "K2Node_CallParentFunction.h"
#include "K2Node_ClearDelegate.h"
#include "K2Node_CommutativeAssociativeBinaryOperator.h"
#include "K2Node_ConstructObjectFromClass.h"
#include "K2Node_DoOnceMultiInput.h"
#include "K2Node_ComponentBoundEvent.h"
#include "K2Node_Composite.h"
#include "K2Node_CreateDelegate.h"
#include "K2Node_CustomEvent.h"
#include "K2Node_DelegateSet.h"
#include "K2Node_DynamicCast.h"
#include "K2Node_EaseFunction.h"
#include "K2Node_Event.h"
#include "K2Node_ExecutionSequence.h"
#include "K2Node_FormatText.h"
#include "K2Node_FunctionEntry.h"
#include "K2Node_FunctionResult.h"
#include "K2Node_GetDataTableRow.h"
#include "K2Node_IfThenElse.h"
#include "K2Node_InputAction.h"
#include "K2Node_InputAxisEvent.h"
#include "K2Node_InputKey.h"
#include "K2Node_InputTouch.h"
#include "K2Node_Knot.h"
#include "K2Node_Literal.h"
#include "K2Node_MacroInstance.h"
#include "K2Node_MakeArray.h"
#include "K2Node_MakeStruct.h"
#include "K2Node_MathExpression.h"
#include "K2Node_MatineeController.h"
#include "K2Node_RemoveDelegate.h"
#include "K2Node_Select.h"
#include "K2Node_Self.h"
#include "K2Node_SpawnActor.h"
#include "K2Node_SpawnActorFromClass.h"
#include "K2Node_StructMemberGet.h"
#include "K2Node_StructMemberSet.h"
#include "K2Node_StructOperation.h"
#include "K2Node_Switch.h"
#include "K2Node_SwitchInteger.h"
#include "K2Node_SwitchName.h"
#include "K2Node_TemporaryVariable.h"
#include "K2Node_Timeline.h"
#include "K2Node_Variable.h"
#include "K2Node_VariableGet.h"
#include "K2Node_VariableSet.h"
#include "K2Node_SetFieldsInStruct.h"
#include "NodeDependingOnEnumInterface.h"
| 33 | 60 | 0.823529 |
a6b1ea3db86e341213b16e1ed29ba5f50336dc5e | 497 | h | C | src/kernel/arch/x86/32Bit/userlogger.h | jbw3/OS | 52026277e20f3f8d504b8094084ba883f1f462df | [
"MIT"
] | 2 | 2018-12-02T05:42:51.000Z | 2020-02-21T14:56:24.000Z | src/kernel/arch/x86/32Bit/userlogger.h | jbw3/OS | 52026277e20f3f8d504b8094084ba883f1f462df | [
"MIT"
] | 7 | 2017-06-03T16:14:10.000Z | 2018-06-19T03:00:51.000Z | src/kernel/arch/x86/32Bit/userlogger.h | jbw3/OS | 52026277e20f3f8d504b8094084ba883f1f462df | [
"MIT"
] | null | null | null | #ifndef USER_LOGGER_H_
#define USER_LOGGER_H_
#include "logger.h"
class Stream;
/**
* @brief Provides capability for logging messages to the user.
*/
class UserLogger : public Logger
{
public:
UserLogger();
void addStream(Stream* stream);
protected:
void flush(const char* buff, size_t len) override;
private:
static constexpr size_t MAX_STREAMS_SIZE = 4;
Stream* streams[MAX_STREAMS_SIZE];
size_t streamsSize;
};
extern UserLogger ulog;
#endif // USER_LOGGER_H_
| 16.566667 | 63 | 0.726358 |
60d49d7fafb0f06c7543932161e68b19fbb3c23f | 344 | c | C | regression/cra/code/mem2.c | ruijiefang/duet-IW | 42365dca17da7cbdcf7fb7e7ca1775298c454970 | [
"MIT"
] | 25 | 2016-10-10T13:52:45.000Z | 2021-12-15T07:49:04.000Z | regression/cra/code/mem2.c | happypig95/duet | fe630be73ba7f55e8d1973f3c364aa37da159607 | [
"MIT"
] | 3 | 2016-02-10T14:03:46.000Z | 2019-08-18T13:59:53.000Z | regression/cra/code/mem2.c | happypig95/duet | fe630be73ba7f55e8d1973f3c364aa37da159607 | [
"MIT"
] | 20 | 2016-02-10T13:46:19.000Z | 2022-02-18T16:02:16.000Z | void *malloc(int);
void usage(int x) {
exit(x);
}
void main(int argc, char* argv[]){
int optind;
char **files;
int n_files;
assume(argc >= 0);
argv = malloc(argc * sizeof(char*));
optind = 1;
n_files = argc - optind;
files = argv + optind;
if (n_files <= 0) {
usage(1);
}
char c = files[0];
}
| 16.380952 | 40 | 0.531977 |
b094205f9cf2041f2b297b5222e2c6a4c187092a | 1,509 | h | C | include/event.h | arsdever/httpcpp | c4f75510d09c37cf11c8cb80493571afd3c321bb | [
"MIT"
] | null | null | null | include/event.h | arsdever/httpcpp | c4f75510d09c37cf11c8cb80493571afd3c321bb | [
"MIT"
] | null | null | null | include/event.h | arsdever/httpcpp | c4f75510d09c37cf11c8cb80493571afd3c321bb | [
"MIT"
] | null | null | null | #pragma once
#define EVENTS
namespace events
{
template <typename ... A>
class event
{
public:
using event_handler = std::function<void(A...)>;
//event(std::string const& name);
event& operator +(event_handler h) { return operator += (h); }
event& operator +(std::initializer_list<event_handler> hlist) { return operator += (hlist); }
event& operator +=(event_handler h)
{
m_handlers.push_back(h);
return *this;
}
event& operator +=(std::initializer_list<event_handler> hlist)
{
m_handlers.insert(m_handlers.end(), hlist.begin(), hlist.end());
return *this;
}
event& operator = (event const&) = delete;
event& operator = (event&&) = delete;
void operator()(A ... args)
{
for (event_handler h : m_handlers)
h(std::forward<A>(args)...);
}
std::vector<event_handler> m_handlers;
};
template <>
class event<void>
{
public:
using event_handler = std::function<void()>;
//event(std::string const& name);
event& operator +(event_handler h) { return operator += (h); }
event& operator +(std::initializer_list<event_handler> hlist) { return operator += (hlist); }
event& operator +=(event_handler h)
{
m_handlers.push_back(h);
return *this;
}
event& operator +=(std::initializer_list<event_handler> hlist)
{
m_handlers.insert(m_handlers.end(), hlist.begin(), hlist.end());
return *this;
}
void operator()()
{
for (event_handler h : m_handlers)
h();
}
std::vector<event_handler> m_handlers;
};
} | 20.671233 | 95 | 0.648111 |
b846110633afd67dc3b6ccb8814f4c99c76918d5 | 883 | c | C | lib/sndkit/dsp/smoother.c | PaulBatchelor/mnolth | 4b9f315f0062212ef96b41153e089dea61c6d16d | [
"MIT"
] | 2 | 2022-01-11T07:00:40.000Z | 2022-01-11T07:00:43.000Z | lib/sndkit/dsp/smoother.c | PaulBatchelor/mnolth | 4b9f315f0062212ef96b41153e089dea61c6d16d | [
"MIT"
] | null | null | null | lib/sndkit/dsp/smoother.c | PaulBatchelor/mnolth | 4b9f315f0062212ef96b41153e089dea61c6d16d | [
"MIT"
] | null | null | null | #line 48 "smoother.org"
#include <math.h>
#define SK_SMOOTHER_PRIV
#include "smoother.h"
#line 87 "smoother.org"
void sk_smoother_init(sk_smoother *s, int sr)
{
#line 114 "smoother.org"
s->smooth = 0.01;
s->psmooth = -1;
#line 123 "smoother.org"
s->a1 = 0;
s->b0 = 0;
s->y0 = 0;
#line 134 "smoother.org"
s->onedsr = 1.0 / sr;
#line 90 "smoother.org"
}
#line 146 "smoother.org"
void sk_smoother_time(sk_smoother *s, SKFLT t)
{
s->smooth = t;
}
#line 166 "smoother.org"
void sk_smoother_reset(sk_smoother *s, SKFLT in)
{
s->y0 = in;
}
#line 187 "smoother.org"
SKFLT sk_smoother_tick(sk_smoother *s, SKFLT in)
{
SKFLT out;
if (s->psmooth != s->smooth) {
s->a1 = pow(0.5, s->onedsr/s->smooth);
s->b0 = 1.0 - s->a1;
s->psmooth = s->smooth;
}
s->y0 = s->b0 * in + s->a1 * s->y0;
out = s->y0;
return out;
}
#line 48 "smoother.org"
| 19.195652 | 48 | 0.605889 |
fc9d1b38bcd149e4ebaa2e35bfa8f166cd64d46a | 1,778 | h | C | Labyrint/labyball/Classes/Native/UnityEngine_UnityEngine_Plane1600081545.h | mimietti/Labyball | c4b03f5b5d5ec1a1cae5831d22391bc2a171230f | [
"MIT"
] | null | null | null | Labyrint/labyball/Classes/Native/UnityEngine_UnityEngine_Plane1600081545.h | mimietti/Labyball | c4b03f5b5d5ec1a1cae5831d22391bc2a171230f | [
"MIT"
] | 23 | 2016-07-21T13:03:02.000Z | 2016-10-03T12:43:01.000Z | Labyrint/labyrinti1/Classes/Native/UnityEngine_UnityEngine_Plane1600081545.h | mimietti/Labyball | c4b03f5b5d5ec1a1cae5831d22391bc2a171230f | [
"MIT"
] | 1 | 2019-09-08T17:32:17.000Z | 2019-09-08T17:32:17.000Z | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "mscorlib_System_ValueType4014882752.h"
#include "UnityEngine_UnityEngine_Vector33525329789.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Plane
struct Plane_t1600081545
{
public:
// UnityEngine.Vector3 UnityEngine.Plane::m_Normal
Vector3_t3525329789 ___m_Normal_0;
// System.Single UnityEngine.Plane::m_Distance
float ___m_Distance_1;
public:
inline static int32_t get_offset_of_m_Normal_0() { return static_cast<int32_t>(offsetof(Plane_t1600081545, ___m_Normal_0)); }
inline Vector3_t3525329789 get_m_Normal_0() const { return ___m_Normal_0; }
inline Vector3_t3525329789 * get_address_of_m_Normal_0() { return &___m_Normal_0; }
inline void set_m_Normal_0(Vector3_t3525329789 value)
{
___m_Normal_0 = value;
}
inline static int32_t get_offset_of_m_Distance_1() { return static_cast<int32_t>(offsetof(Plane_t1600081545, ___m_Distance_1)); }
inline float get_m_Distance_1() const { return ___m_Distance_1; }
inline float* get_address_of_m_Distance_1() { return &___m_Distance_1; }
inline void set_m_Distance_1(float value)
{
___m_Distance_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for marshalling of: UnityEngine.Plane
struct Plane_t1600081545_marshaled_pinvoke
{
Vector3_t3525329789_marshaled_pinvoke ___m_Normal_0;
float ___m_Distance_1;
};
// Native definition for marshalling of: UnityEngine.Plane
struct Plane_t1600081545_marshaled_com
{
Vector3_t3525329789_marshaled_com ___m_Normal_0;
float ___m_Distance_1;
};
| 27.353846 | 130 | 0.806524 |
52bf36537c9b3ed087bea96cfdc45657e53a87a2 | 5,864 | h | C | src/include/lwp.h | Krzem5/C-Lego_Wireless_Protocol | 7556281590f0cd469a1540277c1625fa8961220d | [
"BSD-3-Clause"
] | null | null | null | src/include/lwp.h | Krzem5/C-Lego_Wireless_Protocol | 7556281590f0cd469a1540277c1625fa8961220d | [
"BSD-3-Clause"
] | null | null | null | src/include/lwp.h | Krzem5/C-Lego_Wireless_Protocol | 7556281590f0cd469a1540277c1625fa8961220d | [
"BSD-3-Clause"
] | null | null | null | #ifndef __LWP_H__
#define __LWP_H__ 1
#include <stdint.h>
#include <ble_lib.h>
#include <windows.h>
#define LWP_DEVICE_FOUND_IGNORE 0
#define LWP_DEVICE_FOUND_ACCUMULATE 1
#define LWP_DEVICE_FOUND_ACCUMULATE_RETURN 2
#define LWP_DEVICE_TYPE_WEDO_HUB 0
#define LWP_DEVICE_TYPE_DUPLO_TRAIN 0x20
#define LWP_DEVICE_TYPE_MOVE_HUB 0x40
#define LWP_DEVICE_TYPE_2PORT_HUB 0x41
#define LWP_DEVICE_TYPE_2PORT_HANDSET 0x42
#define LWP_DEVICE_TYPE_MEDIUM_HUB 0x80
#define LWP_DEVICE_TYPE_UNKNOWN 0xff
#define LWP_DEVICE_PORT_ATTACHED 1
#define LWP_DEVICE_PORT_VIRTUAL 2
#define LWP_DEVICE_PORT_OUTPUT 4
#define LWP_DEVICE_PORT_INPUT 8
#define LWP_DEVICE_PORT_COMBINABLE 16
#define LWP_DEVICE_PORT_SYNCHRONIZABLE 32
#define LWP_DEVICE_PORT_DRIVER 64
#define GET_LWP_DEVICE_PORT_MODE_COUNT(f) (((f)&0xf)+1)
#define GET_LWP_DEVICE_PORT_COMBINATION_COUNT(f) ((f)>>4)
#define SET_LWP_DEVICE_PORT_MODE_COUNT(c) ((c)-1)
#define SET_LWP_DEVICE_PORT_COMBINATION_COUNT(c) ((c)<<4)
#define LWP_COMMAND_HUB_PROPERTIES 0x01
#define LWP_COMMAND_HUB_ACTIONS 0x02
#define LWP_COMMAND_HUB_ALERTS 0x03
#define LWP_COMMAND_HUB_ATTACHED_IO 0x04
#define LWP_COMMAND_GENERIC_ERROR_MESSAGES 0x05
#define LWP_COMMAND_HW_NETWORK_COMMANDS 0x08
#define LWP_COMMAND_FW_UPDATE_GO_INTO_BOOT_MODE 0x10
#define LWP_COMMAND_FW_UPDATE_LOCK_MEMORY 0x11
#define LWP_COMMAND_FW_UPDATE_LOCK_STATUS_REQUEST 0x12
#define LWP_COMMAND_FW_LOCK_STATUS 0x13
#define LWP_COMMAND_PORT_INFORMATION_REQUEST 0x21
#define LWP_COMMAND_PORT_MODE_INFORMATION_REQUEST 0x22
#define LWP_COMMAND_PORT_INPUT_FORMAT_SETUP_SINGLE 0x41
#define LWP_COMMAND_PORT_INPUT_FORMAT_SETUP_COMBINED 0x42
#define LWP_COMMAND_PORT_INFORMATION 0x43
#define LWP_COMMAND_PORT_MODE_INFORMATION 0x44
#define LWP_COMMAND_PORT_VALUE_SINGLE 0x45
#define LWP_COMMAND_PORT_VALUE_COMBINED 0x46
#define LWP_COMMAND_PORT_INPUT_FORMAT_SINGLE 0x47
#define LWP_COMMAND_PORT_INPUT_FORMAT_COMBINED 0x48
#define LWP_COMMAND_VIRTUAL_PORT_SETUP 0x61
#define LWP_COMMAND_PORT_OUTPUT_COMMAND 0x81
#define LWP_COMMAND_PORT_OUTPUT_COMMAND_FEEDBACK 0x82
#define LWP_PORT_INFORMATION_TYPE_VALUE 0x00
#define LWP_PORT_INFORMATION_TYPE_MODE 0x01
#define LWP_PORT_INFORMATION_TYPE_COMBINATIONS 0x02
#define LWP_PORT_MODE_INFORMATION_TYPE_NAME 0x00
#define LWP_PORT_MODE_INFORMATION_TYPE_RAW 0x01
#define LWP_PORT_MODE_INFORMATION_TYPE_PCT 0x02
#define LWP_PORT_MODE_INFORMATION_TYPE_SI 0x03
#define LWP_PORT_MODE_INFORMATION_TYPE_SYMBOL 0x04
#define LWP_PORT_MODE_INFORMATION_TYPE_MAPPING 0x05
#define LWP_PORT_MODE_INFORMATION_TYPE_VALUE_FORMAT 0x80
#define LWP_DEVICE_PORT_MODE_INPUT 1
#define LWP_DEVICE_PORT_MODE_INPUT_MAPPING_DISCRETE 2
#define LWP_DEVICE_PORT_MODE_INPUT_MAPPING_RELATIVE 4
#define LWP_DEVICE_PORT_MODE_INPUT_MAPPING_ABSOLUTE 8
#define LWP_DEVICE_PORT_MODE_INPUT_MAPPING_FUNCTIONAL_2_0 16
#define LWP_DEVICE_PORT_MODE_INPUT_MAPPING_NULL 32
#define LWP_DEVICE_PORT_MODE_OUTPUT 64
#define LWP_DEVICE_PORT_MODE_OUTPUT_MAPPING_DISCRETE 128
#define LWP_DEVICE_PORT_MODE_OUTPUT_MAPPING_RELATIVE 256
#define LWP_DEVICE_PORT_MODE_OUTPUT_MAPPING_ABSOLUTE 512
#define LWP_DEVICE_PORT_MODE_OUTPUT_MAPPING_FUNCTIONAL_2_0 1024
#define LWP_DEVICE_PORT_MODE_OUTPUT_MAPPING_NULL 2048
#define LWP_DEVICE_PORT_MODE_DATASET_TYPE_8BYTE 0
#define LWP_DEVICE_PORT_MODE_DATASET_TYPE_16BYTE 4096
#define LWP_DEVICE_PORT_MODE_DATASET_TYPE_32BYTE 8192
#define LWP_DEVICE_PORT_MODE_DATASET_TYPE_FLOAT 12288
#define GET_LWP_DEVICE_PORT_MODE_DATASET_TYPE(f) ((f)>>12)
#define LWP_WAIT_FOR_ALL_PORTS 0
#define LWP_PORT_WRITE_DIRECT_MODE_DATA 0x51
#define LWP_PORT_OUTPUT_FORMAT_BUFFER 0
#define LWP_PORT_OUTPUT_FORMAT_NO_BUFFER 16
#define LWP_PORT_OUTPUT_FORMAT_FEEDBACK 1
#define LWP_PORT_OUTPUT_FORMAT_NO_FEEDBACK 0
#define LWP_DEVICE_FREE_SHUTDOWN 0
#define LWP_DEVICE_FREE_DISCONNECT 1
typedef struct __LWP_DEVICE_DATA{
uint64_t addr;
uint8_t dt;
} lwp_device_data_t;
typedef struct __LWP_DEVICE_PORT_MODE_RANGE{
float mn;
float mx;
} lwp_device_port_mode_range_t;
typedef struct __LWP_DEVICE_PORT_MODE{
uint16_t f;
char nm[12];
char sm[6];
uint8_t _dtl;
lwp_device_port_mode_range_t rr;
lwp_device_port_mode_range_t pr;
lwp_device_port_mode_range_t sr;
} lwp_device_port_mode_t;
typedef struct __LWP_DEVICE_PORT{
void* _drv_dt;
uint16_t t;
uint8_t f;
uint8_t _cnt;
uint16_t _drv_id;
uint16_t sm;
uint8_t mf;
uint16_t mc[8];
lwp_device_port_mode_t ml[16];
} lwp_device_port_t;
typedef struct __LWP_DEVICE_PORT_LIST{
uint8_t l;
lwp_device_port_t* dt;
} lwp_device_port_list_t;
typedef struct __LWP_DEVICE{
uint64_t addr;
uint8_t t;
lwp_device_port_list_t ports;
ble_connected_device_t* _dt;
ble_connected_device_characteristics_t* _dc;
HANDLE _mx;
} lwp_device_t;
typedef struct __LWP_DEVICE_LIST{
uint32_t l;
lwp_device_t** dt;
} lwp_device_list_t;
typedef void (*lwp_driver_init_func)(lwp_device_t* d,uint8_t p);
typedef void (*lwp_driver_update_func)(lwp_device_t* d,uint8_t p,uint32_t f,float tm,void* bf);
typedef void (*lwp_driver_deinit_func)(lwp_device_t* d,uint8_t p);
typedef struct __LWP_DRIVER{
uint16_t id;
const char* nm;
lwp_driver_init_func init;
lwp_driver_update_func update;
lwp_driver_deinit_func deinit;
} lwp_driver_t;
typedef uint8_t (*lwp_device_found_t)(lwp_device_data_t* dt);
lwp_device_list_t* lwp_find_devices(uint32_t tm,lwp_device_found_t cb);
void lwp_free_device_list(lwp_device_list_t* dl);
void lwp_send_raw_data(lwp_device_t* d,uint8_t* dt,uint16_t dtl);
void lwp_wait_for_ports(lwp_device_t* d,uint8_t c,...);
lwp_device_port_t* lwp_get_port(lwp_device_t* d,uint8_t p);
const char* lwp_get_port_string(lwp_device_t* d,uint8_t p);
void lwp_setup_port(lwp_device_t* d,uint8_t p,uint8_t m,uint32_t di,uint8_t ne);
void lwp_setup_port_multiple(lwp_device_t* d,uint8_t p,uint8_t c,...);
void lwp_free_device(lwp_device_t* d,uint8_t t);
#endif
| 26.178571 | 95 | 0.857435 |
ddd9de89331d20006b298e556426d47065429e74 | 1,847 | c | C | debian/modules/nginx-lua/src/ngx_http_lua_initby.c | Low-power/nginx-mbedtls | 08aa7092db52f5a383707815fe64557de9bce3e7 | [
"BSD-2-Clause"
] | 2 | 2015-05-19T08:13:20.000Z | 2016-01-09T05:42:54.000Z | debian/modules/nginx-lua/src/ngx_http_lua_initby.c | Low-power/nginx-mbedtls | 08aa7092db52f5a383707815fe64557de9bce3e7 | [
"BSD-2-Clause"
] | null | null | null | debian/modules/nginx-lua/src/ngx_http_lua_initby.c | Low-power/nginx-mbedtls | 08aa7092db52f5a383707815fe64557de9bce3e7 | [
"BSD-2-Clause"
] | 5 | 2015-01-20T20:20:47.000Z | 2020-05-19T12:01:43.000Z |
/*
* Copyright (C) Yichun Zhang (agentzh)
*/
#ifndef DDEBUG
#define DDEBUG 0
#endif
#include "ddebug.h"
#include "ngx_http_lua_initby.h"
#include "ngx_http_lua_util.h"
static int ngx_http_lua_report(ngx_log_t *log, lua_State *L, int status);
static int ngx_http_lua_do_call(ngx_log_t *log, lua_State *L);
int
ngx_http_lua_init_by_inline(ngx_log_t *log, ngx_http_lua_main_conf_t *lmcf,
lua_State *L)
{
int status;
status = luaL_loadbuffer(L, (char *) lmcf->init_src.data,
lmcf->init_src.len, "init_by_lua")
|| ngx_http_lua_do_call(log, L);
return ngx_http_lua_report(log, L, status);
}
int
ngx_http_lua_init_by_file(ngx_log_t *log, ngx_http_lua_main_conf_t *lmcf,
lua_State *L)
{
int status;
status = luaL_loadfile(L, (char *) lmcf->init_src.data)
|| ngx_http_lua_do_call(log, L);
return ngx_http_lua_report(log, L, status);
}
static int
ngx_http_lua_report(ngx_log_t *log, lua_State *L, int status)
{
const char *msg;
if (status && !lua_isnil(L, -1)) {
msg = lua_tostring(L, -1);
if (msg == NULL) {
msg = "unknown error";
}
ngx_log_error(NGX_LOG_ERR, log, 0, "failed to run init_by_lua*: %s",
msg);
lua_pop(L, 1);
}
/* force a full garbage-collection cycle */
lua_gc(L, LUA_GCCOLLECT, 0);
return status;
}
static int
ngx_http_lua_do_call(ngx_log_t *log, lua_State *L)
{
int status, base;
base = lua_gettop(L); /* function index */
lua_pushcfunction(L, ngx_http_lua_traceback); /* push traceback function */
lua_insert(L, base); /* put it under chunk and args */
status = lua_pcall(L, 0, 0, base);
lua_remove(L, base);
return status;
}
/* vi:set ft=c ts=4 sw=4 et fdm=marker: */
| 21.476744 | 80 | 0.627504 |
dd8b42bf08ae0a55dccc34801e3d8b33ad8e50a9 | 7,048 | h | C | src/xmpp.h | tuhuayuan/imcore | f9a4ef57041f78416cb7146be46e3c5a1a902a65 | [
"MIT"
] | null | null | null | src/xmpp.h | tuhuayuan/imcore | f9a4ef57041f78416cb7146be46e3c5a1a902a65 | [
"MIT"
] | null | null | null | src/xmpp.h | tuhuayuan/imcore | f9a4ef57041f78416cb7146be46e3c5a1a902a65 | [
"MIT"
] | null | null | null | #ifndef __IMCORE_XMPP_H__
#define __IMCORE_XMPP_H__
#include <stdio.h>
#include "im-thread.h"
#ifdef __cplusplus
extern "C" {
#endif
// 名字空间定义
#define XMPP_NS_CLIENT "jabber:client"
#define XMPP_NS_COMPONENT "jabber:component:accept"
#define XMPP_NS_STREAMS "http://etherx.jabber.org/streams"
#define XMPP_NS_STREAMS_IETF "urn:ietf:params:xml:ns:xmpp-streams"
#define XMPP_NS_TLS "urn:ietf:params:xml:ns:xmpp-tls"
#define XMPP_NS_SASL "urn:ietf:params:xml:ns:xmpp-sasl"
#define XMPP_NS_COMPRESSION "http://jabber.org/features/compress"
#define XMPP_NS_BIND "urn:ietf:params:xml:ns:xmpp-bind"
#define XMPP_NS_SESSION "urn:ietf:params:xml:ns:xmpp-session"
#define XMPP_NS_AUTH "jabber:iq:auth"
#define XMPP_NS_DISCO_INFO "http://jabber.org/protocol/disco#info"
#define XMPP_NS_DISCO_ITEMS "http://jabber.org/protocol/disco#items"
#define XMPP_NS_ROSTER "jabber:iq:roster"
// 错误定义
#define XMPP_EOK 0
#define XMPP_EMEM -1
#define XMPP_EINVOP -2
#define XMPP_EINT -3
// 初始化以及反初始化
void xmpp_initialize(void);
void xmpp_shutdown(void);
// 日志等级
typedef enum {
XMPP_LEVEL_DEBUG,
XMPP_LEVEL_INFO,
XMPP_LEVEL_WARN,
XMPP_LEVEL_ERROR
} xmpp_log_level_t;
// 日志处理回掉签名
typedef void(*xmpp_log_handler)(void *userdata, const xmpp_log_level_t level, const char *area,
const char *msg);
// 日志对象
struct _xmpp_log_t {
xmpp_log_handler handler;
void *userdata;
};
typedef struct _xmpp_log_t xmpp_log_t;
xmpp_log_t *xmpp_get_default_logger(xmpp_log_level_t level);
// 上下文对象
typedef struct _xmpp_ctx_t xmpp_ctx_t;
xmpp_ctx_t *xmpp_ctx_new(im_thread_t *workthread, const xmpp_log_t *log);
void xmpp_ctx_free(xmpp_ctx_t *ctx);
//连接类型
typedef enum {
XMPP_UNKNOWN,
XMPP_CLIENT
} xmpp_conn_type_t;
/* 预定义结构体 */
typedef struct _xmpp_conn_t xmpp_conn_t;
typedef struct _xmpp_stanza_t xmpp_stanza_t;
// xmpp连接状态定义
typedef enum {
XMPP_CONN_CONNECT,
XMPP_CONN_DISCONNECT,
XMPP_CONN_FAIL
} xmpp_conn_event_t;
// xmpp 错误定义
typedef enum {
XMPP_SE_BAD_FORMAT,
XMPP_SE_BAD_NS_PREFIX,
XMPP_SE_CONFLICT,
XMPP_SE_CONN_TIMEOUT,
XMPP_SE_HOST_GONE,
XMPP_SE_HOST_UNKNOWN,
XMPP_SE_IMPROPER_ADDR,
XMPP_SE_INTERNAL_SERVER_ERROR,
XMPP_SE_INVALID_FROM,
XMPP_SE_INVALID_ID,
XMPP_SE_INVALID_NS,
XMPP_SE_INVALID_XML,
XMPP_SE_NOT_AUTHORIZED,
XMPP_SE_POLICY_VIOLATION,
XMPP_SE_REMOTE_CONN_FAILED,
XMPP_SE_RESOURCE_CONSTRAINT,
XMPP_SE_RESTRICTED_XML,
XMPP_SE_SEE_OTHER_HOST,
XMPP_SE_SYSTEM_SHUTDOWN,
XMPP_SE_UNDEFINED_CONDITION,
XMPP_SE_UNSUPPORTED_ENCODING,
XMPP_SE_UNSUPPORTED_STANZA_TYPE,
XMPP_SE_UNSUPPORTED_VERSION,
XMPP_SE_XML_NOT_WELL_FORMED
} xmpp_error_type_t;
// 流错误包含错误类型以及错误的xml节以及错误文字
typedef struct {
xmpp_error_type_t type;
char *text;
xmpp_stanza_t *stanza;
} xmpp_stream_error_t;
// 生存周期管理
xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *ctx);
xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *conn);
int xmpp_conn_release(xmpp_conn_t *conn);
// 属性访问
xmpp_ctx_t* xmpp_conn_get_context(xmpp_conn_t *conn);
const char *xmpp_conn_get_jid(const xmpp_conn_t *conn);
const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *conn);
void xmpp_conn_set_jid(xmpp_conn_t *conn, const char *jid);
const char *xmpp_conn_get_pass(const xmpp_conn_t *conn);
void xmpp_conn_set_timeout(xmpp_conn_t *conn, unsigned long usec);
void xmpp_conn_set_pass(xmpp_conn_t *conn, const char *pass);
void xmpp_conn_disable_tls(xmpp_conn_t *conn);
// 连接状态回调
typedef void(*xmpp_conn_handler)(xmpp_conn_t *conn,
xmpp_conn_event_t state, int error,
xmpp_stream_error_t *stream_error,
void *userdata);
// 连接管理
int xmpp_connect_client(xmpp_conn_t *conn,
const char *altdomain,
unsigned short altport,
xmpp_conn_handler callback,
void *userdata);
void xmpp_disconnect(xmpp_conn_t *conn);
// 消息发送
void xmpp_send(xmpp_conn_t *conn, xmpp_stanza_t *stanza);
void xmpp_send_raw_string(xmpp_conn_t *conn, const char *fmt, ...);
void xmpp_send_raw(xmpp_conn_t *conn, const char *data, size_t len);
// handle回调
typedef int (*xmpp_timed_handler)(xmpp_conn_t *conn, void *userdata);
typedef int (*xmpp_handler)(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata);
// handle回调返回值
#define XMPP_HANDLER_END 0
#define XMPP_HANDLER_AGAIN 1
// handle管理
void xmpp_timed_handler_add(xmpp_conn_t *conn,
xmpp_timed_handler handler,
unsigned long period,
void *userdata);
void xmpp_timed_handler_delete(xmpp_conn_t *conn, xmpp_timed_handler handler);
void xmpp_handler_add(xmpp_conn_t *conn,
xmpp_handler handler,
const char *ns,
const char *name,
const char *type,
void *userdata);
void xmpp_handler_delete(xmpp_conn_t *conn, xmpp_handler handler);
void xmpp_id_handler_add(xmpp_conn_t *conn, xmpp_handler handler, const char *id, void *userdata);
void xmpp_id_handler_delete(xmpp_conn_t *conn, xmpp_handler handler, const char *id);
// Stanza操作
xmpp_stanza_t *xmpp_stanza_new(xmpp_ctx_t *ctx);
xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *stanza);
xmpp_stanza_t * xmpp_stanza_copy(const xmpp_stanza_t *stanza);
int xmpp_stanza_release(xmpp_stanza_t *stanza);
int xmpp_stanza_is_text(xmpp_stanza_t *stanza);
int xmpp_stanza_is_tag(xmpp_stanza_t *stanza);
int xmpp_stanza_to_text(xmpp_stanza_t *stanza, char **const buf, size_t *buflen);
xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *stanza);
xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *stanza, const char *name);
xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *stanza, const char *ns);
xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *stanza);
const char *xmpp_stanza_get_attribute(xmpp_stanza_t *stanza, const char *name);
const char *xmpp_stanza_get_ns(xmpp_stanza_t *stanza);
char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *stanza);
char *xmpp_stanza_get_name_ptr(xmpp_stanza_t *stanza);
int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
int xmpp_stanza_set_ns(xmpp_stanza_t *stanza, const char *ns);
int xmpp_stanza_set_attribute(xmpp_stanza_t *stanza, const char *key, const char *value);
int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *name);
int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *text);
int xmpp_stanza_set_text_safe(xmpp_stanza_t *stanza, const char *text, size_t size);
char *xmpp_stanza_get_type_ptr(xmpp_stanza_t *stanza);
char *xmpp_stanza_get_id_ptr(xmpp_stanza_t *stanza);
int xmpp_stanza_set_id(xmpp_stanza_t *stanza, const char *id);
int xmpp_stanza_set_type(xmpp_stanza_t *stanza, const char *type);
// 循环控制
void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout);
void xmpp_run(xmpp_ctx_t *ctx);
void xmpp_stop(xmpp_ctx_t *ctx);
#ifdef __cplusplus
}
#endif
#endif // __IMCORE_XMPP_H__
| 33.722488 | 98 | 0.752838 |
ddb8a60e485ab24f78aaf5d1e9697d97cf459f2a | 462 | h | C | src/inc/video.h | menqgingyu/Terminal-video-chat | b5804598f7d50d536ad0b43600cdecbd7723bcbe | [
"MIT"
] | 3,264 | 2015-02-07T07:15:23.000Z | 2022-03-25T21:24:54.000Z | src/inc/video.h | menqgingyu/Terminal-video-chat | b5804598f7d50d536ad0b43600cdecbd7723bcbe | [
"MIT"
] | 42 | 2015-02-09T06:18:12.000Z | 2022-02-15T23:19:44.000Z | src/inc/video.h | menqgingyu/Terminal-video-chat | b5804598f7d50d536ad0b43600cdecbd7723bcbe | [
"MIT"
] | 317 | 2015-02-09T03:19:10.000Z | 2022-03-01T01:00:16.000Z | #ifndef VIDEO_H
#define VIDEO_H
typedef struct {
int width;
int height;
int depth;
int disp_bandwidth;
int render_type;
unsigned long refresh_rate;
int intensity_threshold;
double saturation;
int monochrome;
char r; char g; char b;
char *ascii_values;
int edge_filter; int edge_lower; int edge_upper;
} vid_options_t;
void video_shutdown(int signal);
int start_video(char *peer, char *port, vid_options_t *vopt);
#endif /* VIDEO_H */
| 19.25 | 61 | 0.735931 |
dd1f2a371873e7e38155220cdc427af998a6da03 | 903 | h | C | include/ipfs/importer/importer.h | squishyhuman/c-ipfs | 7d3418e9c715e70d86c81452639a5ef239a22f31 | [
"MIT"
] | null | null | null | include/ipfs/importer/importer.h | squishyhuman/c-ipfs | 7d3418e9c715e70d86c81452639a5ef239a22f31 | [
"MIT"
] | null | null | null | include/ipfs/importer/importer.h | squishyhuman/c-ipfs | 7d3418e9c715e70d86c81452639a5ef239a22f31 | [
"MIT"
] | 1 | 2018-10-02T12:54:34.000Z | 2018-10-02T12:54:34.000Z | #ifndef __IPFS_IMPORTER_IMPORTER_H__
#define __IPFS_IMPORTER_IMPORTER_H__
#include "ipfs/merkledag/node.h"
#include "ipfs/repo/fsrepo/fs_repo.h"
/**
* Creates a node based on an incoming file
* @param root the root directory
* @param file_name the file to import (could contain a directory)
* @param node the root node (could have links to others)
* @param fs_repo the repo to use
* @param bytes_written the number of bytes written to disk
* @param recursive true(1) if you want to include files and directories
* @returns true(1) on success
*/
int ipfs_import_file(const char* root, const char* fileName, struct Node** node, struct FSRepo* fs_repo, size_t* bytes_written, int recursive);
/**
* called from the command line
* @param argc the number of arguments
* @param argv the arguments
*/
int ipfs_import_files(int argc, char** argv);
#endif /* INCLUDE_IPFS_IMPORTER_IMPORTER_H_ */
| 33.444444 | 143 | 0.754153 |
ea5ee2f4270aef2b2879e5d5ae63418f55afd0ee | 77 | h | C | external/fieldtrip-20160128/peer/src/win32/gettimeofday.h | pchrapka/brain-modelling | f232b5a858e45f10b0b0735269010454129ab017 | [
"MIT"
] | 1 | 2017-10-13T19:37:52.000Z | 2017-10-13T19:37:52.000Z | external/fieldtrip-20160128/peer/src/win32/gettimeofday.h | pchrapka/brain-modelling | f232b5a858e45f10b0b0735269010454129ab017 | [
"MIT"
] | null | null | null | external/fieldtrip-20160128/peer/src/win32/gettimeofday.h | pchrapka/brain-modelling | f232b5a858e45f10b0b0735269010454129ab017 | [
"MIT"
] | 1 | 2019-11-25T12:22:05.000Z | 2019-11-25T12:22:05.000Z | #include <time.h>
int gettimeofday(struct timeval *tv, struct timezone *tz); | 25.666667 | 58 | 0.753247 |
2d87832f7e55fae97d88d0c082229bdf91e7198c | 2,345 | h | C | ECSE/EntityManager.h | VGAD/ECSE | 70b03e2d3d9f9433d5d0bb128e3d69f962231811 | [
"MIT"
] | 5 | 2016-07-03T08:56:46.000Z | 2019-05-14T16:05:06.000Z | ECSE/EntityManager.h | VGAD/ECSE | 70b03e2d3d9f9433d5d0bb128e3d69f962231811 | [
"MIT"
] | 2 | 2015-01-08T01:44:46.000Z | 2015-01-09T00:51:35.000Z | ECSE/EntityManager.h | VGAD/ECSE | 70b03e2d3d9f9433d5d0bb128e3d69f962231811 | [
"MIT"
] | 3 | 2015-01-04T07:33:39.000Z | 2019-08-10T22:39:07.000Z | #pragma once
#include <unordered_map>
#include <boost/pool/object_pool.hpp>
#include "Entity.h"
namespace ECSE
{
//! Handles allocation and deallocation of Entities, as well as distribution of IDs.
/*!
* This class allows Entities to remain more or less tightly-packed. Ownership of the allocated
* Entities will always remain within the EntityManager.
*/
class EntityManager
{
public:
//! Destroy the EntityManager.
virtual ~EntityManager() {}
//! Create a new Entity.
/*!
* \return The ID of the new Entity.
*/
virtual Entity::ID createEntity();
//! Get a pointer to an Entity by its ID.
/*!
* Note that Entity::invalidID (0) is never a valid ID.
*
* \param id The ID of the entity to be removed.
* \return The Entity with this ID. If it's not in the EntityManager, nullptr is returned.
*/
virtual Entity* getEntity(Entity::ID id);
//! Destroy an Entity, removing it from the simulation.
/*!
* Note that this will NOT delete the Entity's Components, as this job belongs
* to the ComponentManager.
*
* \param id The ID of the entity to be removed.
*/
virtual void destroyEntity(Entity::ID id);
//! Destroy an Entity, removing it from the simulation.
/*!
* \param entity A pointer to the Entity to remove.
*/
virtual void destroyEntity(Entity* entity);
//! Get a vector of all the Entities.
/*!
* \return A vector of all Entities.
*/
virtual inline const std::vector<Entity*> getEntities() const
{
return entities;
}
//! Get the maximum number of IDs, including Entity::invalidID.
/*!
* \return The maximum number of IDs.
*/
virtual Entity::ID getMaxIDCount() const
{
return std::numeric_limits<Entity::ID>::max();
}
private:
//! The next entity ID to use.
Entity::ID nextID = Entity::invalidID + 1;
//! Map from Entity ID to a pointer to the actual Entity.
std::unordered_map<Entity::ID, Entity*> idMap;
//! Vector of all entities.
/*!
* This is redundant, but saves us from having to reconstruct it every time we
* want all entities without the IDs attached as pairs.
*/
std::vector<Entity*> entities;
//! Pool from which Entities are allocated.
boost::object_pool<Entity> entityPool;
};
}
| 26.348315 | 94 | 0.649467 |
e15a230db85e13413119dc7e78ebc8031d92e8ba | 10,725 | h | C | avt/Filters/avtMassVoxelExtractor.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | avt/Filters/avtMassVoxelExtractor.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | avt/Filters/avtMassVoxelExtractor.h | ahota/visit_ospray | d80b2e18ff5654d04bfb56ae4d6f42e45f87c9b9 | [
"BSD-3-Clause"
] | null | null | null | /*****************************************************************************
*
* Copyright (c) 2000 - 2014, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-442911
* All rights reserved.
*
* This file is part of VisIt. For details, see https://visit.llnl.gov/. The
* full copyright notice is contained in the file COPYRIGHT located at the root
* of the VisIt distribution or at http://www.llnl.gov/visit/copyright.html.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the disclaimer (as noted below) in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the LLNS/LLNL nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
* LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*****************************************************************************/
// ************************************************************************* //
// avtMassVoxelExtractor.h //
// ************************************************************************* //
#ifndef AVT_MASS_VOXEL_EXTRACTOR_H
#define AVT_MASS_VOXEL_EXTRACTOR_H
#include <filters_exports.h>
#include <avtExtractor.h>
#include <avtViewInfo.h>
#include <avtOpacityMap.h>
class vtkRectilinearGrid;
class vtkMatrix4x4;
#include <vtkMatrix3x3.h>
#include <stdlib.h>
#include <stdio.h>
#include <algorithm> // std::max
// ****************************************************************************
// Class: avtMassVoxelExtractor
//
// Purpose:
// Extracts sample points from a collection of voxels. It assumes that
// the voxels it has been given are in camera space and does not try to
// populate points that are not in the cube [-1, 1], [-1, 1], [-1, 1].
//
// Programmer: Hank Childs
// Creation: December 14, 2003
//
// Modifications:
//
// Hank Childs, Thu Feb 5 17:11:06 PST 2004
// Moved inlined constructor and destructor definitions to .C files
// because certain compilers have problems with them.
//
// Hank Childs, Fri Nov 19 14:50:58 PST 2004
// Added support for accepting grids that need to do a world space to
// image space conversion as well. Also changed API to AVTFILTERS_API.
//
// Jeremy Meredith, Thu Feb 15 11:44:28 EST 2007
// Added support for rectilinear grids with an inherent transform.
//
// Hank Childs, Fri Jun 1 15:28:14 PDT 2007
// Added support for non-scalars.
//
// Hank Childs, Wed Aug 27 11:24:53 PDT 2008
// Add support for non-floats.
//
// Hank Childs, Wed Dec 24 11:24:47 PST 2008
// Remove data member ProportionSpaceToZBufferSpace, as we now do our
// sampling in even intervals (wbuffer).
//
// Kathleen Biagas, Fri Jul 13 09:44:45 PDT 2012
// Use double internally instead of float.
//
// ****************************************************************************
class AVTFILTERS_API avtMassVoxelExtractor : public avtExtractor
{
public:
avtMassVoxelExtractor(int, int, int, avtVolume *,
avtCellList *);
virtual ~avtMassVoxelExtractor();
void Extract(vtkRectilinearGrid *,
std::vector<std::string> &varnames,
std::vector<int> &varsize);
void SetGridsAreInWorldSpace(bool, const avtViewInfo &,double,
const double *);
void SetVariableInformation(std::vector<std::string> &names,
std::vector<int> varsize);
void SetRayCastingSLIVR(bool s) {rayCastingSLIVR = s; };
void SetTrilinear(bool t) {trilinearInterpolation = t; };
void SetLighting(bool l) {lighting = l; };
void SetLightDirection(double _lightDir[3]) { for (int i=0;i<3;i++) lightDirection[i]=_lightDir[i]; }
void SetLightPosition(double _lightPos[4]) { for (int i=0;i<4;i++) lightPosition[i]=_lightPos[i]; }
void SetMatProperties(double _matProp[4]) { for (int i=0;i<4;i++) materialProperties[i]=_matProp[i]; }
void SetTransferFn(avtOpacityMap *_transferFn1D) { transferFn1D = _transferFn1D; };
void SetModelViewMatrix(double _modelViewMatrix[16]) { for (int i=0;i<16;i++) modelViewMatrix[i]=_modelViewMatrix[i]; }
void SetViewDirection(double *vd){ for (int i=0; i<3; i++) view_direction[i] = vd[i]; }
void SetViewUp(double *vu){ for (int i=0; i<3; i++) view_up[i] = vu[i]; }
// Getting the image
void getImageDimensions(int &inUse, int dims[2], int screen_ll[2], int screen_ur[2], float &avg_z);
void getComputedImage(float *image);
void setProcIdPatchID(int _proc, int _patch){ proc = _proc; patch = _patch; }
protected:
bool gridsAreInWorldSpace;
bool pretendGridsAreInWorldSpace;
avtViewInfo view;
double aspect;
double cur_clip_range[2];
vtkMatrix4x4 *view_to_world_transform;
vtkMatrix4x4 *world_to_view_transform;
double modelViewMatrix[16];
double *X;
double *Y;
double *Z;
unsigned char *ghosts;
int dims[3];
int ncell_arrays;
void *cell_arrays[AVT_VARIABLE_LIMIT];
int cell_size[AVT_VARIABLE_LIMIT];
int cell_index[AVT_VARIABLE_LIMIT];
int cell_vartypes[AVT_VARIABLE_LIMIT];
int npt_arrays;
void *pt_arrays[AVT_VARIABLE_LIMIT];
int pt_size[AVT_VARIABLE_LIMIT];
int pt_index[AVT_VARIABLE_LIMIT];
int pt_vartypes[AVT_VARIABLE_LIMIT];
double *prop_buffer;
int *ind_buffer;
bool *valid_sample;
bool trilinearInterpolation;
bool rayCastingSLIVR;
// We repeatedly divide by the term (X[i+1]-X[i]). In the interest of
// performance, cache the term 1./(X[i+1]-X[i]) and use that for faster
// multiplication. This sped up total performance by about 5%.
double *divisors_X;
double *divisors_Y;
double *divisors_Z;
bool lighting;
double lightPosition[4];
float lightDirection[3];
double materialProperties[4];
avtOpacityMap *transferFn1D;
float gradient[3];
double view_direction[3];
double view_up[3];
int debugOn;
int countt;
// Patch details for one image
int patchDrawn; // whether the patch is drawn or not
int imgWidth, imgHeight;
int imgDims[2]; // size of the patch
int imgLowerLeft[2]; // coordinates in the whole image
int imgUpperRight[2]; //
float imgDepth; // from the depth buffer
float *imgArray; // the image data
int proc; // id of the processor
int patch; // id of the patch
int fullImgWidth, fullImgHeight;
int xMin, xMax, yMin, yMax;
void ExtractImageSpaceGrid(vtkRectilinearGrid *,
std::vector<std::string> &varnames,
std::vector<int> &varsize);
void ExtractWorldSpaceGrid(vtkRectilinearGrid *,
std::vector<std::string> &varnames,
std::vector<int> &varsize);
void simpleExtractWorldSpaceGrid(vtkRectilinearGrid *, // added for raycasting slivr
std::vector<std::string> &varnames,
std::vector<int> &varsize);
void RegisterGrid(vtkRectilinearGrid*,
std::vector<std::string>&,std::vector<int>&);
void SampleAlongSegment(const double *, const double*, int, int);
void SampleVariable(int, int, int, int);
bool FrustumIntersectsGrid(int, int, int, int) const;
bool FrustumIntersectsGridSLIVR(int, int, int, int) const;
void GetSegment(int, int, double *, double *) const;
static void FindPlaneNormal(const double *, const double *,
const double *, double *);
bool GridOnPlusSideOfPlane(const double *, const double *) const;
bool FindSegmentIntersections(const double *, const double *,
int &, int &);
void computePixelColor(double source_rgb[4], double dest_rgb[4]);
double trilinearInterpolate(double vals[8], float distRight, float distTop, float distBack);
void computeIndices(int dims[3], int indices[6], int returnIndices[8]);
void computeIndicesVert(int dims[3], int indices[6], int returnIndices[8]);
void getIndexandDistFromCenter(float dist, int index, int &index_before, int &index_after, float &dist_before, float &dist_after);
};
#endif
| 46.030043 | 152 | 0.575571 |
f6f9cb7900fd3019bdcd56bd0ca792dab72597b4 | 545 | c | C | scripts/help/helpBack.c | HelpGiveThanks/Library | af33bf0085c6a025c2bb134044d5a493365c24a8 | [
"Apache-2.0"
] | null | null | null | scripts/help/helpBack.c | HelpGiveThanks/Library | af33bf0085c6a025c2bb134044d5a493365c24a8 | [
"Apache-2.0"
] | 31 | 2015-12-09T04:30:43.000Z | 2018-07-26T23:23:10.000Z | scripts/help/helpBack.c | HelpGiveThanks/Library | af33bf0085c6a025c2bb134044d5a493365c24a8 | [
"Apache-2.0"
] | null | null | null | January 19, 2018 1:23:58 Library.fmp12 - helpBack -1-
help: helpBack
#
#This script functions like a browsers back button
#script, taking users back thru help windows bread
#crumb style.
If [ ValueCount ( tempSetup::helpName ) = 1 ]
Exit Script [ ]
Else
Set Variable [ $value1; Value:GetValue ( tempSetup::helpName ; ValueCount ( tempSetup::helpName ) ) ]
Set Field [ tempSetup::helpName; Substitute ( $value1 ; tempSetup::helpName ; "" &¶ ) ]
Set Variable [ $value1; Value:GetValue ( tempSetup::helpName ; 1 ) ]
Go to Layout [ $value1 ]
End If
| 36.333333 | 101 | 0.713761 |
919b2b4c08fb0e7b45040713f8d4140d37d6d65a | 10,096 | h | C | iOS/10.0.2/Frameworks/UIKit.framework/_UIFloatingContentView.h | onmyway133/Runtime-Headers | e9b80e7ab9103f37ad421ad6b8b58ee06369d21f | [
"MIT"
] | 30 | 2016-10-09T20:13:00.000Z | 2022-01-24T04:14:57.000Z | iOS/10.0.2/Frameworks/UIKit.framework/_UIFloatingContentView.h | onmyway133/Runtime-Headers | e9b80e7ab9103f37ad421ad6b8b58ee06369d21f | [
"MIT"
] | null | null | null | iOS/10.0.2/Frameworks/UIKit.framework/_UIFloatingContentView.h | onmyway133/Runtime-Headers | e9b80e7ab9103f37ad421ad6b8b58ee06369d21f | [
"MIT"
] | 7 | 2017-08-29T14:41:25.000Z | 2022-01-19T17:14:54.000Z | /* Generated by RuntimeBrowser
Image: /System/Library/Frameworks/UIKit.framework/UIKit
*/
@interface _UIFloatingContentView : UIView {
bool __disableOutsetShadowPath;
struct CGSize {
double width;
double height;
} _asymmetricFocusedSizeIncrease;
struct CGSize {
double width;
double height;
} _asymmetricScaleFactor;
struct __CFDictionary { } * _backgroundColorsByState;
_UIFloatingContentSpecialAnimatingView * _containerView;
NSMutableArray * _contentMotionEffects;
bool _contentOpaque;
struct CGPoint {
double x;
double y;
} _contentRotation;
struct CGPoint {
double x;
double y;
} _contentTranslation;
UIView * _contentView;
unsigned long long _controlState;
double _cornerRadius;
bool _customScale;
<_UIFloatingContentViewDelegate> * _floatingContentViewDelegate;
_UIFocusAnimationConfiguration * _focusAnimationConfiguration;
id /* block */ _focusAnimationConfigurationHandler;
struct CGPoint {
double x;
double y;
} _focusDirection;
struct CGPoint {
double x;
double y;
} _focusScaleAnchorPoint;
long long _highlightStyle;
_UIFloatingContentSpecialAnimatingView * _highlightView;
bool _roundContentWhenDeselected;
bool _scalesBackwards;
struct CGRect {
struct CGPoint {
double x;
double y;
} origin;
struct CGSize {
double width;
double height;
} size;
} _shadowContentsCenter;
bool _shadowEnabled;
struct CGSize {
double width;
double height;
} _shadowExpansion;
UIImage * _shadowImage;
double _shadowOpacityDark;
double _shadowOpacityLight;
double _shadowRadius;
struct CGSize {
double width;
double height;
} _shadowSize;
double _shadowVerticalOffset;
UIView * _shadowView;
bool _stretchableShadowImage;
bool _symmetricScale;
struct CGSize {
double width;
double height;
} _unfocusedShadowExpansion;
double _unfocusedShadowOpacity;
double _unfocusedShadowRadius;
double _unfocusedShadowVerticalOffset;
bool _useShadowImage;
_UIFloatingContentSpecialAnimatingView * _visualEffectContainerView;
double _visualEffectContainerViewScaleFactor;
}
@property (nonatomic) bool _disableOutsetShadowPath;
@property (nonatomic) struct CGSize { double x1; double x2; } asymmetricFocusedSizeIncrease;
@property (nonatomic) struct CGSize { double x1; double x2; } asymmetricScaleFactor;
@property (nonatomic) bool clipsContentToBounds;
@property (getter=isContentOpaque, nonatomic) bool contentOpaque;
@property (nonatomic, readonly) UIView *contentView;
@property (nonatomic) unsigned long long controlState;
@property (nonatomic) double cornerRadius;
@property (nonatomic) <_UIFloatingContentViewDelegate> *floatingContentDelegate;
@property (nonatomic, copy) _UIFocusAnimationConfiguration *focusAnimationConfiguration;
@property (nonatomic, copy) id /* block */ focusAnimationConfigurationHandler;
@property (nonatomic) struct CGPoint { double x1; double x2; } focusScaleAnchorPoint;
@property (nonatomic) double focusedSizeIncrease;
@property (nonatomic) long long highlightStyle;
@property (nonatomic) bool roundContentWhenDeselected;
@property (nonatomic) double scaleFactor;
@property (nonatomic) bool scalesBackwards;
@property (nonatomic) struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; } shadowContentsCenter;
@property (getter=isShadowEnabled, nonatomic) bool shadowEnabled;
@property (nonatomic) struct CGSize { double x1; double x2; } shadowExpansion;
@property (nonatomic, retain) UIImage *shadowImage;
@property (nonatomic) double shadowOpacity;
@property (nonatomic) double shadowRadius;
@property (nonatomic) struct CGSize { double x1; double x2; } shadowSize;
@property (nonatomic) double shadowVerticalOffset;
@property (nonatomic) struct CGSize { double x1; double x2; } unfocusedShadowExpansion;
@property (nonatomic) double unfocusedShadowOpacity;
@property (nonatomic) double unfocusedShadowRadius;
@property (nonatomic) double unfocusedShadowVerticalOffset;
@property (nonatomic) bool useShadowImage;
@property (nonatomic, readonly) UIView *visualEffectContainerView;
@property (nonatomic) double visualEffectContainerViewScaleFactor;
+ (id)_defaultFocusAnimationConfiguration;
+ (Class)layerClass;
- (void).cxx_destruct;
- (bool)_applyKeyPathsAndRelativeValues:(id)arg1 forMotionEffect:(id)arg2;
- (double)_currentShadowOpacity;
- (bool)_disableOutsetShadowPath;
- (double)_effectiveShadowOpacity;
- (double)_effectiveShadowRadius;
- (void)_installContentMotionEffects;
- (void)_layoutShadow;
- (id)_preferredConfigurationForFocusAnimation:(long long)arg1 inContext:(id)arg2;
- (unsigned long long)_primaryStateForState:(unsigned long long)arg1;
- (void)_setControlState:(unsigned long long)arg1 withAnimationCoordinator:(id)arg2;
- (void)_setShadowImageIfNeeded;
- (struct CGPath { }*)_shadowPathForSize:(struct CGSize { double x1; double x2; })arg1 radius:(double)arg2;
- (bool)_shouldAppearToFloatForPrimaryState:(unsigned long long)arg1;
- (bool)_shouldApplyCornerRadiusForPrimaryState:(unsigned long long)arg1;
- (void)_uninstallContentMotionEffects;
- (void)_updateBackgroundViewForPrimaryState:(unsigned long long)arg1;
- (void)_updateHighlightViewForPrimaryState:(unsigned long long)arg1;
- (void)_updateScaleFactor;
- (void)_updateShadowContentsScaleForPrimaryState:(unsigned long long)arg1;
- (void)_updateShadowLayer;
- (void)_updateShadowOpacityForPrimaryState:(unsigned long long)arg1;
- (void)_updateTransformForPrimaryState:(unsigned long long)arg1;
- (void)addContentMotionEffect:(id)arg1;
- (struct CGSize { double x1; double x2; })asymmetricFocusedSizeIncrease;
- (struct CGSize { double x1; double x2; })asymmetricScaleFactor;
- (id)backgroundColorForState:(unsigned long long)arg1;
- (bool)canBecomeFocused;
- (bool)clipsContentToBounds;
- (id)contentView;
- (unsigned long long)controlState;
- (double)cornerRadius;
- (void)dealloc;
- (id)floatingContentDelegate;
- (id)focusAnimationConfiguration;
- (id /* block */)focusAnimationConfigurationHandler;
- (struct CGPoint { double x1; double x2; })focusScaleAnchorPoint;
- (double)focusedSizeIncrease;
- (long long)highlightStyle;
- (id)initWithFrame:(struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; })arg1;
- (bool)isContentOpaque;
- (bool)isShadowEnabled;
- (void)layoutSubviews;
- (void)removeContentMotionEffect:(id)arg1;
- (bool)roundContentWhenDeselected;
- (double)scaleFactor;
- (bool)scalesBackwards;
- (void)setAsymmetricFocusedSizeIncrease:(struct CGSize { double x1; double x2; })arg1;
- (void)setAsymmetricScaleFactor:(struct CGSize { double x1; double x2; })arg1;
- (void)setBackgroundColor:(id)arg1 forState:(unsigned long long)arg2;
- (void)setBounds:(struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; })arg1;
- (void)setClipsContentToBounds:(bool)arg1;
- (void)setContentMotionRotation:(struct CGPoint { double x1; double x2; })arg1 translation:(struct CGPoint { double x1; double x2; })arg2;
- (void)setContentOpaque:(bool)arg1;
- (void)setControlState:(unsigned long long)arg1;
- (void)setControlState:(unsigned long long)arg1 animated:(bool)arg2;
- (void)setControlState:(unsigned long long)arg1 withAnimationCoordinator:(id)arg2;
- (void)setCornerRadius:(double)arg1;
- (void)setFloatingContentDelegate:(id)arg1;
- (void)setFocusAnimationConfiguration:(id)arg1;
- (void)setFocusAnimationConfigurationHandler:(id /* block */)arg1;
- (void)setFocusScaleAnchorPoint:(struct CGPoint { double x1; double x2; })arg1;
- (void)setFocusedSizeIncrease:(double)arg1;
- (void)setFrame:(struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; })arg1;
- (void)setHighlightStyle:(long long)arg1;
- (void)setRoundContentWhenDeselected:(bool)arg1;
- (void)setScaleFactor:(double)arg1;
- (void)setScalesBackwards:(bool)arg1;
- (void)setShadowContentsCenter:(struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; })arg1;
- (void)setShadowEnabled:(bool)arg1;
- (void)setShadowExpansion:(struct CGSize { double x1; double x2; })arg1;
- (void)setShadowImage:(id)arg1;
- (void)setShadowImage:(id)arg1 stretchable:(bool)arg2;
- (void)setShadowOpacity:(double)arg1;
- (void)setShadowOpacity:(double)arg1 forUserInterfaceStyle:(long long)arg2;
- (void)setShadowRadius:(double)arg1;
- (void)setShadowSize:(struct CGSize { double x1; double x2; })arg1;
- (void)setShadowVerticalOffset:(double)arg1;
- (void)setUnfocusedShadowExpansion:(struct CGSize { double x1; double x2; })arg1;
- (void)setUnfocusedShadowOpacity:(double)arg1;
- (void)setUnfocusedShadowRadius:(double)arg1;
- (void)setUnfocusedShadowVerticalOffset:(double)arg1;
- (void)setUseShadowImage:(bool)arg1;
- (void)setVisualEffectContainerViewScaleFactor:(double)arg1;
- (void)set_disableOutsetShadowPath:(bool)arg1;
- (struct CGRect { struct CGPoint { double x_1_1_1; double x_1_1_2; } x1; struct CGSize { double x_2_1_1; double x_2_1_2; } x2; })shadowContentsCenter;
- (struct CGSize { double x1; double x2; })shadowExpansion;
- (id)shadowImage;
- (double)shadowOpacity;
- (double)shadowOpacityForUserInterfaceStyle:(long long)arg1;
- (double)shadowRadius;
- (struct CGSize { double x1; double x2; })shadowSize;
- (double)shadowVerticalOffset;
- (void)traitCollectionDidChange:(id)arg1;
- (struct CGSize { double x1; double x2; })unfocusedShadowExpansion;
- (double)unfocusedShadowOpacity;
- (double)unfocusedShadowRadius;
- (double)unfocusedShadowVerticalOffset;
- (bool)useShadowImage;
- (id)visualEffectContainerView;
- (double)visualEffectContainerViewScaleFactor;
@end
| 45.071429 | 170 | 0.759509 |
bccaedceacabeca262931aa9a2b0cc02f4f6e4eb | 1,148 | c | C | MiniProject_C/3_Implementation/src/searchbyfood.c | udupaAnusha/MiniProject_LTTS | fcc265c6a498311046c4a1351ffa95c697c8261a | [
"CC0-1.0"
] | null | null | null | MiniProject_C/3_Implementation/src/searchbyfood.c | udupaAnusha/MiniProject_LTTS | fcc265c6a498311046c4a1351ffa95c697c8261a | [
"CC0-1.0"
] | null | null | null | MiniProject_C/3_Implementation/src/searchbyfood.c | udupaAnusha/MiniProject_LTTS | fcc265c6a498311046c4a1351ffa95c697c8261a | [
"CC0-1.0"
] | null | null | null | // Function to implement the
// search by food
void search_by_food()
{
total = 0;
// Initialize all the hotels
// and their foods
hotel_initialize();
while (1) {
printf("\n\nPlease choose the ");
printf("food\n\n1) %s\t%d\n2) %s\t%d",
m[1].first_food, m[1].first,
m[1].second_food, m[1].second);
printf("\n3) %s\t%d\n4) %s\t%d\n",
m[1].third_food, m[1].third,
m[2].first_food, m[2].first);
printf("5) %s\t%d\n6) %s\t%d\n",
m[2].second_food, m[2].second,
m[2].third_food, m[2].third);
printf("7) %s\t%d\n8) %s\t%d\n",
m[3].first_food, m[3].first,
m[3].second_food, m[3].second);
printf("9) %s\t%d\n10) Cart\n",
m[3].third_food,
m[3].third);
printf("11) Exit");
printf("\nPlease Enter Your Choice\t");
scanf("%d", &food);
if (food > 10) {
printf("Please Enter the ");
printf("valid choice\n\n");
search_by_food();
}
// Moves to the cart
// functionality
else if (food == 10)
cart();
else if (food == 11)
exit(1);
// Call food_order functionality
// to get the no of foods and
// to calculat the total
// amount of the order.
else
food_order(food);
}
}
| 22.076923 | 41 | 0.587108 |
1bc869a092b9e62ef6e6b84a77e799979309cf57 | 3,090 | c | C | external/esp_idf_port/wpa_supplicant/src/wpa2/utils/ext_password.c | ziyik/TizenRT-1 | d510c03303fcfa605bc12c60f826fa5642bbe406 | [
"Apache-2.0"
] | 511 | 2017-03-29T09:14:09.000Z | 2022-03-30T23:10:29.000Z | external/esp_idf_port/wpa_supplicant/src/wpa2/utils/ext_password.c | ziyik/TizenRT-1 | d510c03303fcfa605bc12c60f826fa5642bbe406 | [
"Apache-2.0"
] | 4,673 | 2017-03-29T10:43:43.000Z | 2022-03-31T08:33:44.000Z | external/esp_idf_port/wpa_supplicant/src/wpa2/utils/ext_password.c | ziyik/TizenRT-1 | d510c03303fcfa605bc12c60f826fa5642bbe406 | [
"Apache-2.0"
] | 642 | 2017-03-30T20:45:33.000Z | 2022-03-24T17:07:33.000Z | /******************************************************************
*
* Copyright 2019 Samsung Electronics All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************/
/*
* External password backend
* Copyright (c) 2012, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "wpa/includes.h"
#include "wpa/common.h"
#include "wpa2/utils/ext_password_i.h"
#ifdef CONFIG_EXT_PASSWORD_TEST
extern struct ext_password_backend ext_password_test;
#endif /* CONFIG_EXT_PASSWORD_TEST */
#ifdef CONFIG_EXT_PASSWORD
static const struct ext_password_backend *backends[] = {
#ifdef CONFIG_EXT_PASSWORD_TEST
&ext_password_test,
#endif /* CONFIG_EXT_PASSWORD_TEST */
NULL
};
#endif
struct ext_password_data {
const struct ext_password_backend *backend;
void *priv;
};
#ifdef CONFIG_EXT_PASSWORD
struct ext_password_data * ext_password_init(const char *backend,
const char *params)
{
struct ext_password_data *data;
int i;
data = (struct ext_password_data *)os_zalloc(sizeof(*data));
if (data == NULL)
return NULL;
for (i = 0; backends[i]; i++) {
if (os_strcmp(backends[i]->name, backend) == 0) {
data->backend = backends[i];
break;
}
}
if (!data->backend) {
os_free(data);
return NULL;
}
data->priv = data->backend->init(params);
if (data->priv == NULL) {
os_free(data);
return NULL;
}
return data;
}
void ext_password_deinit(struct ext_password_data *data)
{
if (data && data->backend && data->priv)
data->backend->deinit(data->priv);
os_free(data);
}
struct wpabuf * ext_password_get(struct ext_password_data *data,
const char *name)
{
if (data == NULL)
return NULL;
return data->backend->get(data->priv, name);
}
#endif /* CONFIG_EXT_PASSWORD */
struct wpabuf * ext_password_alloc(size_t len)
{
struct wpabuf *buf;
buf = wpabuf_alloc(len);
if (buf == NULL)
return NULL;
#ifdef __linux__
if (mlock(wpabuf_head(buf), wpabuf_len(buf)) < 0) {
wpa_printf(MSG_ERROR, "EXT PW: mlock failed: %s",
strerror(errno));
}
#endif /* __linux__ */
return buf;
}
#ifdef CONFIG_EXT_PASSWORD
void ext_password_free(struct wpabuf *pw)
{
if (pw == NULL)
return;
os_memset(wpabuf_mhead(pw), 0, wpabuf_len(pw));
#ifdef __linux__
if (munlock(wpabuf_head(pw), wpabuf_len(pw)) < 0) {
wpa_printf(MSG_ERROR, "EXT PW: munlock failed: %s",
strerror(errno));
}
#endif /* __linux__ */
wpabuf_free(pw);
}
#endif /* CONFIG_EXT_PASSWORD */
| 23.233083 | 75 | 0.677023 |
09a2bec55c04969f2f29e153d8879f0b065ed25d | 4,879 | c | C | qmk_firmware/keyboards/xd75/keymaps/clanghans/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | null | null | null | qmk_firmware/keyboards/xd75/keymaps/clanghans/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | null | null | null | qmk_firmware/keyboards/xd75/keymaps/clanghans/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | null | null | null | /* Copyright 2020 Chris Langhans
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
// Layer shorthand
#define _QW 0
#define _FN 1
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* QWERTY
* ┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┐
* │ Esc │ 1 │ 2 │ 3 │ 4 │ 5 │ Bsp │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ ~ │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ Tab │ Q │ W │ E │ R │ T │ Del │ Y │ U │ I │ O │ P │ [ │ ] │ \ │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ Ctrl │ A │ S │ D │ F │ G │ │ H │ J │ K │ L │ ; │ ' │ Home │ PgUp │
* ├──────┼──────┼──────┼──────┼──────┼──────┼Enter ┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ Shift│ Z │ X │ C │ V │ B │ │ N │ M │ , │ . │ / │ Shft │ End │ PgDn │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ Ctrl │ Gui │ Alt │ FN │ Bsp │ N/A │ Space │ Alt │ Ctrl │ Left │ Down │ Up │ Right│
* └──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┘
*/
[_QW] = LAYOUT(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_BSPC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_GRV,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_DEL, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_ENT, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_HOME, KC_PGUP,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, XXXXXXX, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_END, KC_PGDN,
KC_LCTL, KC_LGUI, KC_LALT, MO(_FN), XXXXXXX, KC_BSPC, XXXXXXX, KC_SPC, XXXXXXX, KC_RALT, KC_RCTL, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT
),
/* FUNCTION
* ┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┐
* │Alt F4│ F1 │ F2 │ F3 │ F4 │ F5 │ │ F6 │ F7 │ F8 │ F9 │ F10 │ F11 │ F12 │ # Lk │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ │ │ │ │RGBHUI│BL_TOG│ │ 7 │ 8 │ 9 │ / │ │ │ │ │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ │ │ │ │RGBSAI│RGBMOD│ │ 4 │ 5 │ 6 │ * │ │ │ │Reset │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ │ │ │ │RGBVAI│ │ │ 1 │ 2 │ 3 │ - │ │ │ │ │
* ├──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
* │ │ │ │ │ │ │ │ 0 │ │ , │ + │ │ │ │ │
* └──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┘
*/
[_FN] = LAYOUT(
LALT(KC_F4), KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NLCK,
_______, _______, _______, _______, RGB_HUI, RGB_TOG, _______, KC_P7, KC_P8, KC_P9, KC_PSLS, _______, _______, _______, _______,
_______, _______, _______, _______, RGB_SAI, RGB_MOD, _______, KC_P4, KC_P5, KC_P6, KC_PAST, _______, _______, _______, RESET,
_______, _______, _______, _______, RGB_VAI, _______, _______, KC_P1, KC_P2, KC_P3, KC_PMNS, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, KC_P0, _______, KC_PDOT, KC_PPLS, _______, _______, _______, _______
)
};
| 75.061538 | 146 | 0.35663 |
4ea62218826baf7e6a571aa414e3249dfc46c512 | 58,280 | c | C | modules/synApps_5_6/support/dxp-3-1/dxpApp/handelSrc/handel_xerxes.c | A2-Collaboration/epics | b764a53bf449d9f6b54a1173c5e75a22cf95098c | [
"OML"
] | null | null | null | modules/synApps_5_6/support/dxp-3-1/dxpApp/handelSrc/handel_xerxes.c | A2-Collaboration/epics | b764a53bf449d9f6b54a1173c5e75a22cf95098c | [
"OML"
] | null | null | null | modules/synApps_5_6/support/dxp-3-1/dxpApp/handelSrc/handel_xerxes.c | A2-Collaboration/epics | b764a53bf449d9f6b54a1173c5e75a22cf95098c | [
"OML"
] | null | null | null | /*
* Copyright (c) 2002-2004 X-ray Instrumentation Associates
* 2005-2011 XIA LLC
* All rights reserved
*
* Redistribution and use in source and binary forms,
* with or without modification, are permitted provided
* that the following conditions are met:
*
* * Redistributions of source code must retain the above
* copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
* * Neither the name of XIA LLC
* nor the names of its contributors may be used to endorse
* or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id$
*
*/
#include <stdio.h>
#include <limits.h>
#include "xerxes.h"
#include "xerxes_errors.h"
#include "xia_handel.h"
#include "xia_system.h"
#include "xia_assert.h"
#include "xia_handel_structures.h"
#include "handel_errors.h"
#include "handel_xerxes.h"
#include "handel_generic.h"
#include "handel_log.h"
#include "fdd.h"
HANDEL_STATIC int xia__GetSystemFPGAName(Module *module, char *detType,
char *sysFPGAName, char *rawFilename,
boolean_t *found);
HANDEL_STATIC int xia__GetSystemDSPName(Module *module, char *detType,
char *sysDSPName, char *rawFilename,
boolean_t *found);
HANDEL_STATIC int xia__GetDSPName(Module *module, int channel,
double peakingTime, char *dspName,
char *detectorType, char *rawFilename);
HANDEL_STATIC int xia__GetFiPPIAName(Module *module, char *detType,
char *sysDSPName, char *rawFilename,
boolean_t *found);
HANDEL_STATIC int xia__GetFiPPIName(Module *module, int channel,
double peakingTime, char *fippiName,
char *detectorType, char *rawFilename);
HANDEL_STATIC int xia__GetSystemFiPPIName(Module *module, char *detType,
char *sysFipName, char *rawFilename,
boolean_t *found);
HANDEL_STATIC int xia__CopyInterfString(Module *m, char *interf);
HANDEL_STATIC int xia__CopyMDString(Module *m, char *md);
HANDEL_STATIC int xia__CopyChanString(Module *m, char *chan);
HANDEL_STATIC int xia__AddXerxesSysItems(void);
HANDEL_STATIC int xia__AddXerxesBoardType(Module *m);
HANDEL_STATIC int xia__AddXerxesInterface(Module *m);
HANDEL_STATIC int xia__AddXerxesModule(Module *m);
HANDEL_STATIC int xia__AddXerxesParams(Module *m);
HANDEL_STATIC int xia__AddSystemFPGA(Module *module, char *sysFPGAName,
char *rawFilename);
HANDEL_STATIC int xia__AddSystemDSP(Module *module, char *sysDSPName,
char *rawFilename);
HANDEL_STATIC int xia__AddFiPPIA(Module *module, char *sysDSPName,
char *rawFilename);
HANDEL_STATIC int xia__AddSystemFiPPI(Module *module, char *sysFipName,
char *rawFilename);
HANDEL_STATIC int xia__DoMMUConfig(Module *m);
HANDEL_STATIC int xia__DoSystemFPGA(Module *m);
HANDEL_STATIC int xia__DoSystemDSP(Module *m, boolean_t *found);
HANDEL_STATIC int xia__DoDSP(Module *m);
HANDEL_STATIC int xia__DoFiPPIA(Module *m, boolean_t *found);
HANDEL_STATIC int xia__DoFiPPI(Module *m);
HANDEL_STATIC int xia__DoSystemFiPPI(Module *m, boolean_t *found);
HANDEL_STATIC int xia__GetDetStringFromDetChan(int detChan, Module *m,
char *type);
/*****************************************************************************
*
* This routine calls the XerXes fit routine. See XerXes for more details.
*
*****************************************************************************/
HANDEL_EXPORT int HANDEL_API xiaFitGauss(long data[], int lower, int upper, float *pos, float *fwhm)
{
int statusX;
statusX = dxp_fitgauss0(data, &lower, &upper, pos, fwhm);
if (statusX != XIA_SUCCESS)
{
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/*****************************************************************************
*
* This routine calls the XerXes find peak routine. See XerXes for more
* details.
*
*****************************************************************************/
HANDEL_EXPORT int HANDEL_API xiaFindPeak(long *data, int numBins, float thresh, int *lower, int *upper)
{
int statusX;
statusX = dxp_findpeak(data, &numBins, &thresh, lower, upper);
if (statusX != XIA_SUCCESS)
{
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/*****************************************************************************
*
* This routine calls XerXes routines in order to build a proper XerXes
* configuration based on the HanDeL information.
*
*****************************************************************************/
HANDEL_SHARED int HANDEL_API xiaBuildXerxesConfig(void)
{
int statusX;
int status;
boolean_t found;
boolean_t isSysFip;
Module *current = NULL;
statusX = dxp_init_ds();
if (statusX != DXP_SUCCESS) {
xiaLogError("xiaBuildXerxesConfig", "Error initializing Xerxes internal "
"data structures", XIA_XERXES);
return XIA_XERXES;
}
status = xia__AddXerxesSysItems();
if (status != XIA_SUCCESS) {
xiaLogError("xiaBuildXerxesConfig", "Error adding system items to Xerxes "
"configuration", status);
return status;
}
/* Walk through the module list and make the proper calls to XerXes */
current = xiaGetModuleHead();
while (current != NULL) {
status = xia__AddXerxesBoardType(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding board type for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
status = xia__AddXerxesInterface(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding interface for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
status = xia__AddXerxesModule(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding module for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
/* This section begins the firmware configuration area. Not all firmwares
* are required for each product, but we check to see what is available
* and we add it to the configuration if it is found.
*/
status = xia__DoMMUConfig(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding MMU for alias = '%s'", current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
status = xia__DoSystemFiPPI(current, &isSysFip);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System FiPPI for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
status = xia__DoSystemFPGA(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System FPGA for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
status = xia__DoSystemDSP(current, &found);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System DSP for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
/* If we didn't find a system DSP then we assume that the hardware supports
* a single DSP for each channel.
*/
if (!found && !isSysFip) {
status = xia__DoDSP(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding DSPs for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
}
status = xia__DoFiPPIA(current, &found);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding FiPPI A for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
if (!found && !isSysFip) {
status = xia__DoFiPPI(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding FiPPIs for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
}
status = xia__AddXerxesParams(current);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding params for alias = '%s'",
current->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, status);
return status;
}
current = getListNext(current);
}
return XIA_SUCCESS;
}
/*****************************************************************************
*
* Essentially a wrapper around dxp_user_setup().
*
*****************************************************************************/
HANDEL_SHARED int HANDEL_API xiaUserSetup(void)
{
int statusX;
int status;
int detector_chan;
unsigned int modChan;
unsigned short polarity;
unsigned short type;
double typeValue;
char boardType[MAXITEM_LEN];
char detectorType[MAXITEM_LEN];
char *alias;
char *detAlias;
char *firmAlias;
DetChanElement *current = NULL;
FirmwareSet *firmwareSet = NULL;
CurrentFirmware *currentFirmware = NULL;
Module *module = NULL;
Detector *detector = NULL;
XiaDefaults *defaults = NULL;
PSLFuncs localFuncs;
statusX = dxp_user_setup();
if (statusX != DXP_SUCCESS) {
xiaLogError("xiaUserSetup", "Error downloading firmware via Xerxes.",
XIA_XERXES);
return XIA_XERXES;
}
/* Clear the setup flag for all modules. */
module = xiaGetModuleHead();
ASSERT(module);
while (module != NULL) {
module->isSetup = FALSE_;
module = getListNext(module);
}
module = NULL;
/* Set polarity and reset time from info in detector struct */
current = xiaGetDetChanHead();
while (current != NULL) {
switch (xiaGetElemType(current->detChan)) {
case SET:
/* Skip SETs since all SETs are composed of SINGLES */
break;
case SINGLE:
status = xiaGetBoardType(current->detChan, boardType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to get board type for detChan %d.",
current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
alias = xiaGetAliasFromDetChan(current->detChan);
module = xiaFindModule(alias);
ASSERT(module);
modChan = xiaGetModChan((unsigned int)current->detChan);
firmAlias = module->firmware[modChan];
firmwareSet = xiaFindFirmware(firmAlias);
detAlias = module->detector[modChan];
detector_chan = module->detector_chan[modChan];
detector = xiaFindDetector(detAlias);
polarity = detector->polarity[detector_chan];
type = detector->type;
typeValue = detector->typeValue[detector_chan];
currentFirmware = &module->currentFirmware[modChan];
defaults = xiaGetDefaultFromDetChan((unsigned int)current->detChan);
switch (detector->type) {
case XIA_DET_RESET:
strcpy(detectorType, "RESET");
break;
case XIA_DET_RCFEED:
strcpy(detectorType, "RC");
break;
default:
case XIA_DET_UNKNOWN:
sprintf(info_string, "No detector type specified for "
"detChan %d.", current->detChan);
xiaLogError("xiaSetAcquisitionValues", info_string,
XIA_MISSING_TYPE);
return XIA_MISSING_TYPE;
break;
}
status = xiaLoadPSL(boardType, &localFuncs);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to load PSL funcs for "
"detChan %d.", current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
status = localFuncs.setPolarity(current->detChan, detector,
detector_chan, defaults, module);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to set polarity for detChan %d.",
current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
status = localFuncs.setDetectorTypeValue(current->detChan,
detector, detector_chan,
defaults);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to set detector type value ('%s' "
"detector) for detChan %d.", detectorType,
current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
status = localFuncs.userSetup(current->detChan, defaults,
firmwareSet, currentFirmware,
detectorType, detector, detector_chan,
module, modChan);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to complete user setup for "
"detChan %d.", current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
module->isSetup = TRUE_;
/* Do any DSP parameters that are in the list */
status = xiaUpdateUserParams(current->detChan);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Unable to update user parameters for "
"detChan %d.", current->detChan);
xiaLogError("xiaUserSetup", info_string, status);
return status;
}
break;
case 999:
sprintf(info_string, "detChan %d is not valid.", current->detChan);
xiaLogError("xiaUserSetup", info_string, XIA_INVALID_DETCHAN);
return XIA_INVALID_DETCHAN;
break;
default:
FAIL();
break;
}
current = getListNext(current);
}
return XIA_SUCCESS;
}
/** @brief Copy the interface specfic information into the target string.
*
* Assumes that @a interf has already been allocated to the proper size. This
* routine is meant to encapsulate all of the product-specific logic in it.
*/
HANDEL_STATIC int xia__CopyInterfString(Module *m, char *interf)
{
ASSERT(m != NULL);
ASSERT(interf != NULL);
switch (m->interface_info->type) {
case NO_INTERFACE:
default:
sprintf(info_string, "No interface string specified for alias '%s'",
m->alias);
xiaLogError("xia__CopyInterfString", info_string, XIA_MISSING_INTERFACE);
return XIA_MISSING_INTERFACE;
break;
#ifndef EXCLUDE_CAMAC
case JORWAY73A:
case GENERIC_SCSI:
strcpy(interf, "camacdll.dll");
break;
#endif /* EXCLUDE_CAMAC */
#ifndef EXCLUDE_EPP
case EPP:
case GENERIC_EPP:
sprintf(interf, "%#x", m->interface_info->info.epp->epp_address);
break;
#endif /* EXCLUDE_EPP */
#ifndef EXCLUDE_USB
case USB:
sprintf(interf, "%u", m->interface_info->info.usb->device_number);
break;
#endif /* EXCLUDE_USB */
#ifndef EXCLUDE_USB2
case USB2:
sprintf(interf, "%u", m->interface_info->info.usb2->device_number);
break;
#endif /* EXCLUDE_USB2 */
#ifndef EXCLUDE_SERIAL
case SERIAL:
sprintf(interf, "COM%u", m->interface_info->info.serial->com_port);
break;
#endif /* EXCLUDE_SERIAL */
#ifndef EXCLUDE_PLX
case PLX:
sprintf(interf, "pxi");
break;
#endif /* EXCLUDE_PLX */
}
return XIA_SUCCESS;
}
/** @brief Builds the MD string required by Xerxes.
*
* Assumes that @a md has already been allocated. This routine is meant to
* encapsulate all of the hardware specific logic for building the MD string.
*
*/
HANDEL_STATIC int xia__CopyMDString(Module *m, char *md)
{
ASSERT(m != NULL);
ASSERT(md != NULL);
switch (m->interface_info->type) {
case NO_INTERFACE:
default:
sprintf(info_string, "No interface string specified for alias '%s'",
m->alias);
xiaLogError("xia__CopyMDString", info_string, XIA_MISSING_INTERFACE);
return XIA_MISSING_INTERFACE;
break;
#ifndef EXCLUDE_CAMAC
case JORWAY73A:
case GENERIC_SCSI:
sprintf(md, "%u%u%02u", m->interface_info->info.jorway73a->scsi_bus,
m->interface_info->info.jorway73a->crate_number,
m->interface_info->info.jorway73a->slot);
break;
#endif /* EXCLUDE_CAMAC */
#ifndef EXCLUDE_EPP
case EPP:
case GENERIC_EPP:
/* If default then dont change anything, else tack on a : in front
* of the string (tells XerXes to
* treat this as a multi-module EPP chain
*/
if (m->interface_info->info.epp->daisy_chain_id == UINT_MAX) {
sprintf(md, "0");
} else {
sprintf(md, ":%u", m->interface_info->info.epp->daisy_chain_id);
}
break;
#endif /* EXCLUDE_EPP */
#ifndef EXCLUDE_USB
case USB:
sprintf(md, "%u", m->interface_info->info.usb->device_number);
break;
#endif /* EXCLUDE_USB */
#ifndef EXCLUDE_USB2
case USB2:
sprintf(md, "%u", m->interface_info->info.usb2->device_number);
break;
#endif /* EXCLUDE_USB2 */
#ifndef EXCLUDE_SERIAL
case SERIAL:
sprintf(md, "%u:%u", m->interface_info->info.serial->com_port,
m->interface_info->info.serial->baud_rate);
break;
#endif /* EXCLUDE_SERIAL */
#ifndef EXCLUDE_PLX
case PLX:
sprintf(md, "%u:%u", m->interface_info->info.plx->bus,
m->interface_info->info.plx->slot);
break;
#endif /* EXCLUDE_PLX */
}
return XIA_SUCCESS;
}
/** @brief Get the DSP name for the specified channel.
*
* If no FDD file is specified, then the DSP name is retrieved from the firmware
* Structure. Otherwise, the DSP code is retrieved from the FDD file using
* the FDD library.
*
*/
HANDEL_STATIC int xia__GetDSPName(Module *module, int channel,
double peakingTime, char *dspName,
char *detectorType, char *rawFilename)
{
char *firmAlias;
char *tmpPath = NULL;
int status;
FirmwareSet *firmwareSet = NULL;
firmAlias = module->firmware[channel];
firmwareSet = xiaFindFirmware(firmAlias);
if (firmwareSet->filename == NULL) {
status = xiaGetDSPNameFromFirmware(firmAlias, peakingTime, dspName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting DSP code for firmware %s @ "
"peaking time = %f", firmAlias, peakingTime);
xiaLogError("xiaGetDSPName", info_string, status);
return status;
}
} else {
if (firmwareSet->tmpPath) {
tmpPath = firmwareSet->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(firmwareSet->filename, tmpPath, "dsp", peakingTime,
(unsigned short)firmwareSet->numKeywords,
firmwareSet->keywords, detectorType, dspName,
rawFilename);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting DSP code from FDD file %s @ "
"peaking time = %f", firmwareSet->filename, peakingTime);
xiaLogError("xiaGetDSPName", info_string, status);
return status;
}
/* XXX Dump the FDD data */
xiaLogDebug("xiaGetDSPName", "***** Dump of data sent to FDD *****");
sprintf(info_string, "firmwareSet->filename = %s", firmwareSet->filename);
xiaLogDebug("xiaGetDSPName", info_string);
sprintf(info_string, "peakingTime = %.3f", peakingTime);
xiaLogDebug("xiaGetDSPName", info_string);
sprintf(info_string, "detectorType = %s", detectorType);
xiaLogDebug("xiaGetDSPName", info_string);
sprintf(info_string, "Returned DSPName = %s", dspName);
xiaLogDebug("xiaGetDSPName", info_string);
}
return XIA_SUCCESS;
}
/** @brief Gets the FiPPI name from the firmware configuration.
*
*/
HANDEL_STATIC int xia__GetFiPPIName(Module *module, int channel,
double peakingTime, char *fippiName,
char *detectorType, char *rawFilename)
{
char *firmAlias;
char *tmpPath = NULL;
int status;
FirmwareSet *firmwareSet = NULL;
firmAlias = module->firmware[channel];
firmwareSet = xiaFindFirmware(firmAlias);
if (firmwareSet->filename == NULL)
{
status = xiaGetFippiNameFromFirmware(firmAlias, peakingTime, fippiName);
if (status != XIA_SUCCESS)
{
sprintf(info_string, "Error getting FiPPI code for firmware %s @ peaking time = %f", firmAlias, peakingTime);
xiaLogError("xia__GetFiPPIName", info_string, status);
return status;
}
/* I think that we need this! */
strcpy(rawFilename, fippiName);
} else {
if (firmwareSet->tmpPath) {
tmpPath = firmwareSet->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(firmwareSet->filename, tmpPath, "fippi",
peakingTime,
(unsigned short)firmwareSet->numKeywords,
firmwareSet->keywords, detectorType, fippiName,
rawFilename);
if (status != XIA_SUCCESS)
{
sprintf(info_string, "Error getting FiPPI code from FDD file %s @ peaking time = %f", firmwareSet->filename, peakingTime);
xiaLogError("xia__GetFiPPIName", info_string, status);
return status;
}
/* !!DEBUG!! sequence...used to test FDD stuff */
xiaLogDebug("xia__GetFiPPIName", "***** Dump of data sent to FDD *****");
sprintf(info_string, "firmwareSet->filename = %s", firmwareSet->filename);
xiaLogDebug("xia__GetFiPPIName", info_string);
sprintf(info_string, "peakingTime = %.3f", peakingTime);
xiaLogDebug("xia__GetFiPPIName", info_string);
sprintf(info_string, "detectorType = %s", detectorType);
xiaLogDebug("xia__GetFiPPIName", info_string);
sprintf(info_string, "Returned fippiName = %s", fippiName);
xiaLogDebug("xia__GetFiPPIName", info_string);
}
return XIA_SUCCESS;
}
/** @brief Get the name of the MMU firmware, if it is defined.
*
* Returns status indicating if the MMU firmware was found or not.
*
*/
HANDEL_STATIC int xia__GetMMUName(Module *m, int channel, char *mmuName,
char *rawFilename)
{
char *firmAlias = NULL;
FirmwareSet *firmware = NULL;
ASSERT(m != NULL);
ASSERT(m->firmware != NULL);
ASSERT(m->firmware[channel] != NULL);
firmAlias = m->firmware[channel];
firmware = xiaFindFirmware(firmAlias);
ASSERT(firmware != NULL);
if (firmware->filename == NULL) {
if (firmware->mmu == NULL) {
return XIA_NO_MMU;
}
strcpy(mmuName, firmware->mmu);
strcpy(rawFilename, firmware->mmu);
} else {
/* Do something with the FDD here */
return XIA_NO_MMU;
}
return XIA_SUCCESS;
}
/** @brief Adds a system FPGA to the Xerxes configuration.
*
*/
HANDEL_STATIC int xia__AddSystemFPGA(Module *module, char *sysFPGAName,
char *rawFilename)
{
int statusX;
char *sysFPGAStr[1];
UNUSED(rawFilename);
UNUSED(module);
ASSERT(sysFPGAName != NULL);
sysFPGAStr[0] = (char *)handel_md_alloc(strlen(sysFPGAName) + 1);
if (!sysFPGAStr[0]) {
sprintf(info_string, "Unable to allocate %d bytes for 'sysFPGAStr[0]'",
strlen(sysFPGAName) + 1);
xiaLogError("xia__AddSystemFPGA", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strncpy(sysFPGAStr[0], sysFPGAName, strlen(sysFPGAName) + 1);
statusX = dxp_add_board_item("system_fpga", (char **)sysFPGAStr);
handel_md_free(sysFPGAStr[0]);
if (statusX != DXP_SUCCESS) {
xiaLogError("xia__AddSystemFPGA", "Error adding 'system_fpga' board item",
XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Retrieves the system FPGA name from the firmware, if it has
* been defined.
*
* Currently, this routine only returns success if a system FPGA is
* defined in an FDD file. All other conditions return false, including
* the case where an FDD file is not used.
*
* Future versions of this routine should also include calling parameters
* for the length of @a sysFPGAName and @a rawFilename to prevent buffer
* overflows from occuring.
*
* The FDD file associates a peaking time range with each entry, but some
* firmware types, such as the system FPGA, are global so we pass in a fake
* peaking time instead.
*
* The System FPGA is always assumed to be defined in the firmware for
* channel 0 in the module.
*
*/
HANDEL_STATIC int xia__GetSystemFPGAName(Module *module, char *detType,
char *sysFPGAName, char *rawFilename,
boolean_t *found)
{
int status;
double fake_pt = 1.0;
char *tmpPath = NULL;
FirmwareSet *fs = NULL;
ASSERT(module != NULL);
ASSERT(detType != NULL);
ASSERT(sysFPGAName != NULL);
ASSERT(rawFilename != NULL);
ASSERT(found != NULL);
*found = FALSE_;
fs = xiaFindFirmware(module->firmware[0]);
if (!fs) {
sprintf(info_string, "No firmware set defined for alias '%s'",
module->firmware[0]);
xiaLogError("xia__GetSystemFPGAName", info_string, XIA_NULL_FIRMWARE);
return XIA_NULL_FIRMWARE;
}
if (!fs->filename) {
sprintf(info_string, "No FDD defined in the firmware set '%s'",
module->firmware[0]);
xiaLogError("xia__GetSystemFPGAName", info_string, XIA_NO_FDD);
return XIA_NO_FDD;
}
if (fs->tmpPath) {
tmpPath = fs->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(fs->filename, tmpPath, "system_fpga", fake_pt, 0,
NULL, detType, sysFPGAName, rawFilename);
/* This is not necessarily an error. We will still pass the error value
* up to the top-level but only use an informational message. For products
* without system_fippis defined in their FDD files this message will always
* appear and we don't want them to be confused by spurious ERRORs.
*/
if (status == XIA_FILEERR) {
sprintf(info_string, "Error finding system_fpga in %s", fs->filename);
xiaLogInfo("xia__GetSystemFPGAName", info_string);
return status;
}
/* These are "real" errors, not just missing file problems. */
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error finding system_fpga in %s", fs->filename);
xiaLogError("xia__GetSystemFPGAName", info_string, status);
return status;
}
*found = TRUE_;
return XIA_SUCCESS;
}
/** @brief Get the system DSP name from the FDD file, if either exists.
*
* Currently, this routine only returns success if a system DSP is
* defined in an FDD file. All other conditions return false, including
* the case where an FDD file is not used.
*
* Future versions of this routine should also include calling parameters
* for the length of @a sysDSPName and @a rawFilename to prevent buffer
* overflows from occuring.
*
* XXX: This routine contains a hard-coded peaking time since most FDDs only
* contain one DSP for the entire range of peaking times. This is a hack and
* must be fixed in future versions.
*
* The System DSP is always assumed to be defined in the firmware for
* channel 0 in the module.
*/
HANDEL_STATIC int xia__GetSystemDSPName(Module *module, char *detType,
char *sysDSPName, char *rawFilename,
boolean_t *found)
{
int status;
double fake_pt = 1.0;
char *tmpPath = NULL;
FirmwareSet *fs = NULL;
ASSERT(module != NULL);
ASSERT(detType != NULL);
ASSERT(sysDSPName != NULL);
ASSERT(rawFilename != NULL);
ASSERT(found != NULL);
*found = FALSE_;
fs = xiaFindFirmware(module->firmware[0]);
if (!fs) {
sprintf(info_string, "No firmware set defined for alias '%s'",
module->firmware[0]);
xiaLogError("xia__GetSystemDSPName", info_string, XIA_NULL_FIRMWARE);
return XIA_NULL_FIRMWARE;
}
if (!fs->filename) {
sprintf(info_string, "No FDD defined in the firmware set '%s'",
module->firmware[0]);
xiaLogError("xia__GetSystemDSPName", info_string, XIA_NO_FDD);
return XIA_NO_FDD;
}
if (fs->tmpPath) {
tmpPath = fs->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(fs->filename, tmpPath, "system_dsp", fake_pt, 0, NULL,
detType, sysDSPName, rawFilename);
/* This is not necessarily an error. We will still pass the error value
* up to the top-level but only use an informational message. For products
* without system_fippis defined in their FDD files this message will always
* appear and we don't want them to be confused by spurious ERRORs.
*/
if (status == XIA_FILEERR) {
sprintf(info_string, "Cannot find system_dsp in %s", fs->filename);
xiaLogInfo("xia__GetSystemDSPName", info_string);
return status;
}
/* These are "real" errors, not just missing file problems. */
if (status != XIA_SUCCESS) {
sprintf(info_string, "Cannot find system_dsp in %s", fs->filename);
xiaLogError("xia__GetSystemDSPName", info_string, status);
return status;
}
*found = TRUE_;
return XIA_SUCCESS;
}
/** Add the specified system DSP to the Xerxes configuration.
*
*/
HANDEL_STATIC int xia__AddSystemDSP(Module *module, char *sysDSPName,
char *rawFilename)
{
int statusX;
char *sysDSPStr[1];
UNUSED(rawFilename);
UNUSED(module);
ASSERT(sysDSPName != NULL);
sysDSPStr[0] = (char *)handel_md_alloc(strlen(sysDSPName) + 1);
if (!sysDSPStr[0]) {
sprintf(info_string, "Unable to allocate %d bytes for 'sysDSPStr[0]'",
strlen(sysDSPName) + 1);
xiaLogError("xiaAddSystemDSP", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strncpy(sysDSPStr[0], sysDSPName, strlen(sysDSPName) + 1);
statusX = dxp_add_board_item("system_dsp", (char **)sysDSPStr);
handel_md_free(sysDSPStr[0]);
if (statusX != DXP_SUCCESS) {
xiaLogError("xiaAddSystemDSP", "Error adding 'system_dsp' board item",
XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Get the FiPPI A name from the FDD file, if either exists.
*
* Currently, this routine only returns success if a FiPPI A is
* defined in an FDD file. All other conditions return false, including
* the case where an FDD file is not used.
*
* Future versions of this routine should also include calling parameters
* for the length of @a sysFippiAName and @a rawFilename to prevent buffer
* overflows from occuring.
*
* The Fippi A is always assumed to be defined in the firmware for
* channel 0 in the module.
*/
HANDEL_STATIC int xia__GetFiPPIAName(Module *module, char *detType,
char *sysFippiAName, char *rawFilename,
boolean_t *found)
{
int status;
double fake_pt = 1.0;
char *tmpPath = NULL;
FirmwareSet *fs = NULL;
ASSERT(module != NULL);
ASSERT(detType != NULL);
ASSERT(sysFippiAName != NULL);
ASSERT(rawFilename != NULL);
ASSERT(found != NULL);
*found = FALSE_;
fs = xiaFindFirmware(module->firmware[0]);
if (!fs) {
sprintf(info_string, "No firmware set defined for alias '%s'",
module->firmware[0]);
xiaLogError("xia__GetFiPPIAName", info_string, XIA_NULL_FIRMWARE);
return XIA_NULL_FIRMWARE;
}
if (!fs->filename) {
sprintf(info_string, "No FDD defined in the firmware set '%s'",
module->firmware[0]);
xiaLogError("xia__GetFiPPIAName", info_string, XIA_NO_FDD);
return XIA_NO_FDD;
}
if (fs->tmpPath) {
tmpPath = fs->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(fs->filename, tmpPath, "fippi_a", fake_pt, 0, NULL,
detType, sysFippiAName, rawFilename);
/* This is not necessarily an error. We will still pass the error value
* up to the top-level but only use an informational message. For products
* without system_fippis defined in their FDD files this message will always
* appear and we don't want them to be confused by spurious ERRORs.
*/
if (status == XIA_FILEERR) {
sprintf(info_string, "Cannot find fippi_a in %s", fs->filename);
xiaLogInfo("xia__GetFiPPIAName", info_string);
return status;
}
/* These are "real" errors, not just missing file problems. */
if (status != XIA_SUCCESS) {
sprintf(info_string, "Cannot find fippi_a in %s", fs->filename);
xiaLogError("xia__GetFiPPIAName", info_string, status);
return status;
}
*found = TRUE_;
return XIA_SUCCESS;
}
/** @brief Add FiPPI A to the Xerxes configuration.
*
*/
HANDEL_STATIC int xia__AddFiPPIA(Module *module, char *sysFippiAName,
char *rawFilename)
{
int statusX;
char *sysFippiAStr[1];
UNUSED(rawFilename);
UNUSED(module);
ASSERT(sysFippiAName != NULL);
sysFippiAStr[0] = (char *)handel_md_alloc(strlen(sysFippiAName) + 1);
if (!sysFippiAStr[0]) {
sprintf(info_string, "Unable to allocate %d bytes for 'sysFippiAStr[0]'",
strlen(sysFippiAName) + 1);
xiaLogError("xiaAddSystemFippiA", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strncpy(sysFippiAStr[0], sysFippiAName, strlen(sysFippiAName) + 1);
statusX = dxp_add_board_item("fippi_a", (char **)sysFippiAStr);
handel_md_free(sysFippiAStr[0]);
if (statusX != DXP_SUCCESS) {
xiaLogError("xiaAddSystemFippiA", "Error adding 'fippi_a' board item",
XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Add all of the system items to the Xerxes configuration
*
*/
HANDEL_STATIC int xia__AddXerxesSysItems(void)
{
int i;
int statusX;
/* Xerxes requires us to add all of allowed/known board types to the
* system. The list of known boards is controlled via preprocessor macros
* passed in to the build. For more information, see the top-level Makefile.
*/
for (i = 0; i < N_KNOWN_BOARDS; i++) {
statusX = dxp_add_system_item(BOARD_LIST[i], (char **)SYS_NULL);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding Xerxes system item '%s'",
BOARD_LIST[i]);
xiaLogError("xia__AddXerxesSysItems", info_string, XIA_XERXES);
return XIA_XERXES;
}
}
statusX = dxp_add_system_item("preamp", (char **)SYS_NULL);
if (statusX != DXP_SUCCESS) {
xiaLogError("xia__AddXerxesSysItems", "Error adding Xerxes system item "
"'preamp'", XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Add the board type of the specified module to the Xerxes
* configuration.
*
*/
HANDEL_STATIC int xia__AddXerxesBoardType(Module *m)
{
int statusX;
char **type = NULL;
ASSERT(m != NULL);
type = (char **)handel_md_alloc(sizeof(char *));
if (!type) {
sprintf(info_string, "Error allocating %d bytes for 'type'", sizeof(char *));
xiaLogError("xia__AddXerxesBoardType", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
type[0] = (char *)handel_md_alloc(strlen(m->type) + 1);
if (!type[0]) {
handel_md_free(type);
sprintf(info_string, "Error allocating %d bytes for 'type[0]'",
strlen(m->type) + 1);
xiaLogError("xia__AddXerxesBoardType", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strcpy(type[0], m->type);
statusX = dxp_add_board_item("board_type", type);
handel_md_free(type[0]);
handel_md_free(type);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding board_type '%s' to Xerxes for alias '%s'",
m->type, m->alias);
xiaLogError("xia__AddXerxesBoardType", info_string, XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Add the required interface string to the Xerxes configuration
*
*/
HANDEL_STATIC int xia__AddXerxesInterface(Module *m)
{
int status;
int statusX;
int interfLen = 0;
char *interf[2];
ASSERT(m != NULL);
interfLen = strlen(INTERF_LIST[m->interface_info->type]) + 1;
interf[0] = (char *)handel_md_alloc(interfLen);
if (!interf[0]) {
sprintf(info_string, "Error allocating %d bytes for 'interf[0]'", interfLen);
xiaLogError("xia__AddXerxesInterface", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
interf[1] = (char *)handel_md_alloc(MAX_INTERF_LEN);
if (!interf[1]) {
handel_md_free(interf[0]);
sprintf(info_string, "Error allocating %d bytes for 'interf[1]'",
MAX_INTERF_LEN);
xiaLogError("xia___AddXerxesInterface", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strcpy(interf[0], INTERF_LIST[m->interface_info->type]);
sprintf(info_string, "type = %u, name = '%s'", m->interface_info->type,
INTERF_LIST[m->interface_info->type]);
xiaLogDebug("xia__AddXerxesInterface", info_string);
status = xia__CopyInterfString(m, interf[1]);
if (status != XIA_SUCCESS) {
handel_md_free(interf[0]);
handel_md_free(interf[1]);
sprintf(info_string, "Error getting interface string for alias '%s'",
m->alias);
xiaLogError("xia__AddXerxesInterface", info_string, status);
return status;
}
statusX = dxp_add_board_item("interface", (char **)interf);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding interface '%s, %s' to Xerxes for alias "
"'%s'", interf[0], interf[1], m->alias);
xiaLogError("xia__AddXerxesInterface", info_string, XIA_XERXES);
handel_md_free(interf[0]);
handel_md_free(interf[1]);
return XIA_XERXES;
}
handel_md_free(interf[0]);
handel_md_free(interf[1]);
return XIA_SUCCESS;
}
/** @brief Add the module board item to the Xerxes configuration.
*
*/
HANDEL_STATIC int xia__AddXerxesModule(Module *m)
{
int status;
int statusX;
unsigned int i;
unsigned int j;
char **modStr = NULL;
char mdStr[MAX_MD_LEN];
char chanStr[MAX_NUM_CHAN_LEN];
ASSERT(m != NULL);
modStr = (char **)handel_md_alloc((m->number_of_channels + 2) *
sizeof(char *));
if (!modStr) {
sprintf(info_string, "Error allocating %d bytes for 'modStr'",
(m->number_of_channels + 2) * sizeof(char *));
xiaLogError("xia__AddXerxesModule", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
/* The first two module string elements always refer to the MD string and
* the "number of channels" for this module string.
*/
modStr[0] = &(mdStr[0]);
modStr[1] = &(chanStr[0]);
status = xia__CopyMDString(m, modStr[0]);
if (status != XIA_SUCCESS) {
handel_md_free(modStr);
sprintf(info_string, "Error copying MD string to modules string for alias "
"'%s'", m->alias);
xiaLogError("xia__AddXerxesModule", info_string, status);
return status;
}
status = xia__CopyChanString(m, modStr[1]);
if (status != XIA_SUCCESS) {
handel_md_free(modStr);
sprintf(info_string, "Error copying channel string to modules string for "
"alias '%s'", m->alias);
xiaLogError("xia__AddXerxesModule", info_string, status);
return status;
}
for (i = 0; i < m->number_of_channels; i++) {
modStr[i + 2] = (char *)handel_md_alloc(MAX_CHAN_LEN);
if (!modStr[i + 2]) {
/* Need to unwind the previous allocations */
for (j = 0; j < i; j++) {
handel_md_free(modStr[j + 2]);
}
handel_md_free(modStr);
sprintf(info_string, "Error allocating %d bytes for 'modStr[%d]'",
MAX_CHAN_LEN, (int)(i + 2));
xiaLogError("xia__AddXerxesModule", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
sprintf(modStr[i + 2], "%d", m->channels[i]);
}
statusX = dxp_add_board_item("module", modStr);
for (i = 0; i < m->number_of_channels; i++) {
handel_md_free(modStr[i + 2]);
}
handel_md_free(modStr);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding module to Xerxes for alias '%s'",
m->alias);
xiaLogError("xia__AddXerxesModule", info_string, XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/** @brief Copys the "number of channels" string in the format required by
* Xerxes.
*
* Assumes that @a chan is already allocated.
*
*/
HANDEL_STATIC int xia__CopyChanString(Module *m, char *chan)
{
ASSERT(m != NULL);
ASSERT(chan != NULL);
sprintf(chan, "%u", m->number_of_channels);
return XIA_SUCCESS;
}
/** @brief Checks for the presence of the MMU firmware and configures
* Xerxes with it -- if found.
*
*/
HANDEL_STATIC int xia__DoMMUConfig(Module *m)
{
int status;
int statusX;
char name[MAXFILENAME_LEN];
char rawName[MAXFILENAME_LEN];
char **mmu = NULL;
ASSERT(m != NULL);
status = xia__GetMMUName(m, 0, name, rawName);
if (status != XIA_NO_MMU) {
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error trying to get MMU nume for alias '%s'",
m->alias);
xiaLogError("xia__DoMMUConfig", info_string, status);
return status;
}
strcpy(m->currentFirmware[0].currentMMU, rawName);
mmu = (char **)handel_md_alloc(sizeof(char **));
if (!mmu) {
sprintf(info_string, "Error allocating %d bytes for 'mmu'",
sizeof(char **));
xiaLogError("xia__DoMMUConfig", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
mmu[0] = (char *)handel_md_alloc(strlen(name) + 1);
if (!mmu[0]) {
handel_md_free(mmu);
sprintf(info_string, "Error allocating %d bytes for 'mmu[0]'",
strlen(name) + 1);
xiaLogError("xia__DoMMUConfig", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strcpy(mmu[0], name);
statusX = dxp_add_board_item("mmu", mmu);
handel_md_free(mmu[0]);
handel_md_free(mmu);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding MMU to Xerxes for alias '%s'",
m->alias);
xiaLogError("xia__DoMMUConfig", info_string, XIA_XERXES);
return XIA_XERXES;
}
}
return XIA_SUCCESS;
}
/** @brief Checks for the presence of a system FPGA and adds it to the
* configuration.
*
*/
HANDEL_STATIC int xia__DoSystemFPGA(Module *m)
{
int status;
int detChan = 0;
unsigned int i;
char detType[MAXITEM_LEN];
char sysFPGAName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
boolean_t found = FALSE_;
ASSERT(m != NULL);
/* Assume that the first enabled detChan defines the correct detector type. */
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan != -1) {
break;
}
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoSystemFPGA", info_string, status);
return status;
}
status = xia__GetSystemFPGAName(m, detType, sysFPGAName, rawName, &found);
if ((status != XIA_SUCCESS) && found) {
sprintf(info_string, "Error getting System FPGA for alias '%s'", m->alias);
xiaLogError("xia__DoSystemFPGA", info_string, status);
return status;
}
if (found) {
for (i = 0; i < m->number_of_channels; i++) {
strcpy(m->currentFirmware[i].currentSysFPGA, rawName);
}
status = xia__AddSystemFPGA(m, sysFPGAName, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System FPGA '%s' to Xerxes",
sysFPGAName);
xiaLogError("xia__DoSystemFPGA", info_string, status);
return status;
}
}
return XIA_SUCCESS;
}
/** @brief Gets the appropriate detector type string for the specified detChan.
*
* Assumes that memory for @a type has already been allocated.
*
*/
HANDEL_STATIC int xia__GetDetStringFromDetChan(int detChan, Module *m,
char *type)
{
int modChan;
char *detAlias = NULL;
Detector *det = NULL;
/* If a disabled channel is passed in, we just use module channel 0. */
if (detChan != -1) {
modChan = xiaGetModChan((unsigned int)detChan);
} else {
modChan = 0;
}
detAlias = m->detector[modChan];
det = xiaFindDetector(detAlias);
ASSERT(det != NULL);
switch (det->type) {
case XIA_DET_RESET:
strcpy(type, "RESET");
break;
case XIA_DET_RCFEED:
strcpy(type, "RC");
break;
default:
case XIA_DET_UNKNOWN:
sprintf(info_string, "No detector type specified for detChan %d", detChan);
xiaLogError("xia__GetDetStringFromDetChan", info_string, XIA_MISSING_TYPE);
return XIA_MISSING_TYPE;
break;
}
return XIA_SUCCESS;
}
/** @brief Checks for the presence of a system DSP and adds it to the
* configuration.
*
*/
HANDEL_STATIC int xia__DoSystemDSP(Module *m, boolean_t *found)
{
int detChan = -1;
int status;
unsigned int i;
char detType[MAXITEM_LEN];
char sysDSPName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
ASSERT(m != NULL);
ASSERT(found != NULL);
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan != -1) {
break;
}
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoSystemDSP", info_string, status);
return status;
}
status = xia__GetSystemDSPName(m, detType, sysDSPName, rawName, found);
if ((status != XIA_SUCCESS) && *found) {
sprintf(info_string, "Error getting System DSP for alias '%s'", m->alias);
xiaLogError("xia__DoSystemDSP", info_string, status);
return status;
}
if (*found) {
status = xia__AddSystemDSP(m, sysDSPName, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System DSP '%s' to Xerxes",
sysDSPName);
xiaLogError("xia__DoSystemDSP", info_string, status);
return status;
}
}
return XIA_SUCCESS;
}
/** @brief Adds the DSP info for each channel to the Xerxes configuration.
*
*/
HANDEL_STATIC int xia__DoDSP(Module *m)
{
int status;
int statusX;
int detChan;
unsigned int i;
double pt = 0.0;
char detType[MAXITEM_LEN];
char dspName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
char chan[MAX_CHAN_LEN];
char *dspStr[2];
ASSERT(m != NULL);
/* We skip channels that are disabled (detChan = -1) */
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan == -1) {
continue;
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoDSP", info_string, status);
return status;
}
pt = xiaGetValueFromDefaults("peaking_time", m->defaults[i]);
status = xia__GetDSPName(m, i, pt, dspName, detType, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting DSP name for alias '%s'", m->alias);
xiaLogError("xia__DoDSP", info_string, status);
return status;
}
/* Update the current firmware cache */
strcpy(m->currentFirmware[i].currentDSP, rawName);
dspStr[0] = &(chan[0]);
dspStr[1] = &(dspName[0]);
sprintf(dspStr[0], "%u", i);
statusX = dxp_add_board_item("dsp", (char **)dspStr);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding 'dsp' for alias '%s'", m->alias);
xiaLogError("xia__DoDSP", info_string, XIA_XERXES);
return XIA_XERXES;
}
}
return XIA_SUCCESS;
}
/** @brief Checks for the presence of FiPPI A and adds it to the configuration.
*
*/
HANDEL_STATIC int xia__DoFiPPIA(Module *m, boolean_t *found)
{
int status;
int detChan = 0;
unsigned int i;
char detType[MAXITEM_LEN];
char fippiAName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
ASSERT(m != NULL);
ASSERT(found != NULL);
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan != -1) {
break;
}
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoFiPPIA", info_string, status);
return status;
}
status = xia__GetFiPPIAName(m, detType, fippiAName, rawName, found);
if ((status != XIA_SUCCESS) && *found) {
sprintf(info_string, "Error getting FiPPI A for alias '%s'", m->alias);
xiaLogError("xia__DoFiPPIA", info_string, status);
return status;
}
/* Set FiPPIA as the FiPPI for all of the channels */
for (i = 0; i < m->number_of_channels; i++) {
strcpy(m->currentFirmware[i].currentFiPPI, rawName);
}
if (*found) {
status = xia__AddFiPPIA(m, fippiAName, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding FiPPI A '%s' to Xerxes for alias '%s'",
fippiAName, m->alias);
xiaLogError("xia__DoFiPPIA", info_string, status);
return status;
}
}
return XIA_SUCCESS;
}
/** @brief Adds the FiPPI data for each enabled channel to the Xerxes
* configuration.
*
*/
HANDEL_STATIC int xia__DoFiPPI(Module *m)
{
int status;
int statusX;
int detChan;
unsigned int i;
double pt = 0.0;
char detType[MAXITEM_LEN];
char fippiName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
char chan[MAX_CHAN_LEN];
char *fippiStr[2];
ASSERT(m != NULL);
/* We skip channels that are disabled (detChan = -1) */
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan == -1) {
continue;
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoFiPPI", info_string, status);
return status;
}
pt = xiaGetValueFromDefaults("peaking_time", m->defaults[i]);
status = xia__GetFiPPIName(m, i, pt, fippiName, detType, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting FiPPI name for alias '%s'", m->alias);
xiaLogError("xia__DoFiPPI", info_string, status);
return status;
}
/* Update the current firmware cache */
strcpy(m->currentFirmware[i].currentFiPPI, rawName);
fippiStr[0] = &(chan[0]);
fippiStr[1] = &(fippiName[0]);
sprintf(fippiStr[0], "%u", i);
statusX = dxp_add_board_item("fippi", (char **)fippiStr);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding 'fippi' for alias '%s'", m->alias);
xiaLogError("xia__DoFiPPI", info_string, XIA_XERXES);
return XIA_XERXES;
}
}
return XIA_SUCCESS;
}
/** @brief Adds the params configuration to Xerxes.
*
*/
HANDEL_STATIC int xia__AddXerxesParams(Module *m)
{
int statusX;
ASSERT(m != NULL);
statusX = dxp_add_board_item("default_param", (char **)SYS_NULL);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding 'default_param' to Xerxes for alias '%s'",
m->alias);
xiaLogError("xiaBuildXerxesConfig", info_string, XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
/**
* @brief Checks for the presence of a System FiPPI and adds it to the
* configuration.
*/
HANDEL_STATIC int xia__DoSystemFiPPI(Module *m, boolean_t *found)
{
int detChan = -1;
int status;
unsigned int i;
char detType[MAXITEM_LEN];
char sysFipName[MAX_PATH_LEN];
char rawName[MAXFILENAME_LEN];
ASSERT(m != NULL);
*found = FALSE_;
/* Find the first enabled channel and use that to get the detector type. */
for (i = 0; i < m->number_of_channels; i++) {
detChan = m->channels[i];
if (detChan != -1) {
break;
}
}
status = xia__GetDetStringFromDetChan(detChan, m, detType);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error getting detector type string for alias '%s'",
m->alias);
xiaLogError("xia__DoSystemFiPPI", info_string, status);
return status;
}
status = xia__GetSystemFiPPIName(m, detType, sysFipName, rawName, found);
if ((status != XIA_SUCCESS) && *found) {
sprintf(info_string, "Error getting System FiPPI for alias '%s'",
m->alias);
xiaLogError("xia__DoSystemFiPPI", info_string, status);
return status;
}
if (*found) {
for (i = 0; i < m->number_of_channels; i++) {
strcpy(m->currentFirmware[i].currentSysFiPPI, rawName);
}
status = xia__AddSystemFiPPI(m, sysFipName, rawName);
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error adding System FiPPI '%s' to Xerxes",
sysFipName);
xiaLogError("xia__DoSystemFiPPI", info_string, status);
return status;
}
}
return XIA_SUCCESS;
}
/**
* @brief Retrieves the System FiPPI name from the firmware, if it exists.
*
* @a found is only set to TRUE if a System FiPPI is defined in the FDD file. If
* the module does not use an FDD file, FALSE will be returned.
*
* System FiPPIs are used on hardware that only have a single FPGA and no
* DSP. We use a fake peaking time since the System FiPPI will be defined over
* the entire peaking time range of the product.
*/
HANDEL_STATIC int xia__GetSystemFiPPIName(Module *m, char *detType,
char *sysFipName, char *rawFilename,
boolean_t *found)
{
int status;
double fakePT = 1.0;
char *tmpPath = NULL;
FirmwareSet *fs = NULL;
ASSERT(m != NULL);
ASSERT(detType != NULL);
ASSERT(sysFipName != NULL);
ASSERT(rawFilename != NULL);
ASSERT(found != NULL);
ASSERT(m->firmware[0] != NULL);
*found = FALSE_;
fs = xiaFindFirmware(m->firmware[0]);
ASSERT(fs != NULL);
if (fs->filename == NULL) {
sprintf(info_string, "No FDD defined in the firmware set '%s'",
m->firmware[0]);
xiaLogError("xia__GetSystemFiPPIName", info_string, XIA_NO_FDD);
return XIA_NO_FDD;
}
if (fs->tmpPath != NULL) {
tmpPath = fs->tmpPath;
} else {
tmpPath = utils->funcs->dxp_md_tmp_path();
}
status = xiaFddGetFirmware(fs->filename, tmpPath, "system_fippi", fakePT, 0,
NULL, detType, sysFipName, rawFilename);
/* This is not necessarily an error. We will still pass the error value
* up to the top-level but only use an informational message. For products
* without system_fippis defined in their FDD files this message will always
* appear and we don't want them to be confused by spurious ERRORs.
*/
if (status == XIA_FILEERR) {
sprintf(info_string, "Unable to locate system_fippi in '%s'",
fs->filename);
xiaLogInfo("xia__GetSystemFiPPIName", info_string);
return status;
}
/* These are "real" errors, not just missing file problems. */
if (status != XIA_SUCCESS) {
sprintf(info_string, "Error finding system_fippi in '%s'",
fs->filename);
xiaLogError("xia__GetSystemFiPPIName", info_string, status);
return status;
}
*found = TRUE_;
return XIA_SUCCESS;
}
/**
* @brief Adds a System FiPPI to the Xerxes configuration.
*/
HANDEL_STATIC int xia__AddSystemFiPPI(Module *m, char *sysFipName,
char *rawFilename)
{
int statusX;
/* Xerxes requires items as lists of strings. */
char *sysFipStr[1];
UNUSED(rawFilename);
UNUSED(m);
ASSERT(sysFipName != NULL);
sysFipStr[0] = handel_md_alloc(strlen(sysFipName) + 1);
if (sysFipStr[0] == NULL) {
sprintf(info_string, "Unable to allocated %d bytes for 'sysFipStr[0]'",
strlen(sysFipName) + 1);
xiaLogError("xia__AddSystemFiPPI", info_string, XIA_NOMEM);
return XIA_NOMEM;
}
strcpy(sysFipStr[0], sysFipName);
statusX = dxp_add_board_item("system_fippi", (char **)sysFipStr);
handel_md_free(sysFipStr[0]);
if (statusX != DXP_SUCCESS) {
sprintf(info_string, "Error adding 'system_fippi', '%s', board item to "
"Xerxes configuration",
sysFipName);
xiaLogError("xia__AddSystemFiPPI", info_string, XIA_XERXES);
return XIA_XERXES;
}
return XIA_SUCCESS;
}
| 27.144853 | 127 | 0.637697 |
4ee9560a6a2a6ead205b39f02c54918ad205333e | 2,466 | h | C | include/kernel/Syscall.h | aesophor/valkyrie | 3e2f912da2adfe1a3a8cdb16a989448fccd4e92f | [
"MIT"
] | 53 | 2021-02-24T04:09:41.000Z | 2022-03-30T20:27:12.000Z | include/kernel/Syscall.h | aesophor/valkyrie | 3e2f912da2adfe1a3a8cdb16a989448fccd4e92f | [
"MIT"
] | 4 | 2021-03-03T10:16:42.000Z | 2022-03-10T16:43:40.000Z | include/kernel/Syscall.h | aesophor/valkyrie | 3e2f912da2adfe1a3a8cdb16a989448fccd4e92f | [
"MIT"
] | 5 | 2021-03-03T07:28:17.000Z | 2022-03-05T14:53:10.000Z | // Copyright (c) 2021 Marco Wang <m.aesophor@gmail.com>. All rights reserved.
#ifndef VALKYRIE_SYSCALL_H_
#define VALKYRIE_SYSCALL_H_
#include <Types.h>
#include <Utility.h>
#include <dev/Console.h>
#include <mm/UserspaceAccess.h>
#include <proc/TrapFrame.h>
namespace valkyrie::kernel {
enum Syscall {
SYS_READ,
SYS_WRITE,
SYS_OPEN,
SYS_CLOSE,
SYS_FORK,
SYS_EXEC,
SYS_EXIT,
SYS_GETPID,
SYS_WAIT,
SYS_SCHED_YIELD,
SYS_KILL,
SYS_SIGNAL,
SYS_ACCESS,
SYS_CHDIR,
SYS_MKDIR,
SYS_RMDIR,
SYS_UNLINK,
SYS_MOUNT,
SYS_UMOUNT,
SYS_MKNOD,
SYS_GETCWD,
__NR_syscall
};
// System call table
extern const size_t __syscall_table[Syscall::__NR_syscall];
// Individual system call declaration.
int sys_read(int fd, void __user* buf, size_t count);
int sys_write(int fd, const void __user* buf, size_t count);
int sys_open(const char __user* pathname, int options);
int sys_close(int fd);
int sys_fork();
int sys_exec(const char __user* name, const char __user* argv[]);
[[noreturn]] void sys_exit(int error_code);
int sys_getpid();
int sys_wait(int __user* wstatus);
int sys_sched_yield();
long sys_kill(pid_t pid, int signal);
int sys_signal(int signal, void (__user* handler)());
int sys_access(const char __user* pathname, int options);
int sys_chdir(const char __user* pathname);
int sys_mkdir(const char __user* pathname);
int sys_rmdir(const char __user* pathname);
int sys_unlink(const char __user* pathname);
int sys_mount(const char __user* device_name,
const char __user* mountpoint,
const char __user* fs_name);
int sys_umount(const char __user* mountpoint);
int sys_mknod(const char __user* pathname, mode_t mode, dev_t dev);
int sys_getcwd(char __user* buf);
inline bool is_syscall_id_valid(const uint64_t id) {
return id < Syscall::__NR_syscall;
}
// Indirect system call
//
// A system call is issued using the `svc 0` instruction.
// The system call number is passed via register x8,
// the parameters are stored in x0 ~ x5,
// and the return value will be stored in x0.
template <typename... Args>
size_t do_syscall(const uint64_t id, Args... args) {
// Check if syscall id is valid.
if (!is_syscall_id_valid(id)) [[unlikely]] {
printk("bad system call: (id=0x%x)\n", id);
return -1;
}
// Invoke the specified system call.
return reinterpret_cast<size_t (*)(Args...)>(__syscall_table[id])(args...);
}
} // namespace valkyrie::kernel
#endif // VALKYRIE_SYSCALL_H_
| 26.804348 | 77 | 0.729116 |
abdd6bd88d2f5dcf39ebbeb469e8833eaf920506 | 4,414 | h | C | freeRTOS/b-l475e-iot01a1-bg96-verizon/azure_iotc_sample/lib/third_party/bg96/source/Misc/StackAnalysis/inc/stack_analysis.h | colindembovsky/iot-central-firmware | 29493b18b2d37090c5a071669370d4a907eb3f51 | [
"MIT"
] | 136 | 2018-05-08T08:54:22.000Z | 2022-02-17T21:39:41.000Z | freeRTOS/b-l475e-iot01a1-bg96-verizon/azure_iotc_sample/lib/third_party/bg96/source/Misc/StackAnalysis/inc/stack_analysis.h | colindembovsky/iot-central-firmware | 29493b18b2d37090c5a071669370d4a907eb3f51 | [
"MIT"
] | 90 | 2018-05-08T22:50:26.000Z | 2020-11-04T16:11:44.000Z | freeRTOS/b-l475e-iot01a1-bg96-verizon/azure_iotc_sample/lib/third_party/bg96/source/Misc/StackAnalysis/inc/stack_analysis.h | colindembovsky/iot-central-firmware | 29493b18b2d37090c5a071669370d4a907eb3f51 | [
"MIT"
] | 97 | 2018-05-07T20:55:28.000Z | 2022-02-17T21:39:43.000Z | /**
******************************************************************************
* @file stack_analysis.h
* @author MCD Application Team
* @brief Header for stack_analysis.c module
******************************************************************************
* @attention
*
* <h2><center>© Copyright (c) 2018 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* http://www.st.com/SLA0044
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef STACK_ANALYSIS_H
#define STACK_ANALYSIS_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "plf_config.h"
#include <stdint.h>
/* Exported types ------------------------------------------------------------*/
typedef enum
{
stackAnalysis_false = 0U,
stackAnalysis_true = 1U
} stackAnalysis_Bool;
/* Exported constants --------------------------------------------------------*/
/* Number of tasks in the Project :
to analyse stack size a temporarly buffer will be allocated */
#ifdef THREAD_NUMBER
#define STACK_ANALYSIS_TASK_MAX THREAD_NUMBER
#else
#define STACK_ANALYSIS_TASK_MAX 20
#endif
/* Task name length : used for the trace convenience */
#define STACK_ANALYSIS_TASK_NAME_MAX 15
/* Possible filtering of the stack analysis if force parameter in stackAnalysis_trace
is set to false
Trace only total free heap or current free heap of a task is less than :
TRACE_IF_TOTAL_FREE_HEAP_AT_X_PERCENT % of the starting value
TRACE_IF_THREAD_FREE_STACK_AT_X_PERCENT % of the starting value
Thread not referenced with addStackSizeByHandle or addStackSizeByName
interfaces are always traced */
#define TRACE_IF_TOTAL_FREE_HEAP_AT_X_PERCENT 10U
#define TRACE_IF_THREAD_FREE_STACK_AT_X_PERCENT 20U
/* Trace on change of free heap
Thread not referenced with addStackSizeByHandle or addStackSizeByName
interfaces are always traced */
#define TRACE_ON_CHANGE 1
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
/*
Features functions
*/
/* After each TaskCreate call addStackSizeByHandle or addStackSizeByName
to provide the stackSizeAtCreation to StackAnalysis */
/* Input:
TaskHandle : Task handle
stackSizeAtCreation : stack size parameter at creation */
/* Output:
true : task has been added in the trace
false: task can't be added because number of tasks
is higher than STACK_ANALYSIS_TASK_MAX */
stackAnalysis_Bool stackAnalysis_addStackSizeByHandle(
void *TaskHandle,
uint16_t stackSizeAtCreation);
/* Input:
TaskName : Task name (in some cases Task handle is unknown)
stackSizeAtCreation : stack size parameter at creation */
/* Output:
true : task has been added in the trace
false: task can't be added because number of tasks
is higher than STACK_ANALYSIS_TASK_MAX */
stackAnalysis_Bool stackAnalysis_addStackSizeByName(
char *TaskName,
uint16_t stackSizeAtCreation);
/* Use printf interface to manage the output */
/* Input:
force : true trace is done whatever the value of
TRACE_IF_THREAD_FREE_STACK_AT_X_PERCENT
or TRACE_IF_TOTAL_FREE_HEAP_AT_X_PERCENT;
useful to have a first footprint
false trace is done according to parameter
TRACE_IF_THREAD_FREE_STACK_AT_X_PERCENT
or TRACE_IF_TOTAL_FREE_HEAP_AT_X_PERCENT
Thread whose stack size has not be referenced by a call
to addStackSizeByHandle or addStackSizeByName are always traced
*/
/* Output:
true: stack analysis can be done
false: stack analysis can't be done because number of created tasks
is higher than STACK_ANALYSIS_TASK_MAX */
stackAnalysis_Bool stackAnalysis_trace(stackAnalysis_Bool force);
#ifdef __cplusplus
}
#endif
#endif /* STACK_ANALYSIS_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
| 36.783333 | 86 | 0.63208 |
614db5f3b77358e99e3f75b647db67baee5d59a1 | 622 | h | C | iOSOpenDev/frameworks/IMAVCore.framework/Headers/NetworkCheckOperation.h | bzxy/cydia | f8c838cdbd86e49dddf15792e7aa56e2af80548d | [
"MIT"
] | 678 | 2017-11-17T08:33:19.000Z | 2022-03-26T10:40:20.000Z | iOSOpenDev/frameworks/IMAVCore.framework/Headers/NetworkCheckOperation.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 22 | 2019-04-16T05:51:53.000Z | 2021-11-08T06:18:45.000Z | iOSOpenDev/frameworks/IMAVCore.framework/Headers/NetworkCheckOperation.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 170 | 2018-06-10T07:59:20.000Z | 2022-03-22T16:19:33.000Z | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/IMAVCore.framework/IMAVCore
*/
#import <IMAVCore/IMExtendedOperation.h>
@class IMAVChatParticipant;
__attribute__((visibility("hidden")))
@interface NetworkCheckOperation : IMExtendedOperation {
IMAVChatParticipant *_participant; // 36 = 0x24
unsigned _foundActiveWiFi : 1; // 40 = 0x28
unsigned _foundUsableNetwork : 1; // 40 = 0x28
}
- (BOOL)hasValidNetwork; // 0x1b49
- (BOOL)hasActiveWiFi; // 0x1b35
- (void)main; // 0x1361
- (void)dealloc; // 0x1315
- (id)initWithParticipant:(id)participant; // 0x1299
@end
| 27.043478 | 72 | 0.734727 |
c3266e0c0f92bb38a1655264f89b2be1ea6a82e7 | 2,165 | h | C | src/QtWordreference/wordreferenceclient.h | fgsalomon/QtWordReference | aaccb488f2df40a87c1efa9a2c636cb1ee2f8bf4 | [
"Apache-2.0"
] | 1 | 2015-02-12T19:57:52.000Z | 2015-02-12T19:57:52.000Z | src/QtWordreference/wordreferenceclient.h | fgsalomon/QtWordReference | aaccb488f2df40a87c1efa9a2c636cb1ee2f8bf4 | [
"Apache-2.0"
] | null | null | null | src/QtWordreference/wordreferenceclient.h | fgsalomon/QtWordReference | aaccb488f2df40a87c1efa9a2c636cb1ee2f8bf4 | [
"Apache-2.0"
] | null | null | null | #ifndef WORDREFERENCECLIENT_H
#define WORDREFERENCECLIENT_H
#include <QObject>
#include <QtNetwork/QNetworkAccessManager>
#include <QtNetwork/QNetworkReply>
#include "wordtranslation.h"
/*!
* \brief The WordReferenceClient class encapsulates the interaction with the WordReference API.
*/
class WordReferenceClient : public QObject
{
Q_OBJECT
public:
/*!
* \brief WordReferenceClient constructor
* \param APIKey WordReference API key
* \param parent Pointer to the parent QObject
*/
explicit WordReferenceClient(const QString &APIKey, QObject *parent = 0);
/*!
* \brief setAPIKey changes the WordReference API key for the passed one
* \param APIKey WordReference API key
*/
void setAPIKey(const QString &APIKey) {mAPIKey = APIKey;}
signals:
/*!
* \brief sendResponse sends parsed and formatted WordReference responses
* \param response Parsed and formatted WordReference response
*/
void sendResponse(QByteArray response);
public slots:
/*!
* \brief search sends a search request to the WordReference service
* \param term Search term
* \param dictionary A four letter string representing the dictionary as specified by the WordReference API (enes, fren, etc.)
*/
void search(QString term, QString dictionary);
private slots:
/*!
* \brief onReplyFinished is a slot called when a request reply is received
* \param reply Request reply
*/
void onReplyFinished(QNetworkReply*reply);
private:
QString mAPIKey; /*!< WordReference API key */
QNetworkAccessManager* mNetworkManager; /*!< Manager to handle the http requests */
/*!
* \brief parseReply parses a request reply
* \param reply Request reply
*/
void parseReply(const QByteArray &reply);
/*!
* \brief parseTranslationMap parses a translation map into a translation list
* \param translationMap Translation map to be parsed
* \param translationList Translation list
*/
void parseTranslationMap(const QVariantMap &translationMap, QList<WordTranslation> &translationList);
};
#endif // WORDREFERENCECLIENT_H
| 31.376812 | 130 | 0.712702 |
251a9952f30c7de43c17dcdfadedd5d68799b636 | 8,686 | c | C | src/loggers/JUnitXmlLogger.c | vikingxie/aceunit | 744b61e168efeee57d1c16e82616de63264cae0a | [
"BSD-3-Clause"
] | 31 | 2015-03-20T02:21:14.000Z | 2022-02-05T09:08:02.000Z | src/loggers/JUnitXmlLogger.c | vikingxie/aceunit | 744b61e168efeee57d1c16e82616de63264cae0a | [
"BSD-3-Clause"
] | 2 | 2015-08-06T21:12:51.000Z | 2015-10-25T21:54:57.000Z | src/loggers/JUnitXmlLogger.c | vikingxie/aceunit | 744b61e168efeee57d1c16e82616de63264cae0a | [
"BSD-3-Clause"
] | 10 | 2015-05-16T18:46:23.000Z | 2021-09-01T02:39:51.000Z | /* Copyright (c) 2007 - 2011, Christian Hujer
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the AceUnit developers nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** The JUnitXmlLogger is a #TestLogger_t implementation that writes a test log that is compatible with that of JUnit when using XML log format.
* @author <a href="mailto:cher@riedquat.de">Christian Hujer</a>
* @file JUnitXmlLogger.c
*/
#include <stdio.h>
#include <stdlib.h>
#ifdef _BSD_SOURCE
#include <unistd.h>
#include <err.h>
#endif
#include "AceUnit.h"
#include "AceUnitLogging.h"
/** Returns the host name of the host this test is executed on.
* Tries to determine the hostname in that order:
* - BSD function `gethostname()`, if available.
* - Environment variable `HOSTNAME`.
* - Environment variable `COMPUTERNAME`.
* @return Host name
*/
static char *getHostname() {
char *hostname;
#ifdef _BSD_SOURCE
hostname = malloc(HOST_NAME_MAX + 1);
if (!gethostname(hostname, HOST_NAME_MAX))
return hostname;
warn("Could not determine hostname from system call");
free(hostname);
hostname = NULL;
#endif
hostname = getenv("HOSTNAME");
if (NULL == hostname) {
hostname = getenv("COMPUTERNAME");
}
if (NULL == hostname) {
#ifdef _BSD_SOURCE
warn("Could not determine hostname from environment");
#endif
hostname = "unknown";
}
return hostname;
}
/** The name of the global file.
* Do not change this without really thinking about: It is intentionally the same as that of JUnit / the JUnit Ant task.
*/
#define GLOBAL_FILE_NAME "TESTS-TestSuites.xml"
/** The file TESTS-TestSuites.xml which contains the accumulated log information of all test suites. */
static FILE *globalFile = NULL;
/** The global information recorded by this logger. */
static struct {
char *hostname;
int suiteId;
} globalInfo = {
NULL, 0
};
/** The information about the current suite. */
static struct {
int errors;
int failures;
int id;
char *name;
char *package;
char *fullname;
int tests;
float time;
char *timestamp;
} suiteInfo = {
0, 0, 0, NULL, NULL, NULL, 0, 0.0, NULL
};
/** Initializes all global variables and prepares global log file output.
* @see TestLogger_t#runnerStarted()}
*/
static void runnerStarted() {
globalFile = fopen(GLOBAL_FILE_NAME, "w");
fprintf(globalFile, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
fprintf(globalFile, "<testsuites>\n");
fflush(globalFile);
globalInfo.hostname = getHostname();
globalInfo.suiteId = 0;
}
/** Initializes suite-specific variables.
* @see TestLogger_t#suiteStarted()}
*/
static void suiteStarted(SuiteId_t const suiteId) {
suiteInfo.errors = 0;
suiteInfo.failures = 0;
suiteInfo.id = globalInfo.suiteId++;
}
/** Initializes fixture-specific variables.
* @see TestLogger_t#fixtureStarted()}
*/
static void fixtureStarted(const FixtureId_t fixture) {
suiteInfo.package = NULL; /* TODO */
suiteInfo.name = NULL; /* TODO */
suiteInfo.tests = 0; /* TODO */
suiteInfo.timestamp = NULL; /* TODO */
}
/** @see TestLogger_t#testCaseStarted()} */
static void testCaseStarted(TestCaseId_t testCase) {
}
/** @see TestLogger_t#testCaseFailed()} */
static void testCaseFailed(const AssertionError_t *assertion) {
}
/** @see TestLogger_t#testCaseEnded()} */
static void testCaseEnded(TestCaseId_t testCase) {
}
/** @see TestLogger_t#fixtureEnded()} */
static void fixtureEnded(FixtureId_t fixture) {
}
/** Prints the environment as properties XML element to the specified file.
* @param file File to print to
*/
static void printEnvAsProperties(FILE *file) {
#ifdef ACEUNIT_JUNITXMLLOGGER_ENVIRONMENT
extern char **environ;
char **env = environ;
size_t i;
if (NULL == *env) {
#endif
fprintf(globalFile, " <properties/>\n");
#ifdef ACEUNIT_JUNITXMLLOGGER_ENVIRONMENT
} else {
fprintf(globalFile, " <properties>\n");
for (; NULL != *env; env++) {
char *ptr = *env;
fprintf(globalFile, " <property name=\"");
for (i = 0; i < strlen(ptr); i++) {
if ('=' == ptr[i]) {
break;
}
}
fwrite(*ptr, sizeof(char), i, globalFile);
ptr += i + 1;
fprintf(globalFile, "\" value=\"");
fwrite(*ptr, sizeof(char), strlen(ptr), globalFile);
fprintf(globalFile, "\" />\n");
}
fprintf(globalFile, " </properties>\n");
}
#endif
}
/** @see TestLogger_t#suiteEnded()} */
static void suiteEnded(SuiteId_t const suiteId) {
int i;
FILE *localFile;
/* <testsuite errors="0" failures="0" hostname="riedquat" id="1" name="BasicCommandTest" package="test.net.sf.japi.io.args" tests="10" time="0.105" timestamp="2007-11-06T20:15:24"> */
fprintf(globalFile, " <testsuite errors=\"%d\" failures=\"%d\" hostname=\"%s\" id=\"%d\" name=\"%s\" package=\"%s\" tests=\"%d\" time=\"%f\" timestamp=\"%s\">\n", 0/*TODO*/, 0/*TODO*/, globalInfo.hostname, 0/*TODO*/, ""/*TODO*/, ""/*TODO*/, 0/*TODO*/, 0.0/*TODO*/, ""/*TODO*/);
printEnvAsProperties(globalFile);
for (i = 0; i < suiteInfo.tests; i++) {
/*<testcase classname="test.net.sf.japi.io.args.BasicCommandTest" name="testHelp" time="0.0090" />*/
fprintf(globalFile, " <testcase classname=\"%s\" name=\"%s\" time=\"%f\" />\n", ""/*TODO*/, ""/*TODO*/, 0.0/*TODO*/);
}
fprintf(globalFile, " <system-out/>\n");
fprintf(globalFile, " <system-err/>\n");
fprintf(globalFile, " </testsuite>\n");
fflush(globalFile);
localFile = fopen("TEST-test.net.sf.japi.io.args.ArgParserTest.xml", "w"); /* TODO: configure filename */
/* <testsuite errors="0" failures="0" hostname="riedquat" name="test.net.sf.japi.io.args.ArgParserTest" tests="19" time="3.463" timestamp="2007-11-06T20:15:21"> */
fprintf(localFile, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
fprintf(localFile, "<testsuite errors=\"%d\" failures=\"%d\" hostname=\"%s\" name=\"%s\" tests=\"%d\" time=\"%f\" timestamp=\"%s\">\n", 0/*TODO*/, 0/*TODO*/, globalInfo.hostname, ""/*TODO*/, 0/*TODO*/, 0.0/*TODO*/, ""/*TODO*/);
fprintf(localFile, " <properties/>\n"); /* TODO: encode environment as properties? */
for (i = 0; i < suiteInfo.tests; i++) {
/* <testcase classname="test.net.sf.japi.io.args.ArgParserTest" name="testSimpleParseAndRun" time="0.0080" /> */
fprintf(localFile, " <testcase classname=\"%s\" name=\"%s\" time=\"%f\" />\n", ""/*TODO*/, ""/*TODO*/, 0.0/*TODO*/);
}
fprintf(localFile, " <system-out/>\n");
fprintf(localFile, " <system-err/>\n");
fprintf(localFile, "</testsuite>\n");
fclose(localFile);
}
/** @see TestLogger_t#runnerEnded()} */
static void runnerEnded() {
fprintf(globalFile, "</testsuites>\n");
fclose(globalFile);
}
/** This Logger. */
AceUnitNewLogger(
JUnitXmlLogger,
runnerStarted,
suiteStarted,
fixtureStarted,
testCaseStarted,
testCaseFailed,
testCaseEnded,
fixtureEnded,
suiteEnded,
runnerEnded
);
TestLogger_t *globalLogger = &JUnitXmlLogger; /* XXX Hack. Remove. */
| 36.805085 | 282 | 0.651048 |
c50117ce243e21f885a8ac4fcd0401fe2a2c8b4d | 2,057 | h | C | wpiutil/src/main/native/include/wpi/timestamp.h | shueja-personal/allwpilib | 4b2f6be29e21986703d9c3ddcd2fe07121b2ff6b | [
"BSD-3-Clause"
] | 707 | 2016-05-11T16:54:13.000Z | 2022-03-30T13:03:15.000Z | wpiutil/src/main/native/include/wpi/timestamp.h | shueja-personal/allwpilib | 4b2f6be29e21986703d9c3ddcd2fe07121b2ff6b | [
"BSD-3-Clause"
] | 2,308 | 2016-05-12T00:17:17.000Z | 2022-03-30T20:08:10.000Z | wpiutil/src/main/native/include/wpi/timestamp.h | shueja-personal/allwpilib | 4b2f6be29e21986703d9c3ddcd2fe07121b2ff6b | [
"BSD-3-Clause"
] | 539 | 2016-05-11T20:33:26.000Z | 2022-03-28T20:20:25.000Z | // Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#ifndef WPIUTIL_WPI_TIMESTAMP_H_
#define WPIUTIL_WPI_TIMESTAMP_H_
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* The default implementation used for Now().
* In general this is the time returned by the operating system.
* @return Time in microseconds.
*/
uint64_t WPI_NowDefault(void);
/**
* Set the implementation used by WPI_Now().
* The implementation must return monotonic time in microseconds to maintain
* the contract of WPI_Now().
* @param func Function called by WPI_Now() to return the time.
*/
void WPI_SetNowImpl(uint64_t (*func)(void));
/**
* Return a value representing the current time in microseconds.
* The epoch is not defined.
* @return Time in microseconds.
*/
uint64_t WPI_Now(void);
/**
* Return the current system time in microseconds since the Unix epoch
* (January 1st, 1970 00:00 UTC).
*
* @return Time in microseconds.
*/
uint64_t WPI_GetSystemTime(void);
#ifdef __cplusplus
} // extern "C"
#endif
#ifdef __cplusplus
namespace wpi {
/**
* The default implementation used for Now().
* In general this is the time returned by the operating system.
* @return Time in microseconds.
*/
uint64_t NowDefault(void);
/**
* Set the implementation used by Now().
* The implementation must return monotonic time in microseconds to maintain
* the contract of Now().
* @param func Function called by Now() to return the time.
*/
void SetNowImpl(uint64_t (*func)());
/**
* Return a value representing the current time in microseconds.
* This is a monotonic clock with an undefined epoch.
* @return Time in microseconds.
*/
uint64_t Now(void);
/**
* Return the current system time in microseconds since the Unix epoch
* (January 1st, 1970 00:00 UTC).
*
* @return Time in microseconds.
*/
uint64_t GetSystemTime();
} // namespace wpi
#endif
#endif // WPIUTIL_WPI_TIMESTAMP_H_
| 24.2 | 76 | 0.727759 |
707b894d1c1c1f58cca38732cd7134720908f0ab | 227 | h | C | Example/WCTextField/AppTestDemos/Demo4ViewController.h | daydreamboy/WCTextField | 70363d73c28b0d03c3c33097db90c310d1e3f91c | [
"MIT"
] | null | null | null | Example/WCTextField/AppTestDemos/Demo4ViewController.h | daydreamboy/WCTextField | 70363d73c28b0d03c3c33097db90c310d1e3f91c | [
"MIT"
] | null | null | null | Example/WCTextField/AppTestDemos/Demo4ViewController.h | daydreamboy/WCTextField | 70363d73c28b0d03c3c33097db90c310d1e3f91c | [
"MIT"
] | null | null | null | //
// Demo4ViewController.h
// WCTextField
//
// Created by wesley chen on 16/7/9.
// Copyright © 2016年 wesley_chen. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface Demo4ViewController : UIViewController
@end
| 16.214286 | 55 | 0.713656 |
0293bb4ce2a11256bf878642ad3f5e46fcfefc2b | 353 | c | C | src/drv/cd0prn.c | hleuwer/cd | 3220fd277a07cd1ba26a1dba8e82912960d24ef9 | [
"MIT"
] | 5 | 2015-07-08T06:24:22.000Z | 2020-07-30T21:55:56.000Z | src/drv/cd0prn.c | hleuwer/cd | 3220fd277a07cd1ba26a1dba8e82912960d24ef9 | [
"MIT"
] | 1 | 2022-01-13T13:16:50.000Z | 2022-01-13T13:16:50.000Z | src/drv/null/cd0prn.c | isabella232/cd | 902db126ad1e89266d672e3b9a33405d6bfe83f7 | [
"MIT"
] | 3 | 2019-04-13T12:06:10.000Z | 2022-01-13T11:58:08.000Z | /** \file
* \brief Dummy Printer
*
* See Copyright Notice in cd.h
*/
#include <stdlib.h>
#include "cd.h"
#include "cd_private.h"
#include "cdprint.h"
cdContext* cdContextPrinter(void)
{
if (cdUseContextPlus(CD_QUERY))
{
cdContext* ctx = cdGetContextPlus(CD_CTXPLUS_PRINTER);
if (ctx != NULL)
return ctx;
}
return NULL;
}
| 13.576923 | 58 | 0.651558 |
b346253d8342477ee43a09c2c556d3cc19cc5333 | 737 | h | C | usr/libexec/dasd/_DASActivityBackgroundTaskSchedulerServer-Protocol.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | 5 | 2021-04-29T04:31:43.000Z | 2021-08-19T18:59:58.000Z | usr/libexec/dasd/_DASActivityBackgroundTaskSchedulerServer-Protocol.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | usr/libexec/dasd/_DASActivityBackgroundTaskSchedulerServer-Protocol.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | 1 | 2022-03-19T11:16:23.000Z | 2022-03-19T11:16:23.000Z | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
@class NSString, _DASActivity;
@protocol _DASActivityBackgroundTaskSchedulerServer
- (void)establishConnection:(void (^)(void))arg1;
- (void)completeTaskRequest:(_DASActivity *)arg1 completionHandler:(void (^)(void))arg2;
- (void)cancelAllTaskRequestsWithCompletionHandler:(void (^)(void))arg1;
- (void)cancelTaskRequestWithIdentifier:(NSString *)arg1 completionHandler:(void (^)(void))arg2;
- (void)getPendingTaskRequestsWithCompletionHandler:(void (^)(NSArray *))arg1;
- (void)submitTaskRequest:(_DASActivity *)arg1 withHandler:(void (^)(NSError *))arg2;
@end
| 40.944444 | 120 | 0.753053 |
7057bc61f4b2e2cd5e42292158926d9e5bf1b04e | 518 | h | C | src/Point.h | tcvdijk/wupstream | 317b092f896090436cd155e7a7f2b822938963c0 | [
"MIT"
] | 4 | 2018-09-03T14:19:11.000Z | 2019-03-18T23:43:19.000Z | src/Point.h | tcvdijk/wupstream | 317b092f896090436cd155e7a7f2b822938963c0 | [
"MIT"
] | null | null | null | src/Point.h | tcvdijk/wupstream | 317b092f896090436cd155e7a7f2b822938963c0 | [
"MIT"
] | 2 | 2018-12-04T22:01:09.000Z | 2020-11-17T09:44:43.000Z | // Point feature in the network
#ifndef INCLUDED_POINT
#define INCLUDED_POINT
#include <string>
#include "Settings.h"
class Arc;
class BCNode;
class Point {
public:
Point(const std::string &id) : id(id) {}
// network information
std::string id;
bool isController{ false };
bool isStart{ false };
small_vector<Arc*> arcs;
// for Hopcroft-Tarjan and BC-tree
BCNode *articulation{ nullptr };
bool visited{ false };
Point *dfsParent{ nullptr };
int time{ 0 }, low{ 0 };
};
#endif //ndef INCLUDED_POINT
| 16.709677 | 41 | 0.696911 |
f228a66fb7c2c9114f8029ab0fb3dbd3c3f92cab | 1,025 | h | C | sjtTools/common/model/User.h | sjt777/sjtTools | 2b6256549f631d82160d83e07f03f26bad9cdae7 | [
"MIT"
] | null | null | null | sjtTools/common/model/User.h | sjt777/sjtTools | 2b6256549f631d82160d83e07f03f26bad9cdae7 | [
"MIT"
] | null | null | null | sjtTools/common/model/User.h | sjt777/sjtTools | 2b6256549f631d82160d83e07f03f26bad9cdae7 | [
"MIT"
] | null | null | null | ////
//// User.h
//// antQueen
////
//// Created by yibyi on 15/4/1.
//// Copyright (c) 2015年 yibyi. All rights reserved.
////
//
//#import "Util.h"
//#import "YYModel.h"
//@interface User : NSObject
//@property (strong,nonatomic) NSString *user_token;
//
//@property (strong,nonatomic) NSString *uid ;
//@property (strong,nonatomic) NSString *tel ;
//@property (strong,nonatomic) NSString *pwd ;
//@property (strong,nonatomic) NSString *key ;
//@property (strong,nonatomic) NSString *nickName ;
//#pragma mark - new
//@property (strong,nonatomic) NSString *is_online;// 1 为隐藏充值 0 为显示
//@property(strong,nonatomic)NSString *is_insurance;
//
//@property (nonatomic, strong) NSString *pid; //不等于 0 即为子账号
//@property (nonatomic, strong) NSString *cardealer;
//
//@property (nonatomic, strong) NSString *type;//0 普通用户子账号 1 车商 2特殊车商
//@property (nonatomic, strong) NSString *is_new_cardealer;
//@property (nonatomic, strong) NSString *vip_type; // vip 发车vip
//@property (nonatomic, assign) BOOL is_show_price; //
//@end
| 33.064516 | 70 | 0.691707 |
3503816061d9b22ba3a34468158795643d4ed582 | 1,823 | h | C | class/IDTool.h | hjMaGitHub/TJTools | 075acbe406d4e963881812731ae0f3bf71b26a2c | [
"MIT"
] | null | null | null | class/IDTool.h | hjMaGitHub/TJTools | 075acbe406d4e963881812731ae0f3bf71b26a2c | [
"MIT"
] | null | null | null | class/IDTool.h | hjMaGitHub/TJTools | 075acbe406d4e963881812731ae0f3bf71b26a2c | [
"MIT"
] | null | null | null | //
// IDTool.h
// 我的工具
//
// Created by 吕强 on 16/7/28.
// Copyright © 2017年 Beijing Tianjian Yuan Da Tecnology Co.,Ltd. All rights reserved.
//
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
@interface IDTool : NSObject
+(NSString*)plat;
+(NSString*)model;
+(NSString*)deviceInfo;
+(NSString*)encrypted:(NSString*)strBuf;
+(NSString*)decrypted:(NSString*)strBuf;
+(UIImage*)createImageWithColor:(UIColor*)color Size:(CGSize)size;
+(UIImage*)getImageSize:(NSString*)imgPath Ext:(NSString*)strExt Size:(CGSize)size;
+(NSString*)encodeURL:(NSString *)string;
//+(BOOL)connectedToNetwork;
//+(BOOL)isWIFIConnection;
//System Sound Services
+(void)playSoundWithName:(NSString *)soundName withType:(NSString *)type;
//震动
+(void)shakeMobiledevice;
// 正则判断手机号码地址格式
+ (BOOL)isMobileNumber:(NSString *)mobileNum;
+ (BOOL)isPhoneNumber:(NSString *)phoneNum;
+ (BOOL)isAccount:(NSString *)strAccount;
+ (BOOL)valiMobile:(NSString *)mobile;
// 判断是否是数字
+ (BOOL)isPureNumber:(NSString*)string;
//根据生日（单位秒）转换成一个年龄
+ (double)brithDayToAge:(long long)birthDay;
//根据身份证号码 转换成一个生日
+(NSString *)birthdayStrFromIdentityCard:(NSString *)numberStr;
//根据身份证号码 转换成年龄
+(NSNumber *)ageFromIdentityCard:(NSString *)numberStr;
+ (void)showAlertView:(NSError *)error;
+ (UIImage*)mergedImageOnMainImage:(CGFloat)nhW WithImageArray:(NSArray *)imgArray;
+ (BOOL)isHttpPre:(NSString *)path;
+ (UIViewController *)getCurVC;
//获取ale
+ (NSString *)getAlassetExt:(NSString *)strPath;
//判断身份证号码
+ (BOOL)validateIdentityCard: (NSString *)identityCard;
//精确判断身份证号码
+ (BOOL)validateIDCardNumber:(NSString *)identityCard;
//对中文输入和英文字符限制的问题
+ (void)judgeTheDigitalTypeJudgment:(UITextField *)textfield CN:(NSInteger)chinaT EN:(NSInteger)engT;
//判断身份证号码和性别是否一致
+ (BOOL)compareIdCardSex:(NSString*)idCard andSex:(NSNumber*)sex;
@end
| 24.635135 | 101 | 0.74712 |
013422d76aea55a25249ddd9bd4061c3623e0e0c | 28 | c | C | test/src/second_include.c | shijunjing/ccsm | 2ca1c88008b8ab0a0c86e05aa571660e24b96ac4 | [
"Apache-2.0"
] | 33 | 2015-07-04T19:53:08.000Z | 2022-02-02T10:06:05.000Z | test/src/second_include.c | shijunjing/ccsm | 2ca1c88008b8ab0a0c86e05aa571660e24b96ac4 | [
"Apache-2.0"
] | 83 | 2015-03-07T16:34:20.000Z | 2021-06-23T21:33:31.000Z | test/src/second_include.c | shijunjing/ccsm | 2ca1c88008b8ab0a0c86e05aa571660e24b96ac4 | [
"Apache-2.0"
] | 15 | 2016-02-23T08:36:42.000Z | 2021-08-31T10:30:14.000Z | #include "simple_include.h"
| 14 | 27 | 0.785714 |
d1360f6e72a6bd6c7d6f3c710769af0ab207eb83 | 67 | h | C | implementations/ugene/src/include/U2Core/DocumentSelection.h | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | implementations/ugene/src/include/U2Core/DocumentSelection.h | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | implementations/ugene/src/include/U2Core/DocumentSelection.h | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | #include "../../corelibs/U2Core/src/selection/DocumentSelection.h"
| 33.5 | 66 | 0.761194 |
921307cd3a8145154d8b19500ff7406d088063c8 | 10,463 | h | C | libwallet/musig/keyagg_impl.h | shieldwallets/falcon | 0cc18f526ac4060f6acdb81a5e93f472364abda7 | [
"MIT"
] | 151 | 2018-10-10T23:49:48.000Z | 2022-03-30T11:54:56.000Z | libwallet/musig/keyagg_impl.h | shieldwallets/falcon | 0cc18f526ac4060f6acdb81a5e93f472364abda7 | [
"MIT"
] | 48 | 2019-09-07T09:45:53.000Z | 2022-03-31T17:54:06.000Z | libwallet/musig/keyagg_impl.h | shieldwallets/falcon | 0cc18f526ac4060f6acdb81a5e93f472364abda7 | [
"MIT"
] | 37 | 2019-10-14T22:44:02.000Z | 2022-03-19T18:53:49.000Z | /***********************************************************************
* Copyright (c) 2021 Jonas Nick *
* Distributed under the MIT software license, see the accompanying *
* file COPYING or https://www.opensource.org/licenses/mit-license.php.*
***********************************************************************/
#ifndef SECP256K1_MODULE_MUSIG_KEYAGG_IMPL
#define SECP256K1_MODULE_MUSIG_KEYAGG_IMPL
#include "keyagg.h"
static void secp256k1_point_save(unsigned char *data, secp256k1_ge *ge) {
if (sizeof(secp256k1_ge_storage) == 64) {
secp256k1_ge_storage s;
secp256k1_ge_to_storage(&s, ge);
memcpy(data, &s, sizeof(s));
} else {
VERIFY_CHECK(!secp256k1_ge_is_infinity(ge));
secp256k1_fe_normalize_var(&ge->x);
secp256k1_fe_normalize_var(&ge->y);
secp256k1_fe_get_b32(data, &ge->x);
secp256k1_fe_get_b32(data + 32, &ge->y);
}
}
static void secp256k1_point_load(secp256k1_ge *ge, const unsigned char *data) {
if (sizeof(secp256k1_ge_storage) == 64) {
/* When the secp256k1_ge_storage type is exactly 64 byte, use its
* representation as conversion is very fast. */
secp256k1_ge_storage s;
memcpy(&s, data, sizeof(s));
secp256k1_ge_from_storage(ge, &s);
} else {
/* Otherwise, fall back to 32-byte big endian for X and Y. */
secp256k1_fe x, y;
secp256k1_fe_set_b32(&x, data);
secp256k1_fe_set_b32(&y, data + 32);
secp256k1_ge_set_xy(ge, &x, &y);
}
}
static const unsigned char secp256k1_musig_keyagg_cache_magic[4] = { 0xf4, 0xad, 0xbb, 0xdf };
/* A keyagg cache consists of
* - 4 byte magic set during initialization to allow detecting an uninitialized
* object.
* - 64 byte aggregate (and potentially tweaked) public key
* - 32 byte X-coordinate of "second" public key (0 if not present)
* - 32 byte hash of all public keys
* - 1 byte indicating if the public key is tweaked and if so, also the parity
* of the internal key
* - 32 byte tweak
*/
/* Requires that cache_i->pk is not infinity */
static void secp256k1_keyagg_cache_save(secp256k1_musig_keyagg_cache *cache, secp256k1_keyagg_cache_internal *cache_i) {
unsigned char *ptr = cache->data;
memcpy(ptr, secp256k1_musig_keyagg_cache_magic, 4);
ptr += 4;
secp256k1_point_save(ptr, &cache_i->pk);
ptr += 64;
secp256k1_fe_get_b32(ptr, &cache_i->second_pk_x);
ptr += 32;
memmove(ptr, cache_i->pk_hash, 32);
ptr += 32;
*ptr = cache_i->is_tweaked;
*ptr |= cache_i->internal_key_parity << 1;
ptr += 1;
secp256k1_scalar_get_b32(ptr, &cache_i->tweak);
}
static int secp256k1_keyagg_cache_load(const secp256k1_context* ctx, secp256k1_keyagg_cache_internal *cache_i, const secp256k1_musig_keyagg_cache *cache) {
const unsigned char *ptr = cache->data;
ARG_CHECK(secp256k1_memcmp_var(ptr, secp256k1_musig_keyagg_cache_magic, 4) == 0);
ptr += 4;
secp256k1_point_load(&cache_i->pk, ptr);
ptr += 64;
secp256k1_fe_set_b32(&cache_i->second_pk_x, ptr);
ptr += 32;
cache_i->pk_hash = ptr;
ptr += 32;
cache_i->is_tweaked = *ptr & 1;
cache_i->internal_key_parity = *ptr & 2;
ptr += 1;
secp256k1_scalar_set_b32(&cache_i->tweak, ptr, NULL);
return 1;
}
/* Initializes SHA256 with fixed midstate. This midstate was computed by applying
* SHA256 to SHA256("KeyAgg list")||SHA256("KeyAgg list"). */
static void secp256k1_musig_keyagglist_sha256(secp256k1_sha256 *sha) {
secp256k1_sha256_initialize(sha);
sha->s[0] = 0xb399d5e0ul;
sha->s[1] = 0xc8fff302ul;
sha->s[2] = 0x6badac71ul;
sha->s[3] = 0x07c5b7f1ul;
sha->s[4] = 0x9701e2eful;
sha->s[5] = 0x2a72ecf8ul;
sha->s[6] = 0x201a4c7bul;
sha->s[7] = 0xab148a38ul;
sha->bytes = 64;
}
/* Computes pk_hash = SHA256(pk[0], ..., pk[np-1]) */
static int secp256k1_musig_compute_pk_hash(const secp256k1_context *ctx, unsigned char *pk_hash, const secp256k1_xonly_pubkey * const* pk, size_t np) {
secp256k1_sha256 sha;
size_t i;
secp256k1_musig_keyagglist_sha256(&sha);
for (i = 0; i < np; i++) {
unsigned char ser[32];
if (!secp256k1_xonly_pubkey_serialize(ctx, ser, pk[i])) {
return 0;
}
secp256k1_sha256_write(&sha, ser, 32);
}
secp256k1_sha256_finalize(&sha, pk_hash);
return 1;
}
/* Initializes SHA256 with fixed midstate. This midstate was computed by applying
* SHA256 to SHA256("KeyAgg coefficient")||SHA256("KeyAgg coefficient"). */
static void secp256k1_musig_keyaggcoef_sha256(secp256k1_sha256 *sha) {
secp256k1_sha256_initialize(sha);
sha->s[0] = 0x6ef02c5aul;
sha->s[1] = 0x06a480deul;
sha->s[2] = 0x1f298665ul;
sha->s[3] = 0x1d1134f2ul;
sha->s[4] = 0x56a0b063ul;
sha->s[5] = 0x52da4147ul;
sha->s[6] = 0xf280d9d4ul;
sha->s[7] = 0x4484be15ul;
sha->bytes = 64;
}
/* Compute KeyAgg coefficient which is constant 1 for the second pubkey and
* SHA256(pk_hash, x) where pk_hash is the hash of public keys otherwise. second_pk_x
* can be 0 in case there is no second_pk. Assumes both field elements x and
* second_pk_x are normalized. */
static void secp256k1_musig_keyaggcoef_internal(secp256k1_scalar *r, const unsigned char *pk_hash, const secp256k1_fe *x, const secp256k1_fe *second_pk_x) {
secp256k1_sha256 sha;
unsigned char buf[32];
if (secp256k1_fe_cmp_var(x, second_pk_x) == 0) {
secp256k1_scalar_set_int(r, 1);
} else {
secp256k1_musig_keyaggcoef_sha256(&sha);
secp256k1_sha256_write(&sha, pk_hash, 32);
secp256k1_fe_get_b32(buf, x);
secp256k1_sha256_write(&sha, buf, 32);
secp256k1_sha256_finalize(&sha, buf);
secp256k1_scalar_set_b32(r, buf, NULL);
}
}
/* Assumes both field elements x and second_pk_x are normalized. */
static void secp256k1_musig_keyaggcoef(secp256k1_scalar *r, const secp256k1_keyagg_cache_internal *cache_i, secp256k1_fe *x) {
secp256k1_musig_keyaggcoef_internal(r, cache_i->pk_hash, x, &cache_i->second_pk_x);
}
typedef struct {
const secp256k1_context *ctx;
/* pk_hash is the hash of the public keys */
unsigned char pk_hash[32];
const secp256k1_xonly_pubkey * const* pks;
secp256k1_fe second_pk_x;
} secp256k1_musig_pubkey_agg_ecmult_data;
/* Callback for batch EC multiplication to compute pk_hash_0*P0 + pk_hash_1*P1 + ... */
static int secp256k1_musig_pubkey_agg_callback(secp256k1_scalar *sc, secp256k1_ge *pt, size_t idx, void *data) {
secp256k1_musig_pubkey_agg_ecmult_data *ctx = (secp256k1_musig_pubkey_agg_ecmult_data *) data;
int ret;
ret = secp256k1_xonly_pubkey_load(ctx->ctx, pt, ctx->pks[idx]);
/* pubkey_load can't fail because the same pks have already been loaded (and
* we test this) */
VERIFY_CHECK(ret);
secp256k1_musig_keyaggcoef_internal(sc, ctx->pk_hash, &pt->x, &ctx->second_pk_x);
return 1;
}
int secp256k1_musig_pubkey_agg(const secp256k1_context* ctx, secp256k1_scratch_space *scratch, secp256k1_xonly_pubkey *agg_pk, secp256k1_musig_keyagg_cache *keyagg_cache, const secp256k1_xonly_pubkey * const* pubkeys, size_t n_pubkeys) {
secp256k1_musig_pubkey_agg_ecmult_data ecmult_data;
secp256k1_gej pkj;
secp256k1_ge pkp;
size_t i;
VERIFY_CHECK(ctx != NULL);
if (agg_pk != NULL) {
memset(agg_pk, 0, sizeof(*agg_pk));
}
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
ARG_CHECK(pubkeys != NULL);
ARG_CHECK(n_pubkeys > 0);
ecmult_data.ctx = ctx;
ecmult_data.pks = pubkeys;
/* No point on the curve has an X coordinate equal to 0 */
secp256k1_fe_set_int(&ecmult_data.second_pk_x, 0);
for (i = 1; i < n_pubkeys; i++) {
secp256k1_ge pt;
if (!secp256k1_xonly_pubkey_load(ctx, &pt, pubkeys[i])) {
return 0;
}
if (secp256k1_memcmp_var(pubkeys[0], pubkeys[i], sizeof(*pubkeys[0])) != 0) {
ecmult_data.second_pk_x = pt.x;
break;
}
}
if (!secp256k1_musig_compute_pk_hash(ctx, ecmult_data.pk_hash, pubkeys, n_pubkeys)) {
return 0;
}
if (!secp256k1_ecmult_multi_var(&ctx->error_callback, &ctx->ecmult_ctx, scratch, &pkj, NULL, secp256k1_musig_pubkey_agg_callback, (void *) &ecmult_data, n_pubkeys)) {
/* The current implementation of ecmult_multi_var makes this code unreachable with tests. */
return 0;
}
secp256k1_ge_set_gej(&pkp, &pkj);
secp256k1_fe_normalize_var(&pkp.y);
/* The resulting public key is infinity with negligible probability */
VERIFY_CHECK(!secp256k1_ge_is_infinity(&pkp));
if (keyagg_cache != NULL) {
secp256k1_keyagg_cache_internal cache_i = { 0 };
cache_i.pk = pkp;
cache_i.second_pk_x = ecmult_data.second_pk_x;
cache_i.pk_hash = ecmult_data.pk_hash;
secp256k1_keyagg_cache_save(keyagg_cache, &cache_i);
}
secp256k1_extrakeys_ge_even_y(&pkp);
if (agg_pk != NULL) {
secp256k1_xonly_pubkey_save(agg_pk, &pkp);
}
return 1;
}
int secp256k1_musig_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *output_pubkey, const unsigned char *tweak32, secp256k1_musig_keyagg_cache *keyagg_cache) {
secp256k1_keyagg_cache_internal cache_i;
int overflow = 0;
VERIFY_CHECK(ctx != NULL);
if (output_pubkey != NULL) {
memset(output_pubkey, 0, sizeof(*output_pubkey));
}
ARG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
ARG_CHECK(keyagg_cache != NULL);
ARG_CHECK(tweak32 != NULL);
if(!secp256k1_keyagg_cache_load(ctx, &cache_i, keyagg_cache)) {
return 0;
}
/* This function can only be called once because otherwise signing would not
* succeed */
ARG_CHECK(cache_i.is_tweaked == 0);
cache_i.internal_key_parity = secp256k1_extrakeys_ge_even_y(&cache_i.pk);
secp256k1_scalar_set_b32(&cache_i.tweak, tweak32, &overflow);
if(overflow || !secp256k1_eckey_pubkey_tweak_add(&ctx->ecmult_ctx, &cache_i.pk, &cache_i.tweak)) {
return 0;
}
cache_i.is_tweaked = 1;
/* eckey_pubkey_tweak_add fails if cache_i.pk is infinity */
VERIFY_CHECK(!secp256k1_ge_is_infinity(&cache_i.pk));
secp256k1_keyagg_cache_save(keyagg_cache, &cache_i);
if (output_pubkey != NULL) {
secp256k1_pubkey_save(output_pubkey, &cache_i.pk);
}
return 1;
}
#endif
| 38.186131 | 237 | 0.681258 |
13f02ff4f8ccb0cbca1e630f938c00bf9be7ddc2 | 1,933 | h | C | src/jaegertracing/context/with_context.h | billowqiu/jaeger-client-cpp | 63fe5e89fa468466ef2d5b50a702e1ec3a06675b | [
"Apache-2.0"
] | null | null | null | src/jaegertracing/context/with_context.h | billowqiu/jaeger-client-cpp | 63fe5e89fa468466ef2d5b50a702e1ec3a06675b | [
"Apache-2.0"
] | null | null | null | src/jaegertracing/context/with_context.h | billowqiu/jaeger-client-cpp | 63fe5e89fa468466ef2d5b50a702e1ec3a06675b | [
"Apache-2.0"
] | null | null | null | // Copyright 2018, OpenCensus Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef OPENCENSUS_CONTEXT_WITH_CONTEXT_H_
#define OPENCENSUS_CONTEXT_WITH_CONTEXT_H_
#include "jaegertracing/context/context.h"
#include "jaegertracing/SpanContext.h"
namespace jaegertracing {
// WithContext is a scoped object that sets the current Context to the given
// one, until the WithContext object is destroyed. If the condition is false, it
// doesn't do anything.
//
// Because WithContext changes the current (thread local) context, NEVER
// allocate a WithContext in one thread and deallocate in another. A simple way
// to ensure this is to only ever stack-allocate it.
//
// Example usage:
// {
// WithContext wc(op.ctx_);
// // Do work.
// }
class WithSpanContext {
public:
explicit WithSpanContext(const SpanContext& ctx, bool cond = true);
explicit WithSpanContext(SpanContext&& ctx, bool cond = true);
~WithSpanContext();
private:
WithSpanContext() = delete;
WithSpanContext(const WithSpanContext&) = delete;
WithSpanContext(WithSpanContext&&) = delete;
WithSpanContext& operator=(const WithSpanContext&) = delete;
WithSpanContext& operator=(WithSpanContext&&) = delete;
void ConditionalSwap();
SpanContext swapped_context_;
#ifndef NDEBUG
const Context* original_context_;
#endif
const bool cond_;
};
} // namespace jaegertracing
#endif // OPENCENSUS_CONTEXT_WITH_CONTEXT_H_
| 31.688525 | 80 | 0.755303 |
3d11f6669b50199139cc7f73ad4fe7b52adefdfd | 261 | h | C | ObjectiveC_Extension/NSApplication+Extension.h | WineskinCommunity/ObjectiveC_Extension | adc4a01c2fa30ec9cdcdb9ffb8025e98563076c4 | [
"MIT"
] | 1 | 2019-12-03T14:27:58.000Z | 2019-12-03T14:27:58.000Z | ObjectiveC_Extension/NSApplication+Extension.h | WineskinCommunity/ObjectiveC_Extension | adc4a01c2fa30ec9cdcdb9ffb8025e98563076c4 | [
"MIT"
] | null | null | null | ObjectiveC_Extension/NSApplication+Extension.h | WineskinCommunity/ObjectiveC_Extension | adc4a01c2fa30ec9cdcdb9ffb8025e98563076c4 | [
"MIT"
] | 1 | 2021-12-28T14:31:06.000Z | 2021-12-28T14:31:06.000Z | //
// NSApplication+Extension.h
// ObjectiveC_Extension
//
// Created by Vitor Marques de Miranda on 23/12/2017.
// Copyright © 2017 VitorMM. All rights reserved.
//
#import <Cocoa/Cocoa.h>
@interface NSApplication (VMMApplication)
+(void)restart;
@end
| 16.3125 | 54 | 0.716475 |
82d103723aa134ff72449a2d0ca3735b68c86fee | 4,042 | h | C | deploy/cpp/include/config_parser.h | leakyH/PaddleDetection | aa15eb945711baf248177a02d4d3dd3bd3abc4e8 | [
"Apache-2.0"
] | 3 | 2022-03-23T08:48:06.000Z | 2022-03-28T01:59:34.000Z | deploy/cpp/include/config_parser.h | leakyH/PaddleDetection | aa15eb945711baf248177a02d4d3dd3bd3abc4e8 | [
"Apache-2.0"
] | null | null | null | deploy/cpp/include/config_parser.h | leakyH/PaddleDetection | aa15eb945711baf248177a02d4d3dd3bd3abc4e8 | [
"Apache-2.0"
] | 1 | 2022-01-05T16:34:06.000Z | 2022-01-05T16:34:06.000Z | // Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include "yaml-cpp/yaml.h"
#ifdef _WIN32
#define OS_PATH_SEP "\\"
#else
#define OS_PATH_SEP "/"
#endif
namespace PaddleDetection {
// Inference model configuration parser
class ConfigPaser {
public:
ConfigPaser() {}
~ConfigPaser() {}
bool load_config(const std::string& model_dir,
const std::string& cfg = "infer_cfg.yml") {
// Load as a YAML::Node
YAML::Node config;
config = YAML::LoadFile(model_dir + OS_PATH_SEP + cfg);
// Get runtime mode : paddle, trt_fp16, trt_fp32
if (config["mode"].IsDefined()) {
mode_ = config["mode"].as<std::string>();
} else {
std::cerr << "Please set mode, "
<< "support value : paddle/trt_fp16/trt_fp32." << std::endl;
return false;
}
// Get model arch : YOLO, SSD, RetinaNet, RCNN, Face
if (config["arch"].IsDefined()) {
arch_ = config["arch"].as<std::string>();
} else {
std::cerr << "Please set model arch,"
<< "support value : YOLO, SSD, RetinaNet, RCNN, Face."
<< std::endl;
return false;
}
// Get min_subgraph_size for tensorrt
if (config["min_subgraph_size"].IsDefined()) {
min_subgraph_size_ = config["min_subgraph_size"].as<int>();
} else {
std::cerr << "Please set min_subgraph_size." << std::endl;
return false;
}
// Get draw_threshold for visualization
if (config["draw_threshold"].IsDefined()) {
draw_threshold_ = config["draw_threshold"].as<float>();
} else {
std::cerr << "Please set draw_threshold." << std::endl;
return false;
}
// Get Preprocess for preprocessing
if (config["Preprocess"].IsDefined()) {
preprocess_info_ = config["Preprocess"];
} else {
std::cerr << "Please set Preprocess." << std::endl;
return false;
}
// Get label_list for visualization
if (config["label_list"].IsDefined()) {
label_list_ = config["label_list"].as<std::vector<std::string>>();
} else {
std::cerr << "Please set label_list." << std::endl;
return false;
}
// Get use_dynamic_shape for TensorRT
if (config["use_dynamic_shape"].IsDefined()) {
use_dynamic_shape_ = config["use_dynamic_shape"].as<bool>();
} else {
std::cerr << "Please set use_dynamic_shape." << std::endl;
return false;
}
// Get conf_thresh for tracker
if (config["tracker"].IsDefined()) {
if (config["tracker"]["conf_thres"].IsDefined()) {
conf_thresh_ = config["tracker"]["conf_thres"].as<float>();
} else {
std::cerr << "Please set conf_thres in tracker." << std::endl;
return false;
}
}
// Get NMS for postprocess
if (config["NMS"].IsDefined()) {
nms_info_ = config["NMS"];
}
// Get fpn_stride in PicoDet
if (config["fpn_stride"].IsDefined()) {
fpn_stride_.clear();
for (auto item : config["fpn_stride"]) {
fpn_stride_.emplace_back(item.as<int>());
}
}
return true;
}
std::string mode_;
float draw_threshold_;
std::string arch_;
int min_subgraph_size_;
YAML::Node preprocess_info_;
YAML::Node nms_info_;
std::vector<std::string> label_list_;
std::vector<int> fpn_stride_;
bool use_dynamic_shape_;
float conf_thresh_;
};
} // namespace PaddleDetection
| 29.289855 | 76 | 0.628154 |
89e182f61945f090f3fa7d996d8f89fa34b7847a | 225 | h | C | Example/CLTools/CLViewController.h | ClaudeLi/CLTools | 26fcec4e03727c86ad69ec80cf3a45e476446324 | [
"MIT"
] | 2 | 2018-07-17T03:57:25.000Z | 2021-06-24T04:00:31.000Z | Example/CLTools/CLViewController.h | ClaudeLi/CLTools | 26fcec4e03727c86ad69ec80cf3a45e476446324 | [
"MIT"
] | null | null | null | Example/CLTools/CLViewController.h | ClaudeLi/CLTools | 26fcec4e03727c86ad69ec80cf3a45e476446324 | [
"MIT"
] | null | null | null | //
// CLViewController.h
// CLTools
//
// Created by claudeli@yeah.net on 06/15/2018.
// Copyright (c) 2018 claudeli@yeah.net. All rights reserved.
//
@import UIKit;
@interface CLViewController : UIViewController
@end
| 16.071429 | 62 | 0.706667 |
d601ea02fde4227e841ec0284082f88b748f0d6d | 683 | c | C | src/librandom/unidevurandom.c | matya/skalibs | ffb631dff6b850648b7421f692301a7033a13d55 | [
"0BSD"
] | null | null | null | src/librandom/unidevurandom.c | matya/skalibs | ffb631dff6b850648b7421f692301a7033a13d55 | [
"0BSD"
] | null | null | null | src/librandom/unidevurandom.c | matya/skalibs | ffb631dff6b850648b7421f692301a7033a13d55 | [
"0BSD"
] | null | null | null | /* ISC license. */
#include <skalibs/sysdeps.h>
#include <skalibs/unirandomdev.h>
#include <skalibs/unirandom.h>
#ifdef SKALIBS_HASDEVURANDOM
#include "random-internal.h"
int unidevurandom_init (union unirandominfo *u)
{
return unirandomdev_sinit(u, "/dev/urandom") ;
}
int unirandom_register_devurandom (unirandom *u)
{
unirandom_register(u, &unidevurandom_init, &unirandomdev_finish, &unirandomdev_readb, &unirandomdev_readnb) ;
return 1 ;
}
#else
#include <errno.h>
int unidevurandom_init (union unirandominfo *u)
{
(void)u ;
return (errno = ENOSYS, 0) ;
}
int unirandom_register_devurandom (unirandom *u)
{
(void)u ;
return (errno = ENOSYS, 0) ;
}
#endif
| 17.512821 | 111 | 0.729136 |
328c323a8259f5e9cc25c27406c60f9a9eea0aa9 | 21,537 | h | C | mmtbx/probe/Scoring.h | jongablop/cctbx_project | 5aa9da46eadf4b806cef423218228c4ffdcf2873 | [
"BSD-3-Clause-LBNL"
] | 2 | 2018-02-01T14:25:48.000Z | 2021-09-15T16:36:29.000Z | mmtbx/probe/Scoring.h | jongablop/cctbx_project | 5aa9da46eadf4b806cef423218228c4ffdcf2873 | [
"BSD-3-Clause-LBNL"
] | 2 | 2018-06-14T17:04:17.000Z | 2019-06-24T20:54:12.000Z | mmtbx/probe/Scoring.h | jongablop/cctbx_project | 5aa9da46eadf4b806cef423218228c4ffdcf2873 | [
"BSD-3-Clause-LBNL"
] | null | null | null | // Copyright(c) 2021, Richardson Lab at Duke
// Licensed under the Apache 2 license
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissionsand
// limitations under the License.
#pragma once
#include "SpatialQuery.h"
#include <iotbx/pdb/hierarchy.h>
#include <map>
namespace molprobity {
namespace probe {
//=====================================================================================================
// Helper functions outside the class.
/// @brief Structure to hold the results from a call to closest_contact()
class ContactResult {
public:
Point closestContact; ///< The point on the radius of the tested sphere closest to the dot
double distAboveSurface; ///< Distance that the dot is above the tested sphere (negative for inside)
};
/// @brief Find the point of closest contact and distance above/below atomic surface
/// @param [in] dot The dot whose location is to be projected onto the atom
/// @param [in] atom The center of the atom
/// @param [in] atom_radius The radius of the atom
/// @return The point of closest contact on the atom's surface to the dot and the
/// signed distance that the dot is above that surface, with negative indicating
/// that it is inside the atom's surface.
ContactResult closest_contact(Point dot, Point atom, double atom_radius);
/// @brief Return the signed-integer charge of the atom.
/// @param atom Atom whose charge is to be determined.
/// return Integer representing the charge: -2, -1, 0, 1, 2
int atom_charge(iotbx::pdb::hierarchy::atom const& atom);
// functions used to restrict annular rings of good dots around clashes
/// @brief The distance from a dot to the point on the source surface that is closest to the target
/// @param [in] dot The dot being considered
/// @param [in] srcLoc The center of the source atom
/// @param [in] srcVDWRad The van Der Waals radius of the source atom in Angstroms
/// @param [in] targLoc The center of the target atom
/// @return The distance from a dot to the point on the source surface that is closest to the target
double dot2srcCenter(const Point& dot, const Point& srcLoc, double srcVDWRad, const Point& targLoc);
/// @brief This is the distance from the point on the source atom closest to the target to the edge
/// of contact when the source and target are in optimal contact?
/// @todo Figure out for sure what this is computing.
/// @param [in] ra Radius of the source atom
/// @param [in] rb Radius of the target atom
/// @param [in] rp Probe radius
double kissEdge2bullsEye(double ra, double rb, double rp);
/// @brief A dot is annular if it is further from the center of contact than edge of the overlap
/// region is at optimum contact.
///
/// This checks to make sure that dots that would not have contributed to a good score at optimium
/// contact are not considered to contribute to a good score when the atoms are overlapping or far from
/// each other?
/// @todo Figure out for sure what this is computing.
bool annularDots(const Point& dot, const Point& srcLoc, double srcVDWRad,
const Point& targLoc, double targVDWRad, double probeRadius);
//=====================================================================================================
/// @brief Class to hold data values for an atom beyond those present in the hierarchy::atom class itself
// that are needed by the Probe calculations. These must be filled in by the client, perhaps using data
// from the mmtbx.monomer_library.server.ener_lib() function to get a library and looking things up
// in it based on getting a monomer lib query mon_lib_query() from reduce_hydrogen, then calling its
// atom_dict() method and then looking up the atom by name in that dictionary to get its type_energy
// value.
class ExtraAtomInfo {
public:
/// @brief Constructor with default parameters
ExtraAtomInfo(double vdwRadius = 0, bool isAcceptor = false, bool isDonor = false,
bool isDummyHydrogen = false)
: m_vdwRadius(vdwRadius), m_isAcceptor(isAcceptor), m_isDonor(isDonor)
, m_isDummyHydrogen(isDummyHydrogen) {}
/// @brief Constructor from another ExtraAtomInfo
ExtraAtomInfo(const ExtraAtomInfo &e)
: m_vdwRadius(e.m_vdwRadius), m_isAcceptor(e.m_isAcceptor), m_isDonor(e.m_isDonor)
, m_isDummyHydrogen(e.m_isDummyHydrogen) {}
/// @brief Get and set methods
double getVdwRadius() const { return m_vdwRadius; }
void setVdwRadius(double val) { m_vdwRadius = val; }
bool getIsAcceptor() const { return m_isAcceptor; }
void setIsAcceptor(bool val) { m_isAcceptor = val; }
bool getIsDonor() const { return m_isDonor; }
void setIsDonor(bool val) { m_isDonor = val; }
bool getIsDummyHydrogen() const { return m_isDummyHydrogen; }
void setIsDummyHydrogen(bool val) { m_isDummyHydrogen = val; }
/// @brief == operator is required so that we can wrap the standard vector operators in Boost::Python
bool operator ==(ExtraAtomInfo const& o) {
return ((getVdwRadius() == o.getVdwRadius())
&& (getIsAcceptor() == o.getIsAcceptor())
&& (getIsDonor() == o.getIsDonor())
&& (getIsDummyHydrogen() == o.getIsDummyHydrogen()));
}
protected:
double m_vdwRadius; ///< van Der Waals radius of the atom
bool m_isAcceptor; ///< Does this accept hydrogen bonds (aromatic carbon, nitrogen acceptor,
/// oxygen, sulfur, fluorine, chlorine, bromine, or iodine?
bool m_isDonor; ///< Is this a donor hydrogen (from polar, aromatic polar, or water)?
bool m_isDummyHydrogen; ///< These are inserted on Oxygens that are waters to provide
/// bonds that can go in any direction.
};
//=====================================================================================================
/// @brief Class to map from an atom to the ExtraAtomInfo associated with it.
class ExtraAtomInfoMap {
public:
/// @brief Constructor creates the map from vectors of atoms and ExtraAtomInfo.
/// @param [in] atoms Vector of atoms that will be mapped from. Must include all of the ones added
/// to the SpatialQuery structure so that anyone using its outputs will find an entry.
/// @param [in] extraInfo Vector of extra information pertaining to each atom. Must be the same
/// length as the atoms vector.
ExtraAtomInfoMap(scitbx::af::shared<iotbx::pdb::hierarchy::atom> atoms
, scitbx::af::shared<ExtraAtomInfo> extraInfo)
{
if (atoms.size() == extraInfo.size()) {
// Build the map from the vector of atoms and vector of extra atom info
for (size_t i = 0; i < atoms.size(); i++) {
std::pair < iotbx::pdb::hierarchy::atom_data*, ExtraAtomInfo>
element(atoms[i].data.get(), extraInfo[i]);
m_extraInfo.insert(element);
// Keep a shared pointer so that the data doesn't go away while we're still
// using it.
m_keepPointers.push_back(atoms[i].data);
}
}
}
/// @brief Get and set methods
ExtraAtomInfo getMappingFor(iotbx::pdb::hierarchy::atom const &atom)
{
return m_extraInfo[atom.data.get()];
}
void setMappingFor(iotbx::pdb::hierarchy::atom const &atom, ExtraAtomInfo const &info)
{
m_extraInfo[atom.data.get()] = info;
}
protected:
// Constructed map from the atom_data elements to the extra-atom information so that we
// can look up extra info based on particular atoms without having to rely on the sequence
// IDs being correct.
std::map< iotbx::pdb::hierarchy::atom_data*, ExtraAtomInfo > m_extraInfo;
// This keeps around shared pointers to the data we placed into our map so that they don't
// get deleted out from under us.
std::vector< boost::shared_ptr<iotbx::pdb::hierarchy::atom_data> > m_keepPointers;
};
//=====================================================================================================
/// @brief Class to handle scoring dots given sets of atoms.
class DotScorer {
public:
/// @brief Constructor stores the non-bonded parameters to be used to determine atom features.
/// @param [in] extraInfoMap maps from atoms to ExtraAtomInfo.
/// @param [in] gapScale Scale factor to apply to gap between atoms (gap is divided by this)
/// @param [in] bumpWeight Factor to apply when atoms are in bumping overlap
/// @param [in] hBondWeight Factor to apply to hydrogen-bond overlaps
/// @param [in] maxRegularHydrogenOverlap How much overlap can there be between a hydrogen
/// and the atom it is hydrogen-bonded to before we call it a clash when the atoms
/// are not both charged. It must go badBumpOverlap beyond this before we call
/// it a bad clash.
/// @param [in] maxChargedHydrogenOverlap How much overlap can there be between a hydrogen
/// and the atom it is hydrogen-bonded to before we call it a clash when the
/// atoms are both charged. It must go badBumpOverlap beyond this before we call
/// it a bad clash.
/// @param [in] bumpOverlap Atoms that overlap more than this will cause a clash. This is a
/// positive number indicating how much overlap.
/// @param [in] badBumpOverlap Atoms that overlap more than this will cause bad bump to be flagged.
/// This number can be set very large to cause no bumps to be flagged as bad bumps. This is a
/// positive number indicating how much overlap.
/// @param [in] contactCutoff Atoms that are nearer than this will be considered to be in near
/// contact, with atoms further in far contact. This should be at least as large
/// as the probe radius.
/// @param [in] weakHBonds Include weak hydrogen bonds (dots that are in hydrogen bonds but which
/// are outside contact). These are categorized as a different InteractionType but
/// are counted as hydrogen bonds when scoring.
/// @todo Consider moving the probe radius into the constructor parameters
DotScorer(ExtraAtomInfoMap extraInfoMap
, double gapScale = 0.25
, double bumpWeight = 10.0
, double hBondWeight = 4.0
, double maxRegularHydrogenOverlap = 0.6
, double maxChargedHydrogenOverlap = 0.8
, double bumpOverlap = 0.4
, double badBumpOverlap = 0.5
, double contactCutoff = 0.25
, bool weakHBonds = false
) : m_extraInfoMap(extraInfoMap)
, m_gapScale(gapScale), m_bumpWeight(bumpWeight), m_hBondWeight(hBondWeight)
, m_maxRegularHydrogenOverlap(maxRegularHydrogenOverlap)
, m_maxChargedHydrogenOverlap(maxChargedHydrogenOverlap)
, m_bumpOverlap(bumpOverlap)
, m_badBumpOverlap(badBumpOverlap)
, m_contactCutoff(contactCutoff)
, m_weakHBonds(weakHBonds)
{}
/// @brief Enumeration listing the basic types of overlap a dot can have with an atom.
/// The values mean: NoOverlap => dot outside atom, Clash => dot inside atom and not hydrogen bonding
/// (including too-close hydrogen), HydrogenBond => Hydrogen bond, Ignore = this dot was inside
/// an excluded atom or had no neighboring atoms so should be ignored.
enum OverlapType { Ignore = -2, Clash = -1, NoOverlap = 0, HydrogenBond = 1 };
/// @brief Structure to hold the results from a call to check_dot()
class CheckDotResult {
public:
CheckDotResult() : overlapType(DotScorer::Ignore), overlap(0), gap(1e100), annular(false) {};
OverlapType overlapType; ///< What kind of overlap, if any, was found
iotbx::pdb::hierarchy::atom cause; ///< Cause of the overlap, if overlapType != Ignore
double overlap; ///< Amount of overlap assigned to source atom if there is a clash
double gap; ///< Gap distance (overlap may only be a fraction of this).
/// Was this an annular dot, which is further from the point on the source atom that is closest
/// to the target atom than a point on the tangent edge of the target atom where the ray just
/// grazes the surface of the atom. @todo The math being done here is a bit opaque, so the
/// origin of the second measurement is not clear. The intent is to prevent over-spreading of
/// dots beyond what would have been present when the atoms just touched, which prevents
/// additional good contact outside the clash; see page 1717 of J. Mol. Biol. 285 (1999).
bool annular;
};
/// @brief Score an individual dot against a specific set of interacting atoms unless within an excluded atom
/// @param [in] sourceAtom Atom that the dot is offset with respect to.
/// @param [in] dotOffset Offset from the center of the source atom to the dot
/// @param [in] probeRadius Radius of the probe rolled between the two potentially-contacting atoms
/// If this is < 0, an invalid result will be returned.
/// @param [in] interacting The atoms that are to be checked because they are close enough to sourceAtom
/// to interact with it. This list should not include any excluded atoms because spurious
/// interactions may occur along the edge of the excluded atom when a dot is close to it but
/// not inside.
/// @param [in] excluded Atoms that are to be excluded from contact, for example this could be a list
/// of atoms bonded to sourceAtom. If the dot is inside an excluded atom, it will not be
/// considered even if it is overlapping with an interacting atom.
/// @param [in] overlapScale: The fraction of overlap to assign to each of the two atoms, scaling the
/// spike drawn for each.
CheckDotResult check_dot(iotbx::pdb::hierarchy::atom sourceAtom,
Point const& dotOffset, double probeRadius,
scitbx::af::shared<iotbx::pdb::hierarchy::atom> const& interacting,
scitbx::af::shared<iotbx::pdb::hierarchy::atom> const& exclude,
double overlapScale = 0.5);
/// @brief Enumeration listing the detailed class of interaction a dot can have with an atom.
/// This is a weak enumeration rather than a class so that it can by type-cast back into integers
/// and used as an index. These index values are chosen to match those used by the orignal Probe.
enum InteractionType {
WideContact = 0, CloseContact = 1, WeakHydrogenBond = 2, SmallOverlap = 3,
Bump = 4, BadBump = 5, StandardHydrogenBond = 6, Invalid = -1
};
/// @brief Determine the type of interaction that is represented by a CheckDotResult.
/// @param [in] checkDotResult Value returned from the check_dot() method.
/// @return InteractionType of the contact, Invalid if the OverlapType was Ignore or
/// a non-negative number indicating the index of the interaction type in the
/// original Probe code.
InteractionType interaction_type(OverlapType overlapType, double gap) const;
/// @brief String name for the interaction type, meaningful to the user.
/// @param [in] t Type to report on.
/// @return String name suitable for printing.
static std::string interaction_type_name(InteractionType t);
/// @brief Short string name for the interaction type, meaningful to the user.
/// @param [in] t Type to report on.
/// @return String name suitable for printing.
static std::string interaction_type_short_name(InteractionType t);
/// @brief Structure to hold the results from a call to score_dots()
class ScoreDotsResult {
public:
ScoreDotsResult() : valid(false), bumpSubScore(0), hBondSubScore(0), attractSubScore(0), hasBadBump(false) {};
bool valid; ///< False if this information has not yet been computed.
double bumpSubScore; ///< Portion of the score due to bumps
double hBondSubScore; ///< Portion of the score due to hydrogen bonds
double attractSubScore; ///< Portion of the score due to non-bumping attraction
bool hasBadBump; ///< Did this atom have a bad bump for any of its dots?
/// @brief Sum of all of the sub-scores, the total score
double totalScore() const { return bumpSubScore + hBondSubScore + attractSubScore; }
};
/// @brief Determine the bump and hydrogen-bond subscores for a vector of dots on an atom
/// @param [in] sourceAtom Atom that the dots are surrounding.
/// @param [in] minOccupancy The minimum occupancy of the atom to be scored (applies to both
/// source and target; if either is below this, it will not be scored.
/// If the source is below this, the return value will be marked valid but will
/// have 0 in all of its interactions.
/// @param [in] spatialQuery Structure to ask for neighbors of the atom. This must contain
/// only atoms that are to be considered; those that are in the same conformation
/// or in all conformations.
/// @param [in] nearbyRadius Maximum distance that an atom can be away and still be a neighbor.
/// This should NOT include consideration of the probe radius, which will be added
/// inside this function when it is required (depending on whether onlyBumps is
/// set).
/// @param [in] probeRadius Radius of the probe rolled between the two potentially-contacting atoms
/// If this is < 0, an invalid result will be returned.
/// @param [in] excluded Atoms that are to be excluded from contact, for example this could be a list
/// of atoms bonded to sourceAtom.
/// @param [in] dots Vector of dots to compare. Each is added to the sourceAtom origin.
/// @param [in] density Density of the dots on the probe sphere, used to normalize results.
/// If this is <= 0, an invalid result will be returned.
/// @param [in] onlyBumps If true, ignore near touches and count even hydrogen bonds as bumps.
/// @return Normalized sum of scores, also broken down by hydrogen bond vs. bump scores.
ScoreDotsResult score_dots(iotbx::pdb::hierarchy::atom sourceAtom, double minOccupancy,
SpatialQuery &spatialQuery, double nearbyRadius, double probeRadius,
scitbx::af::shared<iotbx::pdb::hierarchy::atom> const &exclude,
scitbx::af::shared<Point> const &dots, double density, bool onlyBumps);
/// @brief Count how many surface dots on an atom are not within an excluded atom.
/// @param [in] sourceAtom Atom that the dot is offset with respect to.
/// @param [in] dots Vector of dots to compare. Each is added to the sourceAtom origin.
/// @param [in] excluded Atoms that are to be excluded from contact, for example this could be a list
/// of atoms bonded to sourceAtom. If the dot is inside an excluded atom, it will not be
/// counted.
/// @return Number of surface dots that are not inside an excluded atom.
unsigned count_surface_dots(iotbx::pdb::hierarchy::atom sourceAtom, scitbx::af::shared<Point> const& dots,
scitbx::af::shared<iotbx::pdb::hierarchy::atom> const& exclude);
//===========================================================================
// Seldom-used methods below here.
/// @brief Test method to verify that the class is behaving as intended.
/// @return Empty string on success, string telling what went wrong on failure.
static std::string test();
protected:
/// Parameters stored from constructor.
ExtraAtomInfoMap m_extraInfoMap;
double m_gapScale;
double m_bumpWeight;
double m_hBondWeight;
double m_maxRegularHydrogenOverlap;
double m_maxChargedHydrogenOverlap;
double m_bumpOverlap;
double m_badBumpOverlap;
double m_contactCutoff;
bool m_weakHBonds;
};
/// @todo Figure out what all of the things needed by Probe (as opposed to Reduce) are.
//=====================================================================================================
/// @brief Test function to verify that all classes are behaving as intended.
/// @return Empty string on success, string telling what went wrong on failure.
std::string Scoring_test();
}
}
| 58.524457 | 118 | 0.643962 |
d0f41012352d5170b5fb1a193492d06402bcc22e | 3,075 | h | C | Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Widgets/EditorContextMenu/ContextMenuActions/NodeGroupMenuActions/NodeGroupContextMenuActions.h | whywhywhyw/o3de | 8e09f66799d4c8f188d45861d821e8656a554cb1 | [
"Apache-2.0",
"MIT"
] | 11 | 2021-07-08T09:58:26.000Z | 2022-03-17T17:59:26.000Z | Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Widgets/EditorContextMenu/ContextMenuActions/NodeGroupMenuActions/NodeGroupContextMenuActions.h | RoddieKieley/o3de | e804fd2a4241b039a42d9fa54eaae17dc94a7a92 | [
"Apache-2.0",
"MIT"
] | 29 | 2021-07-06T19:33:52.000Z | 2022-03-22T10:27:49.000Z | Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Widgets/EditorContextMenu/ContextMenuActions/NodeGroupMenuActions/NodeGroupContextMenuActions.h | RoddieKieley/o3de | e804fd2a4241b039a42d9fa54eaae17dc94a7a92 | [
"Apache-2.0",
"MIT"
] | 4 | 2021-07-06T19:24:43.000Z | 2022-03-31T12:42:27.000Z | /*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/Memory/SystemAllocator.h>
#include <GraphCanvas/Widgets/EditorContextMenu/ContextMenuActions/NodeGroupMenuActions/NodeGroupContextMenuAction.h>
namespace GraphCanvas
{
class CreateNodeGroupMenuAction
: public NodeGroupContextMenuAction
{
public:
AZ_CLASS_ALLOCATOR(CreateNodeGroupMenuAction, AZ::SystemAllocator, 0);
CreateNodeGroupMenuAction(QObject* parent, bool collapseGroup);
virtual ~CreateNodeGroupMenuAction() = default;
using ContextMenuAction::RefreshAction;
void RefreshAction() override;
using NodeGroupContextMenuAction::TriggerAction;
SceneReaction TriggerAction(const AZ::Vector2& scenePos) override;
private:
bool m_collapseGroup;
};
class UngroupNodeGroupMenuAction
: public NodeGroupContextMenuAction
{
public:
AZ_CLASS_ALLOCATOR(UngroupNodeGroupMenuAction, AZ::SystemAllocator, 0);
UngroupNodeGroupMenuAction(QObject* parent);
virtual ~UngroupNodeGroupMenuAction() = default;
using ContextMenuAction::RefreshAction;
void RefreshAction() override;
using NodeGroupContextMenuAction::TriggerAction;
SceneReaction TriggerAction(const AZ::Vector2& scenePos) override;
};
class CollapseNodeGroupMenuAction
: public NodeGroupContextMenuAction
{
public:
AZ_CLASS_ALLOCATOR(CollapseNodeGroupMenuAction, AZ::SystemAllocator, 0);
CollapseNodeGroupMenuAction(QObject* parent);
virtual ~CollapseNodeGroupMenuAction() = default;
using ContextMenuAction::RefreshAction;
void RefreshAction() override;
using NodeGroupContextMenuAction::TriggerAction;
SceneReaction TriggerAction(const AZ::Vector2& scenePos) override;
};
class ExpandNodeGroupMenuAction
: public NodeGroupContextMenuAction
{
public:
AZ_CLASS_ALLOCATOR(ExpandNodeGroupMenuAction, AZ::SystemAllocator, 0);
ExpandNodeGroupMenuAction(QObject* parent);
virtual ~ExpandNodeGroupMenuAction() = default;
using ContextMenuAction::RefreshAction;
void RefreshAction() override;
using NodeGroupContextMenuAction::TriggerAction;
SceneReaction TriggerAction(const AZ::Vector2& scenePos) override;
};
class EditGroupTitleMenuAction
: public NodeGroupContextMenuAction
{
public:
AZ_CLASS_ALLOCATOR(EditGroupTitleMenuAction, AZ::SystemAllocator, 0);
EditGroupTitleMenuAction(QObject* parent);
virtual ~EditGroupTitleMenuAction() = default;
using ContextMenuAction::RefreshAction;
void RefreshAction() override;
using NodeGroupContextMenuAction::TriggerAction;
SceneReaction TriggerAction(const AZ::Vector2& scenePos) override;
};
}
| 29.567308 | 117 | 0.72 |
190013533a268a91b9da0de7458b42d9df335d45 | 3,524 | h | C | src/mame/includes/fuukifg3.h | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | 26 | 2015-03-31T06:25:51.000Z | 2021-12-14T09:29:04.000Z | src/mame/includes/fuukifg3.h | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | null | null | null | src/mame/includes/fuukifg3.h | Robbbert/messui | 49b756e2140d8831bc81335298ee8c5471045e79 | [
"BSD-3-Clause"
] | 10 | 2015-03-27T05:45:51.000Z | 2022-02-04T06:57:36.000Z | // license:BSD-3-Clause
// copyright-holders:Paul Priest, David Haywood, Luca Elia
#ifndef MAME_INCLUDES_FUUKIFG3_H
#define MAME_INCLUDES_FUUKIFG3_H
#pragma once
#include "video/fuukifg.h"
#include "emupal.h"
#include "screen.h"
#include "tilemap.h"
/* Define clocks based on actual OSC on the PCB */
#define CPU_CLOCK (XTAL(40'000'000) / 2) /* clock for 68020 */
#define SOUND_CPU_CLOCK (XTAL(12'000'000) / 2) /* clock for Z80 sound CPU */
class fuuki32_state : public driver_device
{
public:
fuuki32_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag)
, m_maincpu(*this, "maincpu")
, m_gfxdecode(*this, "gfxdecode")
, m_screen(*this, "screen")
, m_palette(*this, "palette")
, m_fuukivid(*this, "fuukivid")
, m_spriteram(*this, "spriteram", 0x2000, ENDIANNESS_BIG)
, m_vram(*this, "vram.%u", 0)
, m_vregs(*this, "vregs", 0x20, ENDIANNESS_BIG)
, m_priority(*this, "priority")
, m_tilebank(*this, "tilebank")
, m_shared_ram(*this, "shared_ram")
, m_soundbank(*this, "soundbank")
, m_system(*this, "SYSTEM")
, m_inputs(*this, "INPUTS")
, m_dsw1(*this, "DSW1")
, m_dsw2(*this, "DSW2")
{ }
void fuuki32(machine_config &config);
private:
enum
{
TIMER_LEVEL_1_INTERRUPT,
TIMER_VBLANK_INTERRUPT,
TIMER_RASTER_INTERRUPT
};
/* devices */
required_device<cpu_device> m_maincpu;
required_device<gfxdecode_device> m_gfxdecode;
required_device<screen_device> m_screen;
required_device<palette_device> m_palette;
required_device<fuukivid_device> m_fuukivid;
/* memory pointers */
memory_share_creator<u16> m_spriteram;
required_shared_ptr_array<u32, 4> m_vram;
memory_share_creator<u16> m_vregs;
required_shared_ptr<u32> m_priority;
required_shared_ptr<u32> m_tilebank;
required_shared_ptr<u8> m_shared_ram;
std::unique_ptr<u16[]> m_buf_spriteram[2];
required_memory_bank m_soundbank;
required_ioport m_system;
required_ioport m_inputs;
required_ioport m_dsw1;
required_ioport m_dsw2;
/* video-related */
tilemap_t *m_tilemap[3];
u32 m_spr_buffered_tilebank[2];
/* misc */
emu_timer *m_level_1_interrupt_timer;
emu_timer *m_vblank_interrupt_timer;
emu_timer *m_raster_interrupt_timer;
u8 snd_020_r(offs_t offset);
void snd_020_w(offs_t offset, u8 data, u8 mem_mask = ~0);
void sprram_w(offs_t offset, u16 data, u16 mem_mask = ~0);
u16 sprram_r(offs_t offset);
u16 vregs_r(offs_t offset);
void vregs_w(offs_t offset, u16 data, u16 mem_mask = ~0);
void sound_bw_w(u8 data);
template<int Layer> void vram_w(offs_t offset, u32 data, u32 mem_mask = ~0);
template<int Layer> void vram_buffered_w(offs_t offset, u32 data, u32 mem_mask = ~0);
template<int Layer, int ColShift> TILE_GET_INFO_MEMBER(get_tile_info);
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void video_start() override;
void fuuki32_tile_cb(u32 &code);
void fuuki32_colpri_cb(u32 &colour, u32 &pri_mask);
u32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
DECLARE_WRITE_LINE_MEMBER(screen_vblank);
void draw_layer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, u8 i, int flag, u8 pri, u8 primask = 0xff);
void fuuki32_map(address_map &map);
void fuuki32_sound_io_map(address_map &map);
void fuuki32_sound_map(address_map &map);
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
};
#endif // MAME_INCLUDES_FUUKIFG3_H
| 30.912281 | 132 | 0.745743 |
5cf9c9b17ec612cb182b01afb0b0998939930967 | 7,054 | h | C | ns-allinone-3.27/ns-3.27/src/wave/helper/wave-mac-helper.h | zack-braun/4607_NS | 43c8fb772e5552fb44bd7cd34173e73e3fb66537 | [
"MIT"
] | 93 | 2019-04-21T08:22:26.000Z | 2022-03-30T04:26:29.000Z | ns-allinone-3.27/ns-3.27/src/wave/helper/wave-mac-helper.h | zack-braun/4607_NS | 43c8fb772e5552fb44bd7cd34173e73e3fb66537 | [
"MIT"
] | 12 | 2019-04-19T16:39:58.000Z | 2021-06-22T13:18:32.000Z | ns-allinone-3.27/ns-3.27/src/wave/helper/wave-mac-helper.h | zack-braun/4607_NS | 43c8fb772e5552fb44bd7cd34173e73e3fb66537 | [
"MIT"
] | 21 | 2019-05-27T19:36:12.000Z | 2021-07-26T02:37:41.000Z | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2008 INRIA
* Copyright (c) 2009 MIRKO BANCHI
* Copyright (c) 2013 Dalian University of Technology
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
* Author: Mirko Banchi <mk.banchi@gmail.com>
* Author: Junling Bu <linlinjavaer@gmail.com>
*/
#ifndef WAVE_MAC_HELPER_H
#define WAVE_MAC_HELPER_H
#include "ns3/wifi-mac-helper.h"
namespace ns3 {
/**
* \ingroup wave
* \brief Nqos Wave Mac Helper class
*/
class NqosWaveMacHelper : public WifiMacHelper
{
public:
/**
* Create a NqosWaveMacHelper to make life easier for people who want to
* work with non-QOS Wave MAC layers.
*/
NqosWaveMacHelper (void);
/**
* Destroy a NqosWaveMacHelper.
*/
virtual ~NqosWaveMacHelper (void);
/**
* Create a mac helper in a default working state.
* i.e., this is an ocb mac by default.
* \returns NqosWaveMacHelper
*/
static NqosWaveMacHelper Default (void);
/**
* \param type the type of ns3::WifiMac to create.
* \param n0 the name of the attribute to set
* \param v0 the value of the attribute to set
* \param n1 the name of the attribute to set
* \param v1 the value of the attribute to set
* \param n2 the name of the attribute to set
* \param v2 the value of the attribute to set
* \param n3 the name of the attribute to set
* \param v3 the value of the attribute to set
* \param n4 the name of the attribute to set
* \param v4 the value of the attribute to set
* \param n5 the name of the attribute to set
* \param v5 the value of the attribute to set
* \param n6 the name of the attribute to set
* \param v6 the value of the attribute to set
* \param n7 the name of the attribute to set
* \param v7 the value of the attribute to set
* \param n8 the value of the attribute to set
* \param v8 the value of the attribute to set
* \param n9 the value of the attribute to set
* \param v9 the value of the attribute to set
* \param n10 the value of the attribute to set
* \param v10 the value of the attribute to set
*
* All the attributes specified in this method should exist
* in the requested mac.
*
* note: Here we require users set type with OcbWifiMac or its
* subclass, otherwise it will become error
*/
virtual void SetType (std::string type,
std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue (),
std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue ());
};
/**
* \ingroup wave
* \brief Qos Wave Mac Helper class
*/
class QosWaveMacHelper : public WifiMacHelper
{
public:
/**
* Create a QosWaveMacHelper that is used to make life easier when working
* with Wifi 802.11p devices using a QOS MAC layer.
*/
QosWaveMacHelper (void);
/**
* Destroy a QosWaveMacHelper
*/
virtual ~QosWaveMacHelper (void);
/**
* Create a mac helper in a default working state.
*/
static QosWaveMacHelper Default (void);
/**
* \param type the type of ns3::WifiMac to create.
* \param n0 the name of the attribute to set
* \param v0 the value of the attribute to set
* \param n1 the name of the attribute to set
* \param v1 the value of the attribute to set
* \param n2 the name of the attribute to set
* \param v2 the value of the attribute to set
* \param n3 the name of the attribute to set
* \param v3 the value of the attribute to set
* \param n4 the name of the attribute to set
* \param v4 the value of the attribute to set
* \param n5 the name of the attribute to set
* \param v5 the value of the attribute to set
* \param n6 the name of the attribute to set
* \param v6 the value of the attribute to set
* \param n7 the name of the attribute to set
* \param v7 the value of the attribute to set
* \param n8 the value of the attribute to set
* \param v8 the value of the attribute to set
* \param n9 the value of the attribute to set
* \param v9 the value of the attribute to set
* \param n10 the value of the attribute to set
* \param v10 the value of the attribute to set
*
* All the attributes specified in this method should exist
* in the requested mac.
*
* note: Here we require users set type with OcbWifiMac or its
* subclass, otherwise it will become error
*/
virtual void SetType (std::string type,
std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue (),
std::string n10 = "", const AttributeValue &v10 = EmptyAttributeValue ());
};
}
#endif /* WAVE_MAC_HELPER_H */
| 41.739645 | 98 | 0.645733 |
d0588caf801745d37431c35171d8190065f487fc | 1,031 | h | C | ShowNews/ShowNews/classes/Scences/User/Model/User.h | fearlessyyp/YZZLShowNews | 6cbcc59d96017e3132102fe5c7dcb72aab232b07 | [
"Apache-2.0"
] | null | null | null | ShowNews/ShowNews/classes/Scences/User/Model/User.h | fearlessyyp/YZZLShowNews | 6cbcc59d96017e3132102fe5c7dcb72aab232b07 | [
"Apache-2.0"
] | null | null | null | ShowNews/ShowNews/classes/Scences/User/Model/User.h | fearlessyyp/YZZLShowNews | 6cbcc59d96017e3132102fe5c7dcb72aab232b07 | [
"Apache-2.0"
] | null | null | null | //
// User.h
// ShowNews
//
// Created by YYP on 16/7/2.
// Copyright © 2016年 YZZL. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface User : NSObject
/// 用户名
@property (nonatomic, strong) NSString *username;
/// 密码
@property (nonatomic, strong) NSString *password;
/// 电话号码
@property (nonatomic, strong) NSString *phone;
/// 邮箱
@property (nonatomic, strong) NSString *email;
/// 头像
@property (nonatomic, strong) NSData *image;
/// ID
@property (nonatomic, strong) NSString *Id;
- (instancetype)initWithUserName:(NSString *)username
password:(NSString *)password
phone:(NSString *)phone
email:(NSString *)email
image:(NSData *)image;
+ (instancetype)userWithUserName:(NSString *)username
password:(NSString *)password
phone:(NSString *)phone
email:(NSString *)email
image:(NSData *)image;
@end
| 27.131579 | 53 | 0.57129 |
fd9b43d67fd4c987653d595ab5cd82b9f50fb0ca | 260 | h | C | ios/versioned-react-native/ABI28_0_0/Expo/Core/Api/Components/GestureHandler/ABI28_0_0RNGestureHandlerModule.h | ThakurKarthik/expo | ed78ed4f07c950184a59422ebd95645253f44e3d | [
"Apache-2.0",
"MIT"
] | 2 | 2019-08-15T19:24:41.000Z | 2020-09-28T00:44:04.000Z | ios/versioned-react-native/ABI28_0_0/Expo/Core/Api/Components/GestureHandler/ABI28_0_0RNGestureHandlerModule.h | ThakurKarthik/expo | ed78ed4f07c950184a59422ebd95645253f44e3d | [
"Apache-2.0",
"MIT"
] | 2 | 2022-02-14T18:22:55.000Z | 2022-02-26T02:17:58.000Z | ios/versioned-react-native/ABI28_0_0/Expo/Core/Api/Components/GestureHandler/ABI28_0_0RNGestureHandlerModule.h | ThakurKarthik/expo | ed78ed4f07c950184a59422ebd95645253f44e3d | [
"Apache-2.0",
"MIT"
] | 1 | 2020-03-01T01:28:59.000Z | 2020-03-01T01:28:59.000Z | #import <ReactABI28_0_0/ABI28_0_0RCTEventEmitter.h>
#import <ReactABI28_0_0/ABI28_0_0RCTBridgeModule.h>
#import <ReactABI28_0_0/ABI28_0_0RCTUIManager.h>
@interface ABI28_0_0RNGestureHandlerModule : ABI28_0_0RCTEventEmitter <ABI28_0_0RCTBridgeModule>
@end
| 28.888889 | 96 | 0.857692 |
45c57b3178bc333b7ed353a2e9868a14702024ff | 16,267 | c | C | src/base/flamec/supermatrix/gpu/main/FLASH_Queue_gpu.c | greck2908/libflame | 51d901f5fa1729c018c19110d100d117b91a0e65 | [
"BSD-3-Clause"
] | 27 | 2017-10-01T08:26:08.000Z | 2022-01-03T20:26:42.000Z | src/base/flamec/supermatrix/gpu/main/FLASH_Queue_gpu.c | greck2908/libflame | 51d901f5fa1729c018c19110d100d117b91a0e65 | [
"BSD-3-Clause"
] | null | null | null | src/base/flamec/supermatrix/gpu/main/FLASH_Queue_gpu.c | greck2908/libflame | 51d901f5fa1729c018c19110d100d117b91a0e65 | [
"BSD-3-Clause"
] | 11 | 2017-07-30T19:15:00.000Z | 2020-02-21T13:18:13.000Z | /*
Copyright (C) 2014, The University of Texas at Austin
This file is part of libflame and is available under the 3-Clause
BSD license, which can be found in the LICENSE file at the top-level
directory, or at http://opensource.org/licenses/BSD-3-Clause
*/
#include "FLAME.h"
#ifdef FLA_ENABLE_GPU
#include "cublas.h"
static FLA_Bool flash_queue_enabled_gpu = FALSE;
static dim_t flash_queue_gpu_n_blocks = 128;
void FLASH_Queue_init_gpu( void )
/*----------------------------------------------------------------------------
FLASH_Queue_init_gpu
----------------------------------------------------------------------------*/
{
cublasInit();
return;
}
void FLASH_Queue_finalize_gpu( void )
/*----------------------------------------------------------------------------
FLASH_Queue_finalize_gpu
----------------------------------------------------------------------------*/
{
cublasShutdown();
return;
}
FLA_Error FLASH_Queue_enable_gpu( void )
/*----------------------------------------------------------------------------
FLASH_Queue_enable_gpu
----------------------------------------------------------------------------*/
{
if ( FLASH_Queue_stack_depth() == 0 && FLASH_Queue_get_enabled() )
{
// Enable if not begin parallel region yet and SuperMatrix is enabled.
flash_queue_enabled_gpu = TRUE;
return FLA_SUCCESS;
}
else
{
// Cannot change status during parallel region.
return FLA_FAILURE;
}
}
FLA_Error FLASH_Queue_disable_gpu( void )
/*----------------------------------------------------------------------------
FLASH_Queue_disable_gpu
----------------------------------------------------------------------------*/
{
if ( FLASH_Queue_stack_depth() == 0 )
{
// Disable if not begin parallel region yet.
flash_queue_enabled_gpu = FALSE;
return FLA_SUCCESS;
}
else
{
// Cannot change status during parallel region.
return FLA_FAILURE;
}
}
FLA_Bool FLASH_Queue_get_enabled_gpu( void )
/*----------------------------------------------------------------------------
FLASH_Queue_get_enabled_gpu
----------------------------------------------------------------------------*/
{
// Return if SuperMatrix is enabled, but always false if not.
if ( FLASH_Queue_get_enabled() )
return flash_queue_enabled_gpu;
else
return FALSE;
}
void FLASH_Queue_set_gpu_num_blocks( dim_t n_blocks )
/*----------------------------------------------------------------------------
FLASH_Queue_set_gpu_num_blocks
----------------------------------------------------------------------------*/
{
flash_queue_gpu_n_blocks = n_blocks;
return;
}
dim_t FLASH_Queue_get_gpu_num_blocks( void )
/*----------------------------------------------------------------------------
FLASH_Queue_get_gpu_num_blocks
----------------------------------------------------------------------------*/
{
return flash_queue_gpu_n_blocks;
}
// --- helper functions --- ===================================================
FLA_Error FLASH_Queue_bind_gpu( integer thread )
/*----------------------------------------------------------------------------
FLASH_Queue_bind_gpu
----------------------------------------------------------------------------*/
{
// Bind a GPU to this thread.
cudaSetDevice( thread );
return FLA_SUCCESS;
}
FLA_Error FLASH_Queue_alloc_gpu( dim_t size,
FLA_Datatype datatype,
void** buffer_gpu )
/*----------------------------------------------------------------------------
FLASH_Queue_alloc_gpu
----------------------------------------------------------------------------*/
{
cublasStatus status;
// Allocate memory for a block on GPU.
status = cublasAlloc( size,
FLA_Obj_datatype_size( datatype ),
buffer_gpu );
// Check to see if the allocation was successful.
if ( status != CUBLAS_STATUS_SUCCESS )
FLA_Check_error_code( FLA_MALLOC_GPU_RETURNED_NULL_POINTER );
return FLA_SUCCESS;
}
FLA_Error FLASH_Queue_free_gpu( void* buffer_gpu )
/*----------------------------------------------------------------------------
FLASH_Queue_free_gpu
----------------------------------------------------------------------------*/
{
// Free memory for a block on GPU.
cublasFree( buffer_gpu );
return FLA_SUCCESS;
}
FLA_Error FLASH_Queue_write_gpu( FLA_Obj obj, void* buffer_gpu )
/*----------------------------------------------------------------------------
FLASH_Queue_write_gpu
----------------------------------------------------------------------------*/
{
// Write the contents of a block in main memory to GPU.
cublasSetMatrix( FLA_Obj_length( obj ),
FLA_Obj_width( obj ),
FLA_Obj_datatype_size( FLA_Obj_datatype( obj ) ),
FLA_Obj_buffer_at_view( obj ),
FLA_Obj_col_stride( obj ),
buffer_gpu,
FLA_Obj_length( obj ) );
return FLA_SUCCESS;
}
FLA_Error FLASH_Queue_read_gpu( FLA_Obj obj, void* buffer_gpu )
/*----------------------------------------------------------------------------
FLASH_Queue_read_gpu
----------------------------------------------------------------------------*/
{
// Read the memory of a block on GPU to main memory.
cublasGetMatrix( FLA_Obj_length( obj ),
FLA_Obj_width( obj ),
FLA_Obj_datatype_size( FLA_Obj_datatype( obj ) ),
buffer_gpu,
FLA_Obj_length( obj ),
FLA_Obj_buffer_at_view( obj ),
FLA_Obj_col_stride( obj ) );
return FLA_SUCCESS;
}
void FLASH_Queue_exec_task_gpu( FLASH_Task* t,
void** input_arg,
void** output_arg )
/*----------------------------------------------------------------------------
FLASH_Queue_exec_task_gpu
----------------------------------------------------------------------------*/
{
// Define local function pointer types.
// Level-3 BLAS
typedef FLA_Error(*flash_gemm_gpu_p)(FLA_Trans transa, FLA_Trans transb, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_hemm_gpu_p)(FLA_Side side, FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_herk_gpu_p)(FLA_Uplo uplo, FLA_Trans transa, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_her2k_gpu_p)(FLA_Uplo uplo, FLA_Trans transa, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_symm_gpu_p)(FLA_Side side, FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_syrk_gpu_p)(FLA_Uplo uplo, FLA_Trans transa, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_syr2k_gpu_p)(FLA_Uplo uplo, FLA_Trans transa, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu, FLA_Obj beta, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_trmm_gpu_p)(FLA_Side side, FLA_Uplo uplo, FLA_Trans trans, FLA_Diag diag, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj C, void* C_gpu);
typedef FLA_Error(*flash_trsm_gpu_p)(FLA_Side side, FLA_Uplo uplo, FLA_Trans trans, FLA_Diag diag, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj C, void* C_gpu);
// Level-2 BLAS
typedef FLA_Error(*flash_gemv_gpu_p)(FLA_Trans transa, FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj x, void* x_gpu, FLA_Obj beta, FLA_Obj y, void* y_gpu);
typedef FLA_Error(*flash_trsv_gpu_p)(FLA_Uplo uplo, FLA_Trans trans, FLA_Diag diag, FLA_Obj A, void* A_gpu, FLA_Obj x, void* x_gpu);
// Level-1 BLAS
typedef FLA_Error(*flash_axpy_gpu_p)(FLA_Obj alpha, FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu);
typedef FLA_Error(*flash_copy_gpu_p)(FLA_Obj A, void* A_gpu, FLA_Obj B, void* B_gpu);
typedef FLA_Error(*flash_scal_gpu_p)(FLA_Obj alpha, FLA_Obj A, void* A_gpu);
typedef FLA_Error(*flash_scalr_gpu_p)(FLA_Uplo uplo, FLA_Obj alpha, FLA_Obj A, void* A_gpu);
// Only execute task if it is not NULL.
if ( t == NULL )
return;
// Now "switch" between the various possible task functions.
// FLA_Gemm
if ( t->func == (void *) FLA_Gemm_task )
{
flash_gemm_gpu_p func;
func = (flash_gemm_gpu_p) FLA_Gemm_external_gpu;
func( ( FLA_Trans ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Hemm
else if ( t->func == (void *) FLA_Hemm_task )
{
flash_hemm_gpu_p func;
func = (flash_hemm_gpu_p) FLA_Hemm_external_gpu;
func( ( FLA_Side ) t->int_arg[0],
( FLA_Uplo ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Herk
else if ( t->func == (void *) FLA_Herk_task )
{
flash_herk_gpu_p func;
func = (flash_herk_gpu_p) FLA_Herk_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Her2k
else if ( t->func == (void *) FLA_Her2k_task )
{
flash_her2k_gpu_p func;
func = (flash_her2k_gpu_p) FLA_Her2k_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Symm
else if ( t->func == (void *) FLA_Symm_task )
{
flash_symm_gpu_p func;
func = (flash_symm_gpu_p) FLA_Symm_external_gpu;
func( ( FLA_Side ) t->int_arg[0],
( FLA_Uplo ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Syrk
else if ( t->func == (void *) FLA_Syrk_task )
{
flash_syrk_gpu_p func;
func = (flash_syrk_gpu_p) FLA_Syrk_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Syr2k
else if ( t->func == (void *) FLA_Syr2k_task )
{
flash_syr2k_gpu_p func;
func = (flash_syr2k_gpu_p) FLA_Syr2k_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Trmm
else if ( t->func == (void *) FLA_Trmm_task )
{
flash_trmm_gpu_p func;
func = (flash_trmm_gpu_p) FLA_Trmm_external_gpu;
func( ( FLA_Side ) t->int_arg[0],
( FLA_Uplo ) t->int_arg[1],
( FLA_Trans ) t->int_arg[2],
( FLA_Diag ) t->int_arg[3],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Trsm
else if ( t->func == (void *) FLA_Trsm_task )
{
flash_trsm_gpu_p func;
func = (flash_trsm_gpu_p) FLA_Trsm_external_gpu;
func( ( FLA_Side ) t->int_arg[0],
( FLA_Uplo ) t->int_arg[1],
( FLA_Trans ) t->int_arg[2],
( FLA_Diag ) t->int_arg[3],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Gemv
else if ( t->func == (void *) FLA_Gemv_task )
{
flash_gemv_gpu_p func;
func = (flash_gemv_gpu_p) FLA_Gemv_external_gpu;
func( ( FLA_Trans ) t->int_arg[0],
t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->input_arg[1],
input_arg[1],
t->fla_arg[1],
t->output_arg[0],
output_arg[0] );
}
// FLA_Trsv
else if ( t->func == (void *) FLA_Trsv_task )
{
flash_trsv_gpu_p func;
func = (flash_trsv_gpu_p) FLA_Trsv_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
( FLA_Trans ) t->int_arg[1],
( FLA_Diag ) t->int_arg[2],
t->input_arg[0],
input_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Axpy
else if ( t->func == (void *) FLA_Axpy_task )
{
flash_axpy_gpu_p func;
func = (flash_axpy_gpu_p) FLA_Axpy_external_gpu;
func( t->fla_arg[0],
t->input_arg[0],
input_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Copy
else if ( t->func == (void *) FLA_Copy_task )
{
flash_copy_gpu_p func;
func = (flash_copy_gpu_p) FLA_Copy_external_gpu;
func( t->input_arg[0],
input_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Scal
else if ( t->func == (void *) FLA_Scal_task )
{
flash_scal_gpu_p func;
func = (flash_scal_gpu_p) FLA_Scal_external_gpu;
func( t->fla_arg[0],
t->output_arg[0],
output_arg[0] );
}
// FLA_Scalr
else if ( t->func == (void *) FLA_Scalr_task )
{
flash_scalr_gpu_p func;
func = (flash_scalr_gpu_p) FLA_Scalr_external_gpu;
func( ( FLA_Uplo ) t->int_arg[0],
t->fla_arg[0],
t->output_arg[0],
output_arg[0] );
}
else
{
FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
}
return;
}
#endif // FLA_ENABLE_GPU
| 32.92915 | 177 | 0.456384 |
a9d9c075b2cb12bdf014aa1f9bade6d0d2529541 | 3,872 | h | C | VTK/Hybrid/vtkLandmarkTransform.h | matthb2/ParaView-beforekitwareswtichedtogit | e47e57d6ce88444d9e6af9ab29f9db8c23d24cef | [
"BSD-3-Clause"
] | 1 | 2021-07-31T19:38:03.000Z | 2021-07-31T19:38:03.000Z | VTK/Hybrid/vtkLandmarkTransform.h | matthb2/ParaView-beforekitwareswtichedtogit | e47e57d6ce88444d9e6af9ab29f9db8c23d24cef | [
"BSD-3-Clause"
] | null | null | null | VTK/Hybrid/vtkLandmarkTransform.h | matthb2/ParaView-beforekitwareswtichedtogit | e47e57d6ce88444d9e6af9ab29f9db8c23d24cef | [
"BSD-3-Clause"
] | 2 | 2019-01-22T19:51:40.000Z | 2021-07-31T19:38:05.000Z | /*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile$
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME vtkLandmarkTransform - a linear transform specified by two corresponding point sets
// .SECTION Description
// A vtkLandmarkTransform is defined by two sets of landmarks, the
// transform computed gives the best fit mapping one onto the other, in a
// least squares sense. The indices are taken to correspond, so point 1
// in the first set will get mapped close to point 1 in the second set,
// etc. Call SetSourceLandmarks and SetTargetLandmarks to specify the two
// sets of landmarks, ensure they have the same number of points.
// .SECTION Caveats
// Whenever you add, subtract, or set points you must call Modified()
// on the vtkPoints object, or the transformation might not update.
// .SECTION see also
// vtkLinearTransform
#ifndef __vtkLandmarkTransform_h
#define __vtkLandmarkTransform_h
#include "vtkLinearTransform.h"
#define VTK_LANDMARK_RIGIDBODY 6
#define VTK_LANDMARK_SIMILARITY 7
#define VTK_LANDMARK_AFFINE 12
class VTK_HYBRID_EXPORT vtkLandmarkTransform : public vtkLinearTransform
{
public:
static vtkLandmarkTransform *New();
vtkTypeRevisionMacro(vtkLandmarkTransform,vtkLinearTransform);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Specify the source and target landmark sets. The two sets must have
// the same number of points. If you add or change points in these objects,
// you must call Modified() on them or the transformation might not update.
void SetSourceLandmarks(vtkPoints *points);
void SetTargetLandmarks(vtkPoints *points);
vtkGetObjectMacro(SourceLandmarks, vtkPoints);
vtkGetObjectMacro(TargetLandmarks, vtkPoints);
// Description:
// Set the number of degrees of freedom to constrain the solution to.
// Rigidbody: rotation and translation only.
// Similarity: rotation, translation and isotropic scaling.
// The default is similarity.
vtkSetMacro(Mode,int);
void SetModeToRigidBody() { this->SetMode(VTK_LANDMARK_RIGIDBODY); };
void SetModeToSimilarity() { this->SetMode(VTK_LANDMARK_SIMILARITY); };
void SetModeToAffine() { this->SetMode(VTK_LANDMARK_AFFINE); };
vtkGetMacro(Mode,int);
const char *GetModeAsString();
// Description:
// Invert the transformation. This is done by switching the
// source and target landmarks.
void Inverse();
// Description:
// Get the MTime.
unsigned long GetMTime();
// Description:
// Make another transform of the same type.
vtkAbstractTransform *MakeTransform();
protected:
vtkLandmarkTransform();
~vtkLandmarkTransform();
// Update the matrix from the quaternion.
void InternalUpdate();
// Description:
// This method does no type checking, use DeepCopy instead.
void InternalDeepCopy(vtkAbstractTransform *transform);
vtkPoints* SourceLandmarks;
vtkPoints* TargetLandmarks;
int Mode;
private:
vtkLandmarkTransform(const vtkLandmarkTransform&); // Not implemented.
void operator=(const vtkLandmarkTransform&); // Not implemented.
};
//BTX
inline const char *vtkLandmarkTransform::GetModeAsString()
{
switch (this->Mode)
{
case VTK_LANDMARK_RIGIDBODY:
return "RigidBody";
case VTK_LANDMARK_SIMILARITY:
return "Similarity";
case VTK_LANDMARK_AFFINE:
return "Affine";
default:
return "Unrecognized";
}
}
//ETX
#endif
| 33.094017 | 92 | 0.722624 |
43ca863bd9c88a03f8c17a83e43ca84753d3450d | 124,564 | c | C | MagickCore/visual-effects.c | feiser2016/ImageMagick | 5a526edbbf98b4ba244fd62e8460e8e1d0ee274f | [
"ImageMagick"
] | null | null | null | MagickCore/visual-effects.c | feiser2016/ImageMagick | 5a526edbbf98b4ba244fd62e8460e8e1d0ee274f | [
"ImageMagick"
] | null | null | null | MagickCore/visual-effects.c | feiser2016/ImageMagick | 5a526edbbf98b4ba244fd62e8460e8e1d0ee274f | [
"ImageMagick"
] | null | null | null | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% FFFFF X X %
% F X X %
% FFF X %
% F X X %
% F X X %
% %
% %
% MagickCore Image Special Effects Methods %
% %
% Software Design %
% Cristy %
% October 1996 %
% %
% %
% %
% Copyright 1999-2020 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
% obtain a copy of the License at %
% %
% https://imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
% See the License for the specific language governing permissions and %
% limitations under the License. %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
%
*/
/*
Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/accelerate-private.h"
#include "MagickCore/annotate.h"
#include "MagickCore/artifact.h"
#include "MagickCore/attribute.h"
#include "MagickCore/cache.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/channel.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
#include "MagickCore/decorate.h"
#include "MagickCore/distort.h"
#include "MagickCore/draw.h"
#include "MagickCore/effect.h"
#include "MagickCore/enhance.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
#include "MagickCore/gem.h"
#include "MagickCore/gem-private.h"
#include "MagickCore/geometry.h"
#include "MagickCore/layer.h"
#include "MagickCore/list.h"
#include "MagickCore/log.h"
#include "MagickCore/image.h"
#include "MagickCore/image-private.h"
#include "MagickCore/magick.h"
#include "MagickCore/memory_.h"
#include "MagickCore/memory-private.h"
#include "MagickCore/monitor.h"
#include "MagickCore/monitor-private.h"
#include "MagickCore/option.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
#include "MagickCore/property.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/random_.h"
#include "MagickCore/random-private.h"
#include "MagickCore/resample.h"
#include "MagickCore/resample-private.h"
#include "MagickCore/resize.h"
#include "MagickCore/resource_.h"
#include "MagickCore/splay-tree.h"
#include "MagickCore/statistic.h"
#include "MagickCore/string_.h"
#include "MagickCore/string-private.h"
#include "MagickCore/thread-private.h"
#include "MagickCore/threshold.h"
#include "MagickCore/transform.h"
#include "MagickCore/transform-private.h"
#include "MagickCore/utility.h"
#include "MagickCore/visual-effects.h"
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A d d N o i s e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% AddNoiseImage() adds random noise to the image.
%
% The format of the AddNoiseImage method is:
%
% Image *AddNoiseImage(const Image *image,const NoiseType noise_type,
% const double attenuate,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o channel: the channel type.
%
% o noise_type: The type of noise: Uniform, Gaussian, Multiplicative,
% Impulse, Laplacian, or Poisson.
%
% o attenuate: attenuate the random distribution.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *AddNoiseImage(const Image *image,const NoiseType noise_type,
const double attenuate,ExceptionInfo *exception)
{
#define AddNoiseImageTag "AddNoise/Image"
CacheView
*image_view,
*noise_view;
Image
*noise_image;
MagickBooleanType
status;
MagickOffsetType
progress;
RandomInfo
**magick_restrict random_info;
ssize_t
y;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
unsigned long
key;
#endif
/*
Initialize noise image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
#if defined(MAGICKCORE_OPENCL_SUPPORT)
noise_image=AccelerateAddNoiseImage(image,noise_type,attenuate,exception);
if (noise_image != (Image *) NULL)
return(noise_image);
#endif
noise_image=CloneImage(image,0,0,MagickTrue,exception);
if (noise_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(noise_image,DirectClass,exception) == MagickFalse)
{
noise_image=DestroyImage(noise_image);
return((Image *) NULL);
}
/*
Add noise in each row.
*/
status=MagickTrue;
progress=0;
random_info=AcquireRandomInfoThreadSet();
image_view=AcquireVirtualCacheView(image,exception);
noise_view=AcquireAuthenticCacheView(noise_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
key=GetRandomSecretKey(random_info[0]);
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,noise_image,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
const int
id = GetOpenMPThreadId();
MagickBooleanType
sync;
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
register ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
PixelTrait noise_traits=GetPixelChannelTraits(noise_image,channel);
if ((traits == UndefinedPixelTrait) ||
(noise_traits == UndefinedPixelTrait))
continue;
if ((noise_traits & CopyPixelTrait) != 0)
{
SetPixelChannel(noise_image,channel,p[i],q);
continue;
}
SetPixelChannel(noise_image,channel,ClampToQuantum(
GenerateDifferentialNoise(random_info[id],p[i],noise_type,attenuate)),
q);
}
p+=GetPixelChannels(image);
q+=GetPixelChannels(noise_image);
}
sync=SyncCacheViewAuthenticPixels(noise_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,AddNoiseImageTag,progress,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
noise_view=DestroyCacheView(noise_view);
image_view=DestroyCacheView(image_view);
random_info=DestroyRandomInfoThreadSet(random_info);
if (status == MagickFalse)
noise_image=DestroyImage(noise_image);
return(noise_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% B l u e S h i f t I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% BlueShiftImage() mutes the colors of the image to simulate a scene at
% nighttime in the moonlight.
%
% The format of the BlueShiftImage method is:
%
% Image *BlueShiftImage(const Image *image,const double factor,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o factor: the shift factor.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *BlueShiftImage(const Image *image,const double factor,
ExceptionInfo *exception)
{
#define BlueShiftImageTag "BlueShift/Image"
CacheView
*image_view,
*shift_view;
Image
*shift_image;
MagickBooleanType
status;
MagickOffsetType
progress;
ssize_t
y;
/*
Allocate blue shift image.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
shift_image=CloneImage(image,0,0,MagickTrue,exception);
if (shift_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(shift_image,DirectClass,exception) == MagickFalse)
{
shift_image=DestroyImage(shift_image);
return((Image *) NULL);
}
/*
Blue-shift DirectClass image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireVirtualCacheView(image,exception);
shift_view=AcquireAuthenticCacheView(shift_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,shift_image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
sync;
PixelInfo
pixel;
Quantum
quantum;
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(shift_view,0,y,shift_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
quantum=GetPixelRed(image,p);
if (GetPixelGreen(image,p) < quantum)
quantum=GetPixelGreen(image,p);
if (GetPixelBlue(image,p) < quantum)
quantum=GetPixelBlue(image,p);
pixel.red=0.5*(GetPixelRed(image,p)+factor*quantum);
pixel.green=0.5*(GetPixelGreen(image,p)+factor*quantum);
pixel.blue=0.5*(GetPixelBlue(image,p)+factor*quantum);
quantum=GetPixelRed(image,p);
if (GetPixelGreen(image,p) > quantum)
quantum=GetPixelGreen(image,p);
if (GetPixelBlue(image,p) > quantum)
quantum=GetPixelBlue(image,p);
pixel.red=0.5*(pixel.red+factor*quantum);
pixel.green=0.5*(pixel.green+factor*quantum);
pixel.blue=0.5*(pixel.blue+factor*quantum);
SetPixelRed(shift_image,ClampToQuantum(pixel.red),q);
SetPixelGreen(shift_image,ClampToQuantum(pixel.green),q);
SetPixelBlue(shift_image,ClampToQuantum(pixel.blue),q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(shift_image);
}
sync=SyncCacheViewAuthenticPixels(shift_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,BlueShiftImageTag,progress,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
image_view=DestroyCacheView(image_view);
shift_view=DestroyCacheView(shift_view);
if (status == MagickFalse)
shift_image=DestroyImage(shift_image);
return(shift_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C h a r c o a l I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CharcoalImage() creates a new image that is a copy of an existing one with
% the edge highlighted. It allocates the memory necessary for the new Image
% structure and returns a pointer to the new image.
%
% The format of the CharcoalImage method is:
%
% Image *CharcoalImage(const Image *image,const double radius,
% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o radius: the radius of the pixel neighborhood.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *CharcoalImage(const Image *image,const double radius,
const double sigma,ExceptionInfo *exception)
{
Image
*charcoal_image,
*edge_image;
MagickBooleanType
status;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
edge_image=EdgeImage(image,radius,exception);
if (edge_image == (Image *) NULL)
return((Image *) NULL);
edge_image->alpha_trait=UndefinedPixelTrait;
charcoal_image=(Image *) NULL;
status=ClampImage(edge_image,exception);
if (status != MagickFalse)
charcoal_image=BlurImage(edge_image,radius,sigma,exception);
edge_image=DestroyImage(edge_image);
if (charcoal_image == (Image *) NULL)
return((Image *) NULL);
status=NormalizeImage(charcoal_image,exception);
if (status != MagickFalse)
status=NegateImage(charcoal_image,MagickFalse,exception);
if (status != MagickFalse)
status=GrayscaleImage(charcoal_image,image->intensity,exception);
if (status == MagickFalse)
charcoal_image=DestroyImage(charcoal_image);
return(charcoal_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o l o r i z e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ColorizeImage() blends the fill color with each pixel in the image.
% A percentage blend is specified with opacity. Control the application
% of different color components by specifying a different percentage for
% each component (e.g. 90/100/10 is 90% red, 100% green, and 10% blue).
%
% The format of the ColorizeImage method is:
%
% Image *ColorizeImage(const Image *image,const char *blend,
% const PixelInfo *colorize,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o blend: A character string indicating the level of blending as a
% percentage.
%
% o colorize: A color value.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ColorizeImage(const Image *image,const char *blend,
const PixelInfo *colorize,ExceptionInfo *exception)
{
#define ColorizeImageTag "Colorize/Image"
#define Colorize(pixel,blend_percentage,colorize) \
(((pixel)*(100.0-(blend_percentage))+(colorize)*(blend_percentage))/100.0)
CacheView
*image_view;
GeometryInfo
geometry_info;
Image
*colorize_image;
MagickBooleanType
status;
MagickOffsetType
progress;
MagickStatusType
flags;
PixelInfo
blend_percentage;
ssize_t
y;
/*
Allocate colorized image.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
colorize_image=CloneImage(image,0,0,MagickTrue,exception);
if (colorize_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(colorize_image,DirectClass,exception) == MagickFalse)
{
colorize_image=DestroyImage(colorize_image);
return((Image *) NULL);
}
if ((IsGrayColorspace(colorize_image->colorspace) != MagickFalse) ||
(IsPixelInfoGray(colorize) != MagickFalse))
(void) SetImageColorspace(colorize_image,sRGBColorspace,exception);
if ((colorize_image->alpha_trait == UndefinedPixelTrait) &&
(colorize->alpha_trait != UndefinedPixelTrait))
(void) SetImageAlpha(colorize_image,OpaqueAlpha,exception);
if (blend == (const char *) NULL)
return(colorize_image);
GetPixelInfo(colorize_image,&blend_percentage);
flags=ParseGeometry(blend,&geometry_info);
blend_percentage.red=geometry_info.rho;
blend_percentage.green=geometry_info.rho;
blend_percentage.blue=geometry_info.rho;
blend_percentage.black=geometry_info.rho;
blend_percentage.alpha=(MagickRealType) TransparentAlpha;
if ((flags & SigmaValue) != 0)
blend_percentage.green=geometry_info.sigma;
if ((flags & XiValue) != 0)
blend_percentage.blue=geometry_info.xi;
if ((flags & PsiValue) != 0)
blend_percentage.alpha=geometry_info.psi;
if (blend_percentage.colorspace == CMYKColorspace)
{
if ((flags & PsiValue) != 0)
blend_percentage.black=geometry_info.psi;
if ((flags & ChiValue) != 0)
blend_percentage.alpha=geometry_info.chi;
}
/*
Colorize DirectClass image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireVirtualCacheView(colorize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(colorize_image,colorize_image,colorize_image->rows,1)
#endif
for (y=0; y < (ssize_t) colorize_image->rows; y++)
{
MagickBooleanType
sync;
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,colorize_image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) colorize_image->columns; x++)
{
register ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(colorize_image); i++)
{
PixelTrait traits = GetPixelChannelTraits(colorize_image,
(PixelChannel) i);
if (traits == UndefinedPixelTrait)
continue;
if ((traits & CopyPixelTrait) != 0)
continue;
SetPixelChannel(colorize_image,(PixelChannel) i,ClampToQuantum(
Colorize(q[i],GetPixelInfoChannel(&blend_percentage,(PixelChannel) i),
GetPixelInfoChannel(colorize,(PixelChannel) i))),q);
}
q+=GetPixelChannels(colorize_image);
}
sync=SyncCacheViewAuthenticPixels(image_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,ColorizeImageTag,progress,
colorize_image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
colorize_image=DestroyImage(colorize_image);
return(colorize_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o l o r M a t r i x I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ColorMatrixImage() applies color transformation to an image. This method
% permits saturation changes, hue rotation, luminance to alpha, and various
% other effects. Although variable-sized transformation matrices can be used,
% typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA
% (or RGBA with offsets). The matrix is similar to those used by Adobe Flash
% except offsets are in column 6 rather than 5 (in support of CMYKA images)
% and offsets are normalized (divide Flash offset by 255).
%
% The format of the ColorMatrixImage method is:
%
% Image *ColorMatrixImage(const Image *image,
% const KernelInfo *color_matrix,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o color_matrix: the color matrix.
%
% o exception: return any errors or warnings in this structure.
%
*/
/* FUTURE: modify to make use of a MagickMatrix Mutliply function
That should be provided in "matrix.c"
(ASIDE: actually distorts should do this too but currently doesn't)
*/
MagickExport Image *ColorMatrixImage(const Image *image,
const KernelInfo *color_matrix,ExceptionInfo *exception)
{
#define ColorMatrixImageTag "ColorMatrix/Image"
CacheView
*color_view,
*image_view;
double
ColorMatrix[6][6] =
{
{ 1.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 1.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 }
};
Image
*color_image;
MagickBooleanType
status;
MagickOffsetType
progress;
register ssize_t
i;
ssize_t
u,
v,
y;
/*
Map given color_matrix, into a 6x6 matrix RGBKA and a constant
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
i=0;
for (v=0; v < (ssize_t) color_matrix->height; v++)
for (u=0; u < (ssize_t) color_matrix->width; u++)
{
if ((v < 6) && (u < 6))
ColorMatrix[v][u]=color_matrix->values[i];
i++;
}
/*
Initialize color image.
*/
color_image=CloneImage(image,0,0,MagickTrue,exception);
if (color_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(color_image,DirectClass,exception) == MagickFalse)
{
color_image=DestroyImage(color_image);
return((Image *) NULL);
}
if (image->debug != MagickFalse)
{
char
format[MagickPathExtent],
*message;
(void) LogMagickEvent(TransformEvent,GetMagickModule(),
" ColorMatrix image with color matrix:");
message=AcquireString("");
for (v=0; v < 6; v++)
{
*message='\0';
(void) FormatLocaleString(format,MagickPathExtent,"%.20g: ",(double) v);
(void) ConcatenateString(&message,format);
for (u=0; u < 6; u++)
{
(void) FormatLocaleString(format,MagickPathExtent,"%+f ",
ColorMatrix[v][u]);
(void) ConcatenateString(&message,format);
}
(void) LogMagickEvent(TransformEvent,GetMagickModule(),"%s",message);
}
message=DestroyString(message);
}
/*
Apply the ColorMatrix to image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireVirtualCacheView(image,exception);
color_view=AcquireAuthenticCacheView(color_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,color_image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
PixelInfo
pixel;
register const Quantum
*magick_restrict p;
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
q=GetCacheViewAuthenticPixels(color_view,0,y,color_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
GetPixelInfo(image,&pixel);
for (x=0; x < (ssize_t) image->columns; x++)
{
register ssize_t
v;
size_t
height;
GetPixelInfoPixel(image,p,&pixel);
height=color_matrix->height > 6 ? 6UL : color_matrix->height;
for (v=0; v < (ssize_t) height; v++)
{
double
sum;
sum=ColorMatrix[v][0]*GetPixelRed(image,p)+ColorMatrix[v][1]*
GetPixelGreen(image,p)+ColorMatrix[v][2]*GetPixelBlue(image,p);
if (image->colorspace == CMYKColorspace)
sum+=ColorMatrix[v][3]*GetPixelBlack(image,p);
if (image->alpha_trait != UndefinedPixelTrait)
sum+=ColorMatrix[v][4]*GetPixelAlpha(image,p);
sum+=QuantumRange*ColorMatrix[v][5];
switch (v)
{
case 0: pixel.red=sum; break;
case 1: pixel.green=sum; break;
case 2: pixel.blue=sum; break;
case 3: pixel.black=sum; break;
case 4: pixel.alpha=sum; break;
default: break;
}
}
SetPixelViaPixelInfo(color_image,&pixel,q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(color_image);
}
if (SyncCacheViewAuthenticPixels(color_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,ColorMatrixImageTag,progress,
image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
color_view=DestroyCacheView(color_view);
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
color_image=DestroyImage(color_image);
return(color_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% I m p l o d e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ImplodeImage() creates a new image that is a copy of an existing
% one with the image pixels "implode" by the specified percentage. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ImplodeImage method is:
%
% Image *ImplodeImage(const Image *image,const double amount,
% const PixelInterpolateMethod method,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o implode_image: Method ImplodeImage returns a pointer to the image
% after it is implode. A null image is returned if there is a memory
% shortage.
%
% o image: the image.
%
% o amount: Define the extent of the implosion.
%
% o method: the pixel interpolation method.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ImplodeImage(const Image *image,const double amount,
const PixelInterpolateMethod method,ExceptionInfo *exception)
{
#define ImplodeImageTag "Implode/Image"
CacheView
*canvas_view,
*implode_view,
*interpolate_view;
double
radius;
Image
*canvas_image,
*implode_image;
MagickBooleanType
status;
MagickOffsetType
progress;
PointInfo
center,
scale;
ssize_t
y;
/*
Initialize implode image attributes.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
canvas_image=CloneImage(image,0,0,MagickTrue,exception);
if (canvas_image == (Image *) NULL)
return((Image *) NULL);
if ((canvas_image->alpha_trait == UndefinedPixelTrait) &&
(canvas_image->background_color.alpha != OpaqueAlpha))
(void) SetImageAlphaChannel(canvas_image,OpaqueAlphaChannel,exception);
implode_image=CloneImage(canvas_image,0,0,MagickTrue,exception);
if (implode_image == (Image *) NULL)
{
canvas_image=DestroyImage(canvas_image);
return((Image *) NULL);
}
if (SetImageStorageClass(implode_image,DirectClass,exception) == MagickFalse)
{
canvas_image=DestroyImage(canvas_image);
implode_image=DestroyImage(implode_image);
return((Image *) NULL);
}
/*
Compute scaling factor.
*/
scale.x=1.0;
scale.y=1.0;
center.x=0.5*canvas_image->columns;
center.y=0.5*canvas_image->rows;
radius=center.x;
if (canvas_image->columns > canvas_image->rows)
scale.y=(double) canvas_image->columns/(double) canvas_image->rows;
else
if (canvas_image->columns < canvas_image->rows)
{
scale.x=(double) canvas_image->rows/(double) canvas_image->columns;
radius=center.y;
}
/*
Implode image.
*/
status=MagickTrue;
progress=0;
canvas_view=AcquireVirtualCacheView(canvas_image,exception);
interpolate_view=AcquireVirtualCacheView(canvas_image,exception);
implode_view=AcquireAuthenticCacheView(implode_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(canvas_image,implode_image,canvas_image->rows,1)
#endif
for (y=0; y < (ssize_t) canvas_image->rows; y++)
{
double
distance;
PointInfo
delta;
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(canvas_view,0,y,canvas_image->columns,1,
exception);
q=QueueCacheViewAuthenticPixels(implode_view,0,y,implode_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
delta.y=scale.y*(double) (y-center.y);
for (x=0; x < (ssize_t) canvas_image->columns; x++)
{
register ssize_t
i;
/*
Determine if the pixel is within an ellipse.
*/
delta.x=scale.x*(double) (x-center.x);
distance=delta.x*delta.x+delta.y*delta.y;
if (distance >= (radius*radius))
for (i=0; i < (ssize_t) GetPixelChannels(canvas_image); i++)
{
PixelChannel channel = GetPixelChannelChannel(canvas_image,i);
PixelTrait traits = GetPixelChannelTraits(canvas_image,channel);
PixelTrait implode_traits = GetPixelChannelTraits(implode_image,
channel);
if ((traits == UndefinedPixelTrait) ||
(implode_traits == UndefinedPixelTrait))
continue;
SetPixelChannel(implode_image,channel,p[i],q);
}
else
{
double
factor;
/*
Implode the pixel.
*/
factor=1.0;
if (distance > 0.0)
factor=pow(sin(MagickPI*sqrt((double) distance)/radius/2),-amount);
status=InterpolatePixelChannels(canvas_image,interpolate_view,
implode_image,method,(double) (factor*delta.x/scale.x+center.x),
(double) (factor*delta.y/scale.y+center.y),q,exception);
if (status == MagickFalse)
break;
}
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(implode_image);
}
if (SyncCacheViewAuthenticPixels(implode_view,exception) == MagickFalse)
status=MagickFalse;
if (canvas_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(canvas_image,ImplodeImageTag,progress,
canvas_image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
implode_view=DestroyCacheView(implode_view);
interpolate_view=DestroyCacheView(interpolate_view);
canvas_view=DestroyCacheView(canvas_view);
canvas_image=DestroyImage(canvas_image);
if (status == MagickFalse)
implode_image=DestroyImage(implode_image);
return(implode_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% M o r p h I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The MorphImages() method requires a minimum of two images. The first
% image is transformed into the second by a number of intervening images
% as specified by frames.
%
% The format of the MorphImage method is:
%
% Image *MorphImages(const Image *image,const size_t number_frames,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o number_frames: Define the number of in-between image to generate.
% The more in-between frames, the smoother the morph.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *MorphImages(const Image *image,const size_t number_frames,
ExceptionInfo *exception)
{
#define MorphImageTag "Morph/Image"
double
alpha,
beta;
Image
*morph_image,
*morph_images;
MagickBooleanType
status;
MagickOffsetType
scene;
register const Image
*next;
register ssize_t
n;
ssize_t
y;
/*
Clone first frame in sequence.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
morph_images=CloneImage(image,0,0,MagickTrue,exception);
if (morph_images == (Image *) NULL)
return((Image *) NULL);
if (GetNextImageInList(image) == (Image *) NULL)
{
/*
Morph single image.
*/
for (n=1; n < (ssize_t) number_frames; n++)
{
morph_image=CloneImage(image,0,0,MagickTrue,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
AppendImageToList(&morph_images,morph_image);
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,MorphImageTag,(MagickOffsetType) n,
number_frames);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
return(GetFirstImageInList(morph_images));
}
/*
Morph image sequence.
*/
status=MagickTrue;
scene=0;
next=image;
for ( ; GetNextImageInList(next) != (Image *) NULL; next=GetNextImageInList(next))
{
for (n=0; n < (ssize_t) number_frames; n++)
{
CacheView
*image_view,
*morph_view;
beta=(double) (n+1.0)/(double) (number_frames+1.0);
alpha=1.0-beta;
morph_image=ResizeImage(next,(size_t) (alpha*next->columns+beta*
GetNextImageInList(next)->columns+0.5),(size_t) (alpha*next->rows+beta*
GetNextImageInList(next)->rows+0.5),next->filter,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
status=SetImageStorageClass(morph_image,DirectClass,exception);
if (status == MagickFalse)
{
morph_image=DestroyImage(morph_image);
return((Image *) NULL);
}
AppendImageToList(&morph_images,morph_image);
morph_images=GetLastImageInList(morph_images);
morph_image=ResizeImage(GetNextImageInList(next),morph_images->columns,
morph_images->rows,GetNextImageInList(next)->filter,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
image_view=AcquireVirtualCacheView(morph_image,exception);
morph_view=AcquireAuthenticCacheView(morph_images,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
magick_number_threads(morph_image,morph_image,morph_image->rows,1)
#endif
for (y=0; y < (ssize_t) morph_images->rows; y++)
{
MagickBooleanType
sync;
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,morph_image->columns,1,
exception);
q=GetCacheViewAuthenticPixels(morph_view,0,y,morph_images->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) morph_images->columns; x++)
{
register ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(morph_image); i++)
{
PixelChannel channel = GetPixelChannelChannel(morph_image,i);
PixelTrait traits = GetPixelChannelTraits(morph_image,channel);
PixelTrait morph_traits=GetPixelChannelTraits(morph_images,channel);
if ((traits == UndefinedPixelTrait) ||
(morph_traits == UndefinedPixelTrait))
continue;
if ((morph_traits & CopyPixelTrait) != 0)
{
SetPixelChannel(morph_image,channel,p[i],q);
continue;
}
SetPixelChannel(morph_image,channel,ClampToQuantum(alpha*
GetPixelChannel(morph_images,channel,q)+beta*p[i]),q);
}
p+=GetPixelChannels(morph_image);
q+=GetPixelChannels(morph_images);
}
sync=SyncCacheViewAuthenticPixels(morph_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
}
morph_view=DestroyCacheView(morph_view);
image_view=DestroyCacheView(image_view);
morph_image=DestroyImage(morph_image);
}
if (n < (ssize_t) number_frames)
break;
/*
Clone last frame in sequence.
*/
morph_image=CloneImage(GetNextImageInList(next),0,0,MagickTrue,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
AppendImageToList(&morph_images,morph_image);
morph_images=GetLastImageInList(morph_images);
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,MorphImageTag,scene,
GetImageListLength(image));
if (proceed == MagickFalse)
status=MagickFalse;
}
scene++;
}
if (GetNextImageInList(next) != (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
return(GetFirstImageInList(morph_images));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P l a s m a I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PlasmaImage() initializes an image with plasma fractal values. The image
% must be initialized with a base color and the random number generator
% seeded before this method is called.
%
% The format of the PlasmaImage method is:
%
% MagickBooleanType PlasmaImage(Image *image,const SegmentInfo *segment,
% size_t attenuate,size_t depth,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o segment: Define the region to apply plasma fractals values.
%
% o attenuate: Define the plasma attenuation factor.
%
% o depth: Limit the plasma recursion depth.
%
% o exception: return any errors or warnings in this structure.
%
*/
static inline Quantum PlasmaPixel(RandomInfo *magick_restrict random_info,
const double pixel,const double noise)
{
MagickRealType
plasma;
plasma=pixel+noise*GetPseudoRandomValue(random_info)-noise/2.0;
return(ClampToQuantum(plasma));
}
static MagickBooleanType PlasmaImageProxy(Image *image,CacheView *image_view,
CacheView *u_view,CacheView *v_view,RandomInfo *magick_restrict random_info,
const SegmentInfo *magick_restrict segment,size_t attenuate,size_t depth,
ExceptionInfo *exception)
{
double
plasma;
MagickStatusType
status;
register const Quantum
*magick_restrict u,
*magick_restrict v;
register Quantum
*magick_restrict q;
register ssize_t
i;
ssize_t
x,
x_mid,
y,
y_mid;
if ((fabs(segment->x2-segment->x1) < MagickEpsilon) &&
(fabs(segment->y2-segment->y1) < MagickEpsilon))
return(MagickTrue);
if (depth != 0)
{
SegmentInfo
local_info;
/*
Divide the area into quadrants and recurse.
*/
depth--;
attenuate++;
x_mid=(ssize_t) ceil((segment->x1+segment->x2)/2-0.5);
y_mid=(ssize_t) ceil((segment->y1+segment->y2)/2-0.5);
local_info=(*segment);
local_info.x2=(double) x_mid;
local_info.y2=(double) y_mid;
status=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
&local_info,attenuate,depth,exception);
local_info=(*segment);
local_info.y1=(double) y_mid;
local_info.x2=(double) x_mid;
status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
&local_info,attenuate,depth,exception);
local_info=(*segment);
local_info.x1=(double) x_mid;
local_info.y2=(double) y_mid;
status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
&local_info,attenuate,depth,exception);
local_info=(*segment);
local_info.x1=(double) x_mid;
local_info.y1=(double) y_mid;
status&=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,
&local_info,attenuate,depth,exception);
return(status == 0 ? MagickFalse : MagickTrue);
}
x_mid=(ssize_t) ceil((segment->x1+segment->x2)/2-0.5);
y_mid=(ssize_t) ceil((segment->y1+segment->y2)/2-0.5);
if ((fabs(segment->x1-x_mid) < MagickEpsilon) &&
(fabs(segment->x2-x_mid) < MagickEpsilon) &&
(fabs(segment->y1-y_mid) < MagickEpsilon) &&
(fabs(segment->y2-y_mid) < MagickEpsilon))
return(MagickFalse);
/*
Average pixels and apply plasma.
*/
status=MagickTrue;
plasma=(double) QuantumRange/(2.0*attenuate);
if ((fabs(segment->x1-x_mid) >= MagickEpsilon) ||
(fabs(segment->x2-x_mid) >= MagickEpsilon))
{
/*
Left pixel.
*/
x=(ssize_t) ceil(segment->x1-0.5);
u=GetCacheViewVirtualPixels(u_view,x,(ssize_t) ceil(segment->y1-0.5),1,1,
exception);
v=GetCacheViewVirtualPixels(v_view,x,(ssize_t) ceil(segment->y2-0.5),1,1,
exception);
q=QueueCacheViewAuthenticPixels(image_view,x,y_mid,1,1,exception);
if ((u == (const Quantum *) NULL) || (v == (const Quantum *) NULL) ||
(q == (Quantum *) NULL))
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,((double) u[i]+v[i])/2.0,plasma);
}
status=SyncCacheViewAuthenticPixels(image_view,exception);
if (fabs(segment->x1-segment->x2) >= MagickEpsilon)
{
/*
Right pixel.
*/
x=(ssize_t) ceil(segment->x2-0.5);
u=GetCacheViewVirtualPixels(u_view,x,(ssize_t) ceil(segment->y1-0.5),
1,1,exception);
v=GetCacheViewVirtualPixels(v_view,x,(ssize_t) ceil(segment->y2-0.5),
1,1,exception);
q=QueueCacheViewAuthenticPixels(image_view,x,y_mid,1,1,exception);
if ((u == (const Quantum *) NULL) || (v == (const Quantum *) NULL) ||
(q == (Quantum *) NULL))
return(MagickFalse);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,((double) u[i]+v[i])/2.0,plasma);
}
status=SyncCacheViewAuthenticPixels(image_view,exception);
}
}
if ((fabs(segment->y1-y_mid) >= MagickEpsilon) ||
(fabs(segment->y2-y_mid) >= MagickEpsilon))
{
if ((fabs(segment->x1-x_mid) >= MagickEpsilon) ||
(fabs(segment->y2-y_mid) >= MagickEpsilon))
{
/*
Bottom pixel.
*/
y=(ssize_t) ceil(segment->y2-0.5);
u=GetCacheViewVirtualPixels(u_view,(ssize_t) ceil(segment->x1-0.5),y,
1,1,exception);
v=GetCacheViewVirtualPixels(v_view,(ssize_t) ceil(segment->x2-0.5),y,
1,1,exception);
q=QueueCacheViewAuthenticPixels(image_view,x_mid,y,1,1,exception);
if ((u == (const Quantum *) NULL) || (v == (const Quantum *) NULL) ||
(q == (Quantum *) NULL))
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,((double) u[i]+v[i])/2.0,plasma);
}
status=SyncCacheViewAuthenticPixels(image_view,exception);
}
if (fabs(segment->y1-segment->y2) >= MagickEpsilon)
{
/*
Top pixel.
*/
y=(ssize_t) ceil(segment->y1-0.5);
u=GetCacheViewVirtualPixels(u_view,(ssize_t) ceil(segment->x1-0.5),y,
1,1,exception);
v=GetCacheViewVirtualPixels(v_view,(ssize_t) ceil(segment->x2-0.5),y,
1,1,exception);
q=QueueCacheViewAuthenticPixels(image_view,x_mid,y,1,1,exception);
if ((u == (const Quantum *) NULL) || (v == (const Quantum *) NULL) ||
(q == (Quantum *) NULL))
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,((double) u[i]+v[i])/2.0,plasma);
}
status=SyncCacheViewAuthenticPixels(image_view,exception);
}
}
if ((fabs(segment->x1-segment->x2) >= MagickEpsilon) ||
(fabs(segment->y1-segment->y2) >= MagickEpsilon))
{
/*
Middle pixel.
*/
x=(ssize_t) ceil(segment->x1-0.5);
y=(ssize_t) ceil(segment->y1-0.5);
u=GetCacheViewVirtualPixels(u_view,x,y,1,1,exception);
x=(ssize_t) ceil(segment->x2-0.5);
y=(ssize_t) ceil(segment->y2-0.5);
v=GetCacheViewVirtualPixels(v_view,x,y,1,1,exception);
q=QueueCacheViewAuthenticPixels(image_view,x_mid,y_mid,1,1,exception);
if ((u == (const Quantum *) NULL) || (v == (const Quantum *) NULL) ||
(q == (Quantum *) NULL))
return(MagickTrue);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=PlasmaPixel(random_info,((double) u[i]+v[i])/2.0,plasma);
}
status=SyncCacheViewAuthenticPixels(image_view,exception);
}
if ((fabs(segment->x2-segment->x1) < 3.0) &&
(fabs(segment->y2-segment->y1) < 3.0))
return(status == 0 ? MagickFalse : MagickTrue);
return(MagickFalse);
}
MagickExport MagickBooleanType PlasmaImage(Image *image,
const SegmentInfo *segment,size_t attenuate,size_t depth,
ExceptionInfo *exception)
{
CacheView
*image_view,
*u_view,
*v_view;
MagickBooleanType
status;
RandomInfo
*random_info;
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
image_view=AcquireAuthenticCacheView(image,exception);
u_view=AcquireVirtualCacheView(image,exception);
v_view=AcquireVirtualCacheView(image,exception);
random_info=AcquireRandomInfo();
status=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,segment,
attenuate,depth,exception);
random_info=DestroyRandomInfo(random_info);
v_view=DestroyCacheView(v_view);
u_view=DestroyCacheView(u_view);
image_view=DestroyCacheView(image_view);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P o l a r o i d I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PolaroidImage() simulates a Polaroid picture.
%
% The format of the PolaroidImage method is:
%
% Image *PolaroidImage(const Image *image,const DrawInfo *draw_info,
% const char *caption,const double angle,
% const PixelInterpolateMethod method,ExceptionInfo exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o draw_info: the draw info.
%
% o caption: the Polaroid caption.
%
% o angle: Apply the effect along this angle.
%
% o method: the pixel interpolation method.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *PolaroidImage(const Image *image,const DrawInfo *draw_info,
const char *caption,const double angle,const PixelInterpolateMethod method,
ExceptionInfo *exception)
{
Image
*bend_image,
*caption_image,
*flop_image,
*picture_image,
*polaroid_image,
*rotate_image,
*trim_image;
size_t
height;
ssize_t
quantum;
/*
Simulate a Polaroid picture.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
quantum=(ssize_t) MagickMax(MagickMax((double) image->columns,(double)
image->rows)/25.0,10.0);
height=image->rows+2*quantum;
caption_image=(Image *) NULL;
if (caption != (const char *) NULL)
{
char
*text;
/*
Generate caption image.
*/
caption_image=CloneImage(image,image->columns,1,MagickTrue,exception);
if (caption_image == (Image *) NULL)
return((Image *) NULL);
text=InterpretImageProperties((ImageInfo *) NULL,(Image *) image,caption,
exception);
if (text != (char *) NULL)
{
char
geometry[MagickPathExtent];
DrawInfo
*annotate_info;
MagickBooleanType
status;
ssize_t
count;
TypeMetric
metrics;
annotate_info=CloneDrawInfo((const ImageInfo *) NULL,draw_info);
(void) CloneString(&annotate_info->text,text);
count=FormatMagickCaption(caption_image,annotate_info,MagickTrue,
&metrics,&text,exception);
status=SetImageExtent(caption_image,image->columns,(size_t)
((count+1)*(metrics.ascent-metrics.descent)+0.5),exception);
if (status == MagickFalse)
caption_image=DestroyImage(caption_image);
else
{
caption_image->background_color=image->border_color;
(void) SetImageBackgroundColor(caption_image,exception);
(void) CloneString(&annotate_info->text,text);
(void) FormatLocaleString(geometry,MagickPathExtent,"+0+%.20g",
metrics.ascent);
if (annotate_info->gravity == UndefinedGravity)
(void) CloneString(&annotate_info->geometry,AcquireString(
geometry));
(void) AnnotateImage(caption_image,annotate_info,exception);
height+=caption_image->rows;
}
annotate_info=DestroyDrawInfo(annotate_info);
text=DestroyString(text);
}
}
picture_image=CloneImage(image,image->columns+2*quantum,height,MagickTrue,
exception);
if (picture_image == (Image *) NULL)
{
if (caption_image != (Image *) NULL)
caption_image=DestroyImage(caption_image);
return((Image *) NULL);
}
picture_image->background_color=image->border_color;
(void) SetImageBackgroundColor(picture_image,exception);
(void) CompositeImage(picture_image,image,OverCompositeOp,MagickTrue,quantum,
quantum,exception);
if (caption_image != (Image *) NULL)
{
(void) CompositeImage(picture_image,caption_image,OverCompositeOp,
MagickTrue,quantum,(ssize_t) (image->rows+3*quantum/2),exception);
caption_image=DestroyImage(caption_image);
}
(void) QueryColorCompliance("none",AllCompliance,
&picture_image->background_color,exception);
(void) SetImageAlphaChannel(picture_image,OpaqueAlphaChannel,exception);
rotate_image=RotateImage(picture_image,90.0,exception);
picture_image=DestroyImage(picture_image);
if (rotate_image == (Image *) NULL)
return((Image *) NULL);
picture_image=rotate_image;
bend_image=WaveImage(picture_image,0.01*picture_image->rows,2.0*
picture_image->columns,method,exception);
picture_image=DestroyImage(picture_image);
if (bend_image == (Image *) NULL)
return((Image *) NULL);
picture_image=bend_image;
rotate_image=RotateImage(picture_image,-90.0,exception);
picture_image=DestroyImage(picture_image);
if (rotate_image == (Image *) NULL)
return((Image *) NULL);
picture_image=rotate_image;
picture_image->background_color=image->background_color;
polaroid_image=ShadowImage(picture_image,80.0,2.0,quantum/3,quantum/3,
exception);
if (polaroid_image == (Image *) NULL)
{
picture_image=DestroyImage(picture_image);
return(picture_image);
}
flop_image=FlopImage(polaroid_image,exception);
polaroid_image=DestroyImage(polaroid_image);
if (flop_image == (Image *) NULL)
{
picture_image=DestroyImage(picture_image);
return(picture_image);
}
polaroid_image=flop_image;
(void) CompositeImage(polaroid_image,picture_image,OverCompositeOp,
MagickTrue,(ssize_t) (-0.01*picture_image->columns/2.0),0L,exception);
picture_image=DestroyImage(picture_image);
(void) QueryColorCompliance("none",AllCompliance,
&polaroid_image->background_color,exception);
rotate_image=RotateImage(polaroid_image,angle,exception);
polaroid_image=DestroyImage(polaroid_image);
if (rotate_image == (Image *) NULL)
return((Image *) NULL);
polaroid_image=rotate_image;
trim_image=TrimImage(polaroid_image,exception);
polaroid_image=DestroyImage(polaroid_image);
if (trim_image == (Image *) NULL)
return((Image *) NULL);
polaroid_image=trim_image;
return(polaroid_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e p i a T o n e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickSepiaToneImage() applies a special effect to the image, similar to the
% effect achieved in a photo darkroom by sepia toning. Threshold ranges from
% 0 to QuantumRange and is a measure of the extent of the sepia toning. A
% threshold of 80% is a good starting point for a reasonable tone.
%
% The format of the SepiaToneImage method is:
%
% Image *SepiaToneImage(const Image *image,const double threshold,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o threshold: the tone threshold.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SepiaToneImage(const Image *image,const double threshold,
ExceptionInfo *exception)
{
#define SepiaToneImageTag "SepiaTone/Image"
CacheView
*image_view,
*sepia_view;
Image
*sepia_image;
MagickBooleanType
status;
MagickOffsetType
progress;
ssize_t
y;
/*
Initialize sepia-toned image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
sepia_image=CloneImage(image,0,0,MagickTrue,exception);
if (sepia_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(sepia_image,DirectClass,exception) == MagickFalse)
{
sepia_image=DestroyImage(sepia_image);
return((Image *) NULL);
}
/*
Tone each row of the image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireVirtualCacheView(image,exception);
sepia_view=AcquireAuthenticCacheView(sepia_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,sepia_image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
q=GetCacheViewAuthenticPixels(sepia_view,0,y,sepia_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
double
intensity,
tone;
intensity=GetPixelIntensity(image,p);
tone=intensity > threshold ? (double) QuantumRange : intensity+
(double) QuantumRange-threshold;
SetPixelRed(sepia_image,ClampToQuantum(tone),q);
tone=intensity > (7.0*threshold/6.0) ? (double) QuantumRange :
intensity+(double) QuantumRange-7.0*threshold/6.0;
SetPixelGreen(sepia_image,ClampToQuantum(tone),q);
tone=intensity < (threshold/6.0) ? 0 : intensity-threshold/6.0;
SetPixelBlue(sepia_image,ClampToQuantum(tone),q);
tone=threshold/7.0;
if ((double) GetPixelGreen(image,q) < tone)
SetPixelGreen(sepia_image,ClampToQuantum(tone),q);
if ((double) GetPixelBlue(image,q) < tone)
SetPixelBlue(sepia_image,ClampToQuantum(tone),q);
SetPixelAlpha(sepia_image,GetPixelAlpha(image,p),q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(sepia_image);
}
if (SyncCacheViewAuthenticPixels(sepia_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,SepiaToneImageTag,progress,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
sepia_view=DestroyCacheView(sepia_view);
image_view=DestroyCacheView(image_view);
(void) NormalizeImage(sepia_image,exception);
(void) ContrastImage(sepia_image,MagickTrue,exception);
if (status == MagickFalse)
sepia_image=DestroyImage(sepia_image);
return(sepia_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S h a d o w I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ShadowImage() simulates a shadow from the specified image and returns it.
%
% The format of the ShadowImage method is:
%
% Image *ShadowImage(const Image *image,const double alpha,
% const double sigma,const ssize_t x_offset,const ssize_t y_offset,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o alpha: percentage transparency.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
% o x_offset: the shadow x-offset.
%
% o y_offset: the shadow y-offset.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ShadowImage(const Image *image,const double alpha,
const double sigma,const ssize_t x_offset,const ssize_t y_offset,
ExceptionInfo *exception)
{
#define ShadowImageTag "Shadow/Image"
CacheView
*image_view;
ChannelType
channel_mask;
Image
*border_image,
*clone_image,
*shadow_image;
MagickBooleanType
status;
PixelInfo
background_color;
RectangleInfo
border_info;
ssize_t
y;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
clone_image=CloneImage(image,0,0,MagickTrue,exception);
if (clone_image == (Image *) NULL)
return((Image *) NULL);
if (IsGrayColorspace(image->colorspace) != MagickFalse)
(void) SetImageColorspace(clone_image,sRGBColorspace,exception);
(void) SetImageVirtualPixelMethod(clone_image,EdgeVirtualPixelMethod,
exception);
border_info.width=(size_t) floor(2.0*sigma+0.5);
border_info.height=(size_t) floor(2.0*sigma+0.5);
border_info.x=0;
border_info.y=0;
(void) QueryColorCompliance("none",AllCompliance,&clone_image->border_color,
exception);
clone_image->alpha_trait=BlendPixelTrait;
border_image=BorderImage(clone_image,&border_info,OverCompositeOp,exception);
clone_image=DestroyImage(clone_image);
if (border_image == (Image *) NULL)
return((Image *) NULL);
if (border_image->alpha_trait == UndefinedPixelTrait)
(void) SetImageAlphaChannel(border_image,OpaqueAlphaChannel,exception);
/*
Shadow image.
*/
status=MagickTrue;
background_color=border_image->background_color;
background_color.alpha_trait=BlendPixelTrait;
image_view=AcquireAuthenticCacheView(border_image,exception);
for (y=0; y < (ssize_t) border_image->rows; y++)
{
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=QueueCacheViewAuthenticPixels(image_view,0,y,border_image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) border_image->columns; x++)
{
if (border_image->alpha_trait != UndefinedPixelTrait)
background_color.alpha=GetPixelAlpha(border_image,q)*alpha/100.0;
SetPixelViaPixelInfo(border_image,&background_color,q);
q+=GetPixelChannels(border_image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
}
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
{
border_image=DestroyImage(border_image);
return((Image *) NULL);
}
channel_mask=SetImageChannelMask(border_image,AlphaChannel);
shadow_image=BlurImage(border_image,0.0,sigma,exception);
border_image=DestroyImage(border_image);
if (shadow_image == (Image *) NULL)
return((Image *) NULL);
(void) SetPixelChannelMask(shadow_image,channel_mask);
if (shadow_image->page.width == 0)
shadow_image->page.width=shadow_image->columns;
if (shadow_image->page.height == 0)
shadow_image->page.height=shadow_image->rows;
shadow_image->page.width+=x_offset-(ssize_t) border_info.width;
shadow_image->page.height+=y_offset-(ssize_t) border_info.height;
shadow_image->page.x+=x_offset-(ssize_t) border_info.width;
shadow_image->page.y+=y_offset-(ssize_t) border_info.height;
return(shadow_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S k e t c h I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SketchImage() simulates a pencil sketch. We convolve the image with a
% Gaussian operator of the given radius and standard deviation (sigma). For
% reasonable results, radius should be larger than sigma. Use a radius of 0
% and SketchImage() selects a suitable radius for you. Angle gives the angle
% of the sketch.
%
% The format of the SketchImage method is:
%
% Image *SketchImage(const Image *image,const double radius,
% const double sigma,const double angle,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o radius: the radius of the Gaussian, in pixels, not counting the
% center pixel.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
% o angle: apply the effect along this angle.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SketchImage(const Image *image,const double radius,
const double sigma,const double angle,ExceptionInfo *exception)
{
CacheView
*random_view;
Image
*blend_image,
*blur_image,
*dodge_image,
*random_image,
*sketch_image;
MagickBooleanType
status;
RandomInfo
**magick_restrict random_info;
ssize_t
y;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
unsigned long
key;
#endif
/*
Sketch image.
*/
random_image=CloneImage(image,image->columns << 1,image->rows << 1,
MagickTrue,exception);
if (random_image == (Image *) NULL)
return((Image *) NULL);
status=MagickTrue;
random_info=AcquireRandomInfoThreadSet();
random_view=AcquireAuthenticCacheView(random_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
key=GetRandomSecretKey(random_info[0]);
#pragma omp parallel for schedule(static) shared(status) \
magick_number_threads(random_image,random_image,random_image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) random_image->rows; y++)
{
const int
id = GetOpenMPThreadId();
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
q=QueueCacheViewAuthenticPixels(random_view,0,y,random_image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) random_image->columns; x++)
{
double
value;
register ssize_t
i;
value=GetPseudoRandomValue(random_info[id]);
for (i=0; i < (ssize_t) GetPixelChannels(random_image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
q[i]=ClampToQuantum(QuantumRange*value);
}
q+=GetPixelChannels(random_image);
}
if (SyncCacheViewAuthenticPixels(random_view,exception) == MagickFalse)
status=MagickFalse;
}
random_view=DestroyCacheView(random_view);
random_info=DestroyRandomInfoThreadSet(random_info);
if (status == MagickFalse)
{
random_image=DestroyImage(random_image);
return(random_image);
}
blur_image=MotionBlurImage(random_image,radius,sigma,angle,exception);
random_image=DestroyImage(random_image);
if (blur_image == (Image *) NULL)
return((Image *) NULL);
dodge_image=EdgeImage(blur_image,radius,exception);
blur_image=DestroyImage(blur_image);
if (dodge_image == (Image *) NULL)
return((Image *) NULL);
status=ClampImage(dodge_image,exception);
if (status != MagickFalse)
status=NormalizeImage(dodge_image,exception);
if (status != MagickFalse)
status=NegateImage(dodge_image,MagickFalse,exception);
if (status != MagickFalse)
status=TransformImage(&dodge_image,(char *) NULL,"50%",exception);
sketch_image=CloneImage(image,0,0,MagickTrue,exception);
if (sketch_image == (Image *) NULL)
{
dodge_image=DestroyImage(dodge_image);
return((Image *) NULL);
}
(void) CompositeImage(sketch_image,dodge_image,ColorDodgeCompositeOp,
MagickTrue,0,0,exception);
dodge_image=DestroyImage(dodge_image);
blend_image=CloneImage(image,0,0,MagickTrue,exception);
if (blend_image == (Image *) NULL)
{
sketch_image=DestroyImage(sketch_image);
return((Image *) NULL);
}
if (blend_image->alpha_trait != BlendPixelTrait)
(void) SetImageAlpha(blend_image,TransparentAlpha,exception);
(void) SetImageArtifact(blend_image,"compose:args","20x80");
(void) CompositeImage(sketch_image,blend_image,BlendCompositeOp,MagickTrue,
0,0,exception);
blend_image=DestroyImage(blend_image);
return(sketch_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S o l a r i z e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SolarizeImage() applies a special effect to the image, similar to the effect
% achieved in a photo darkroom by selectively exposing areas of photo
% sensitive paper to light. Threshold ranges from 0 to QuantumRange and is a
% measure of the extent of the solarization.
%
% The format of the SolarizeImage method is:
%
% MagickBooleanType SolarizeImage(Image *image,const double threshold,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o threshold: Define the extent of the solarization.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport MagickBooleanType SolarizeImage(Image *image,
const double threshold,ExceptionInfo *exception)
{
#define SolarizeImageTag "Solarize/Image"
CacheView
*image_view;
MagickBooleanType
status;
MagickOffsetType
progress;
ssize_t
y;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (IsGrayColorspace(image->colorspace) != MagickFalse)
(void) SetImageColorspace(image,sRGBColorspace,exception);
if (image->storage_class == PseudoClass)
{
register ssize_t
i;
/*
Solarize colormap.
*/
for (i=0; i < (ssize_t) image->colors; i++)
{
if ((double) image->colormap[i].red > threshold)
image->colormap[i].red=QuantumRange-image->colormap[i].red;
if ((double) image->colormap[i].green > threshold)
image->colormap[i].green=QuantumRange-image->colormap[i].green;
if ((double) image->colormap[i].blue > threshold)
image->colormap[i].blue=QuantumRange-image->colormap[i].blue;
}
return(SyncImage(image,exception));
}
/*
Solarize image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
register ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel channel = GetPixelChannelChannel(image,i);
PixelTrait traits = GetPixelChannelTraits(image,channel);
if ((traits & UpdatePixelTrait) == 0)
continue;
if ((double) q[i] > threshold)
q[i]=QuantumRange-q[i];
}
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,SolarizeImageTag,progress,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
image_view=DestroyCacheView(image_view);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t e g a n o I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SteganoImage() hides a digital watermark within the image. Recover
% the hidden watermark later to prove that the authenticity of an image.
% Offset defines the start position within the image to hide the watermark.
%
% The format of the SteganoImage method is:
%
% Image *SteganoImage(const Image *image,Image *watermark,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o watermark: the watermark image.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SteganoImage(const Image *image,const Image *watermark,
ExceptionInfo *exception)
{
#define GetBit(alpha,i) ((((size_t) (alpha) >> (size_t) (i)) & 0x01) != 0)
#define SetBit(alpha,i,set) (Quantum) ((set) != 0 ? (size_t) (alpha) \
| (one << (size_t) (i)) : (size_t) (alpha) & ~(one << (size_t) (i)))
#define SteganoImageTag "Stegano/Image"
CacheView
*stegano_view,
*watermark_view;
Image
*stegano_image;
int
c;
MagickBooleanType
status;
PixelInfo
pixel;
register Quantum
*q;
register ssize_t
x;
size_t
depth,
one;
ssize_t
i,
j,
k,
y;
/*
Initialize steganographic image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(watermark != (const Image *) NULL);
assert(watermark->signature == MagickCoreSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
one=1UL;
stegano_image=CloneImage(image,0,0,MagickTrue,exception);
if (stegano_image == (Image *) NULL)
return((Image *) NULL);
stegano_image->depth=MAGICKCORE_QUANTUM_DEPTH;
if (SetImageStorageClass(stegano_image,DirectClass,exception) == MagickFalse)
{
stegano_image=DestroyImage(stegano_image);
return((Image *) NULL);
}
/*
Hide watermark in low-order bits of image.
*/
c=0;
i=0;
j=0;
depth=stegano_image->depth;
k=stegano_image->offset;
status=MagickTrue;
watermark_view=AcquireVirtualCacheView(watermark,exception);
stegano_view=AcquireAuthenticCacheView(stegano_image,exception);
for (i=(ssize_t) depth-1; (i >= 0) && (j < (ssize_t) depth); i--)
{
for (y=0; (y < (ssize_t) watermark->rows) && (j < (ssize_t) depth); y++)
{
for (x=0; (x < (ssize_t) watermark->columns) && (j < (ssize_t) depth); x++)
{
ssize_t
offset;
(void) GetOneCacheViewVirtualPixelInfo(watermark_view,x,y,&pixel,
exception);
offset=k/(ssize_t) stegano_image->columns;
if (offset >= (ssize_t) stegano_image->rows)
break;
q=GetCacheViewAuthenticPixels(stegano_view,k % (ssize_t)
stegano_image->columns,k/(ssize_t) stegano_image->columns,1,1,
exception);
if (q == (Quantum *) NULL)
break;
switch (c)
{
case 0:
{
SetPixelRed(stegano_image,SetBit(GetPixelRed(stegano_image,q),j,
GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
break;
}
case 1:
{
SetPixelGreen(stegano_image,SetBit(GetPixelGreen(stegano_image,q),j,
GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
break;
}
case 2:
{
SetPixelBlue(stegano_image,SetBit(GetPixelBlue(stegano_image,q),j,
GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
break;
}
}
if (SyncCacheViewAuthenticPixels(stegano_view,exception) == MagickFalse)
break;
c++;
if (c == 3)
c=0;
k++;
if (k == (ssize_t) (stegano_image->columns*stegano_image->columns))
k=0;
if (k == stegano_image->offset)
j++;
}
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,SteganoImageTag,(MagickOffsetType)
(depth-i),depth);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
stegano_view=DestroyCacheView(stegano_view);
watermark_view=DestroyCacheView(watermark_view);
if (status == MagickFalse)
stegano_image=DestroyImage(stegano_image);
return(stegano_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t e r e o A n a g l y p h I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StereoAnaglyphImage() combines two images and produces a single image that
% is the composite of a left and right image of a stereo pair. Special
% red-green stereo glasses are required to view this effect.
%
% The format of the StereoAnaglyphImage method is:
%
% Image *StereoImage(const Image *left_image,const Image *right_image,
% ExceptionInfo *exception)
% Image *StereoAnaglyphImage(const Image *left_image,
% const Image *right_image,const ssize_t x_offset,const ssize_t y_offset,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o left_image: the left image.
%
% o right_image: the right image.
%
% o exception: return any errors or warnings in this structure.
%
% o x_offset: amount, in pixels, by which the left image is offset to the
% right of the right image.
%
% o y_offset: amount, in pixels, by which the left image is offset to the
% bottom of the right image.
%
%
*/
MagickExport Image *StereoImage(const Image *left_image,
const Image *right_image,ExceptionInfo *exception)
{
return(StereoAnaglyphImage(left_image,right_image,0,0,exception));
}
MagickExport Image *StereoAnaglyphImage(const Image *left_image,
const Image *right_image,const ssize_t x_offset,const ssize_t y_offset,
ExceptionInfo *exception)
{
#define StereoImageTag "Stereo/Image"
const Image
*image;
Image
*stereo_image;
MagickBooleanType
status;
ssize_t
y;
assert(left_image != (const Image *) NULL);
assert(left_image->signature == MagickCoreSignature);
if (left_image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
left_image->filename);
assert(right_image != (const Image *) NULL);
assert(right_image->signature == MagickCoreSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
image=left_image;
if ((left_image->columns != right_image->columns) ||
(left_image->rows != right_image->rows))
ThrowImageException(ImageError,"LeftAndRightImageSizesDiffer");
/*
Initialize stereo image attributes.
*/
stereo_image=CloneImage(left_image,left_image->columns,left_image->rows,
MagickTrue,exception);
if (stereo_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(stereo_image,DirectClass,exception) == MagickFalse)
{
stereo_image=DestroyImage(stereo_image);
return((Image *) NULL);
}
(void) SetImageColorspace(stereo_image,sRGBColorspace,exception);
/*
Copy left image to red channel and right image to blue channel.
*/
status=MagickTrue;
for (y=0; y < (ssize_t) stereo_image->rows; y++)
{
register const Quantum
*magick_restrict p,
*magick_restrict q;
register ssize_t
x;
register Quantum
*magick_restrict r;
p=GetVirtualPixels(left_image,-x_offset,y-y_offset,image->columns,1,
exception);
q=GetVirtualPixels(right_image,0,y,right_image->columns,1,exception);
r=QueueAuthenticPixels(stereo_image,0,y,stereo_image->columns,1,exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL) ||
(r == (Quantum *) NULL))
break;
for (x=0; x < (ssize_t) stereo_image->columns; x++)
{
SetPixelRed(stereo_image,GetPixelRed(left_image,p),r);
SetPixelGreen(stereo_image,GetPixelGreen(right_image,q),r);
SetPixelBlue(stereo_image,GetPixelBlue(right_image,q),r);
if ((GetPixelAlphaTraits(stereo_image) & CopyPixelTrait) != 0)
SetPixelAlpha(stereo_image,(GetPixelAlpha(left_image,p)+
GetPixelAlpha(right_image,q))/2,r);
p+=GetPixelChannels(left_image);
q+=GetPixelChannels(right_image);
r+=GetPixelChannels(stereo_image);
}
if (SyncAuthenticPixels(stereo_image,exception) == MagickFalse)
break;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,StereoImageTag,(MagickOffsetType) y,
stereo_image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
if (status == MagickFalse)
stereo_image=DestroyImage(stereo_image);
return(stereo_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S w i r l I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SwirlImage() swirls the pixels about the center of the image, where
% degrees indicates the sweep of the arc through which each pixel is moved.
% You get a more dramatic effect as the degrees move from 1 to 360.
%
% The format of the SwirlImage method is:
%
% Image *SwirlImage(const Image *image,double degrees,
% const PixelInterpolateMethod method,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o degrees: Define the tightness of the swirling effect.
%
% o method: the pixel interpolation method.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SwirlImage(const Image *image,double degrees,
const PixelInterpolateMethod method,ExceptionInfo *exception)
{
#define SwirlImageTag "Swirl/Image"
CacheView
*canvas_view,
*interpolate_view,
*swirl_view;
double
radius;
Image
*canvas_image,
*swirl_image;
MagickBooleanType
status;
MagickOffsetType
progress;
PointInfo
center,
scale;
ssize_t
y;
/*
Initialize swirl image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
canvas_image=CloneImage(image,0,0,MagickTrue,exception);
if (canvas_image == (Image *) NULL)
return((Image *) NULL);
swirl_image=CloneImage(canvas_image,0,0,MagickTrue,exception);
if (swirl_image == (Image *) NULL)
{
canvas_image=DestroyImage(canvas_image);
return((Image *) NULL);
}
if (SetImageStorageClass(swirl_image,DirectClass,exception) == MagickFalse)
{
canvas_image=DestroyImage(canvas_image);
swirl_image=DestroyImage(swirl_image);
return((Image *) NULL);
}
if (swirl_image->background_color.alpha_trait != UndefinedPixelTrait)
(void) SetImageAlphaChannel(swirl_image,OnAlphaChannel,exception);
/*
Compute scaling factor.
*/
center.x=(double) canvas_image->columns/2.0;
center.y=(double) canvas_image->rows/2.0;
radius=MagickMax(center.x,center.y);
scale.x=1.0;
scale.y=1.0;
if (canvas_image->columns > canvas_image->rows)
scale.y=(double) canvas_image->columns/(double) canvas_image->rows;
else
if (canvas_image->columns < canvas_image->rows)
scale.x=(double) canvas_image->rows/(double) canvas_image->columns;
degrees=(double) DegreesToRadians(degrees);
/*
Swirl image.
*/
status=MagickTrue;
progress=0;
canvas_view=AcquireVirtualCacheView(canvas_image,exception);
interpolate_view=AcquireVirtualCacheView(image,exception);
swirl_view=AcquireAuthenticCacheView(swirl_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(canvas_image,swirl_image,canvas_image->rows,1)
#endif
for (y=0; y < (ssize_t) canvas_image->rows; y++)
{
double
distance;
PointInfo
delta;
register const Quantum
*magick_restrict p;
register ssize_t
x;
register Quantum
*magick_restrict q;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(canvas_view,0,y,canvas_image->columns,1,
exception);
q=QueueCacheViewAuthenticPixels(swirl_view,0,y,swirl_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
delta.y=scale.y*(double) (y-center.y);
for (x=0; x < (ssize_t) canvas_image->columns; x++)
{
/*
Determine if the pixel is within an ellipse.
*/
delta.x=scale.x*(double) (x-center.x);
distance=delta.x*delta.x+delta.y*delta.y;
if (distance >= (radius*radius))
{
register ssize_t
i;
for (i=0; i < (ssize_t) GetPixelChannels(canvas_image); i++)
{
PixelChannel channel = GetPixelChannelChannel(canvas_image,i);
PixelTrait traits = GetPixelChannelTraits(canvas_image,channel);
PixelTrait swirl_traits = GetPixelChannelTraits(swirl_image,
channel);
if ((traits == UndefinedPixelTrait) ||
(swirl_traits == UndefinedPixelTrait))
continue;
SetPixelChannel(swirl_image,channel,p[i],q);
}
}
else
{
double
cosine,
factor,
sine;
/*
Swirl the pixel.
*/
factor=1.0-sqrt((double) distance)/radius;
sine=sin((double) (degrees*factor*factor));
cosine=cos((double) (degrees*factor*factor));
status=InterpolatePixelChannels(canvas_image,interpolate_view,
swirl_image,method,((cosine*delta.x-sine*delta.y)/scale.x+center.x),
(double) ((sine*delta.x+cosine*delta.y)/scale.y+center.y),q,
exception);
if (status == MagickFalse)
break;
}
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(swirl_image);
}
if (SyncCacheViewAuthenticPixels(swirl_view,exception) == MagickFalse)
status=MagickFalse;
if (canvas_image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(canvas_image,SwirlImageTag,progress,
canvas_image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
swirl_view=DestroyCacheView(swirl_view);
interpolate_view=DestroyCacheView(interpolate_view);
canvas_view=DestroyCacheView(canvas_view);
canvas_image=DestroyImage(canvas_image);
if (status == MagickFalse)
swirl_image=DestroyImage(swirl_image);
return(swirl_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% T i n t I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% TintImage() applies a color vector to each pixel in the image. The length
% of the vector is 0 for black and white and at its maximum for the midtones.
% The vector weighting function is f(x)=(1-(4.0*((x-0.5)*(x-0.5))))
%
% The format of the TintImage method is:
%
% Image *TintImage(const Image *image,const char *blend,
% const PixelInfo *tint,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o blend: A color value used for tinting.
%
% o tint: A color value used for tinting.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *TintImage(const Image *image,const char *blend,
const PixelInfo *tint,ExceptionInfo *exception)
{
#define TintImageTag "Tint/Image"
CacheView
*image_view,
*tint_view;
double
intensity;
GeometryInfo
geometry_info;
Image
*tint_image;
MagickBooleanType
status;
MagickOffsetType
progress;
PixelInfo
color_vector;
MagickStatusType
flags;
ssize_t
y;
/*
Allocate tint image.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
tint_image=CloneImage(image,0,0,MagickTrue,exception);
if (tint_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(tint_image,DirectClass,exception) == MagickFalse)
{
tint_image=DestroyImage(tint_image);
return((Image *) NULL);
}
if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
(IsPixelInfoGray(tint) == MagickFalse))
(void) SetImageColorspace(tint_image,sRGBColorspace,exception);
if (blend == (const char *) NULL)
return(tint_image);
/*
Determine RGB values of the color.
*/
GetPixelInfo(image,&color_vector);
flags=ParseGeometry(blend,&geometry_info);
color_vector.red=geometry_info.rho;
color_vector.green=geometry_info.rho;
color_vector.blue=geometry_info.rho;
color_vector.alpha=(MagickRealType) OpaqueAlpha;
if ((flags & SigmaValue) != 0)
color_vector.green=geometry_info.sigma;
if ((flags & XiValue) != 0)
color_vector.blue=geometry_info.xi;
if ((flags & PsiValue) != 0)
color_vector.alpha=geometry_info.psi;
if (image->colorspace == CMYKColorspace)
{
color_vector.black=geometry_info.rho;
if ((flags & PsiValue) != 0)
color_vector.black=geometry_info.psi;
if ((flags & ChiValue) != 0)
color_vector.alpha=geometry_info.chi;
}
intensity=(double) GetPixelInfoIntensity((const Image *) NULL,tint);
color_vector.red=(double) (color_vector.red*tint->red/100.0-intensity);
color_vector.green=(double) (color_vector.green*tint->green/100.0-intensity);
color_vector.blue=(double) (color_vector.blue*tint->blue/100.0-intensity);
color_vector.black=(double) (color_vector.black*tint->black/100.0-intensity);
color_vector.alpha=(double) (color_vector.alpha*tint->alpha/100.0-intensity);
/*
Tint image.
*/
status=MagickTrue;
progress=0;
image_view=AcquireVirtualCacheView(image,exception);
tint_view=AcquireAuthenticCacheView(tint_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(image,tint_image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*magick_restrict p;
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
q=QueueCacheViewAuthenticPixels(tint_view,0,y,tint_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
PixelInfo
pixel;
double
weight;
GetPixelInfo(image,&pixel);
weight=QuantumScale*GetPixelRed(image,p)-0.5;
pixel.red=(MagickRealType) GetPixelRed(image,p)+color_vector.red*
(1.0-(4.0*(weight*weight)));
weight=QuantumScale*GetPixelGreen(image,p)-0.5;
pixel.green=(MagickRealType) GetPixelGreen(image,p)+color_vector.green*
(1.0-(4.0*(weight*weight)));
weight=QuantumScale*GetPixelBlue(image,p)-0.5;
pixel.blue=(MagickRealType) GetPixelBlue(image,p)+color_vector.blue*
(1.0-(4.0*(weight*weight)));
weight=QuantumScale*GetPixelBlack(image,p)-0.5;
pixel.black=(MagickRealType) GetPixelBlack(image,p)+color_vector.black*
(1.0-(4.0*(weight*weight)));
pixel.alpha=(MagickRealType) GetPixelAlpha(image,p);
SetPixelViaPixelInfo(tint_image,&pixel,q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(tint_image);
}
if (SyncCacheViewAuthenticPixels(tint_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(image,TintImageTag,progress,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
tint_view=DestroyCacheView(tint_view);
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
tint_image=DestroyImage(tint_image);
return(tint_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% V i g n e t t e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% VignetteImage() softens the edges of the image in vignette style.
%
% The format of the VignetteImage method is:
%
% Image *VignetteImage(const Image *image,const double radius,
% const double sigma,const ssize_t x,const ssize_t y,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o radius: the radius of the pixel neighborhood.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
% o x, y: Define the x and y ellipse offset.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *VignetteImage(const Image *image,const double radius,
const double sigma,const ssize_t x,const ssize_t y,ExceptionInfo *exception)
{
char
ellipse[MagickPathExtent];
DrawInfo
*draw_info;
Image
*canvas,
*blur_image,
*oval_image,
*vignette_image;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
canvas=CloneImage(image,0,0,MagickTrue,exception);
if (canvas == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(canvas,DirectClass,exception) == MagickFalse)
{
canvas=DestroyImage(canvas);
return((Image *) NULL);
}
canvas->alpha_trait=BlendPixelTrait;
oval_image=CloneImage(canvas,canvas->columns,canvas->rows,MagickTrue,
exception);
if (oval_image == (Image *) NULL)
{
canvas=DestroyImage(canvas);
return((Image *) NULL);
}
(void) QueryColorCompliance("#000000",AllCompliance,
&oval_image->background_color,exception);
(void) SetImageBackgroundColor(oval_image,exception);
draw_info=CloneDrawInfo((const ImageInfo *) NULL,(const DrawInfo *) NULL);
(void) QueryColorCompliance("#ffffff",AllCompliance,&draw_info->fill,
exception);
(void) QueryColorCompliance("#ffffff",AllCompliance,&draw_info->stroke,
exception);
(void) FormatLocaleString(ellipse,MagickPathExtent,"ellipse %g,%g,%g,%g,"
"0.0,360.0",image->columns/2.0,image->rows/2.0,image->columns/2.0-x,
image->rows/2.0-y);
draw_info->primitive=AcquireString(ellipse);
(void) DrawImage(oval_image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
blur_image=BlurImage(oval_image,radius,sigma,exception);
oval_image=DestroyImage(oval_image);
if (blur_image == (Image *) NULL)
{
canvas=DestroyImage(canvas);
return((Image *) NULL);
}
blur_image->alpha_trait=UndefinedPixelTrait;
(void) CompositeImage(canvas,blur_image,IntensityCompositeOp,MagickTrue,
0,0,exception);
blur_image=DestroyImage(blur_image);
vignette_image=MergeImageLayers(canvas,FlattenLayer,exception);
canvas=DestroyImage(canvas);
if (vignette_image != (Image *) NULL)
(void) TransformImageColorspace(vignette_image,image->colorspace,exception);
return(vignette_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W a v e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WaveImage() creates a "ripple" effect in the image by shifting the pixels
% vertically along a sine wave whose amplitude and wavelength is specified
% by the given parameters.
%
% The format of the WaveImage method is:
%
% Image *WaveImage(const Image *image,const double amplitude,
% const double wave_length,const PixelInterpolateMethod method,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o amplitude, wave_length: Define the amplitude and wave length of the
% sine wave.
%
% o interpolate: the pixel interpolation method.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *WaveImage(const Image *image,const double amplitude,
const double wave_length,const PixelInterpolateMethod method,
ExceptionInfo *exception)
{
#define WaveImageTag "Wave/Image"
CacheView
*canvas_image_view,
*wave_view;
float
*sine_map;
Image
*canvas_image,
*wave_image;
MagickBooleanType
status;
MagickOffsetType
progress;
register ssize_t
i;
ssize_t
y;
/*
Initialize wave image attributes.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
canvas_image=CloneImage(image,0,0,MagickTrue,exception);
if (canvas_image == (Image *) NULL)
return((Image *) NULL);
if ((canvas_image->alpha_trait == UndefinedPixelTrait) &&
(canvas_image->background_color.alpha != OpaqueAlpha))
(void) SetImageAlpha(canvas_image,OpaqueAlpha,exception);
wave_image=CloneImage(canvas_image,canvas_image->columns,(size_t)
(canvas_image->rows+2.0*fabs(amplitude)),MagickTrue,exception);
if (wave_image == (Image *) NULL)
{
canvas_image=DestroyImage(canvas_image);
return((Image *) NULL);
}
if (SetImageStorageClass(wave_image,DirectClass,exception) == MagickFalse)
{
canvas_image=DestroyImage(canvas_image);
wave_image=DestroyImage(wave_image);
return((Image *) NULL);
}
/*
Allocate sine map.
*/
sine_map=(float *) AcquireQuantumMemory((size_t) wave_image->columns,
sizeof(*sine_map));
if (sine_map == (float *) NULL)
{
canvas_image=DestroyImage(canvas_image);
wave_image=DestroyImage(wave_image);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
for (i=0; i < (ssize_t) wave_image->columns; i++)
sine_map[i]=(float) fabs(amplitude)+amplitude*sin((double)
((2.0*MagickPI*i)/wave_length));
/*
Wave image.
*/
status=MagickTrue;
progress=0;
canvas_image_view=AcquireVirtualCacheView(canvas_image,exception);
wave_view=AcquireAuthenticCacheView(wave_image,exception);
(void) SetCacheViewVirtualPixelMethod(canvas_image_view,
BackgroundVirtualPixelMethod);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
magick_number_threads(canvas_image,wave_image,wave_image->rows,1)
#endif
for (y=0; y < (ssize_t) wave_image->rows; y++)
{
register const Quantum
*magick_restrict p;
register Quantum
*magick_restrict q;
register ssize_t
x;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(canvas_image_view,0,y,canvas_image->columns,1,
exception);
q=QueueCacheViewAuthenticPixels(wave_view,0,y,wave_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
{
status=MagickFalse;
continue;
}
for (x=0; x < (ssize_t) wave_image->columns; x++)
{
status=InterpolatePixelChannels(canvas_image,canvas_image_view,
wave_image,method,(double) x,(double) (y-sine_map[x]),q,exception);
if (status == MagickFalse)
break;
p+=GetPixelChannels(canvas_image);
q+=GetPixelChannels(wave_image);
}
if (SyncCacheViewAuthenticPixels(wave_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp atomic
#endif
progress++;
proceed=SetImageProgress(canvas_image,WaveImageTag,progress,
canvas_image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
wave_view=DestroyCacheView(wave_view);
canvas_image_view=DestroyCacheView(canvas_image_view);
canvas_image=DestroyImage(canvas_image);
sine_map=(float *) RelinquishMagickMemory(sine_map);
if (status == MagickFalse)
wave_image=DestroyImage(wave_image);
return(wave_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W a v e l e t D e n o i s e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WaveletDenoiseImage() removes noise from the image using a wavelet
% transform. The wavelet transform is a fast hierarchical scheme for
% processing an image using a set of consecutive lowpass and high_pass filters,
% followed by a decimation. This results in a decomposition into different
% scales which can be regarded as different “frequency bands”, determined by
% the mother wavelet. Adapted from dcraw.c by David Coffin.
%
% The format of the WaveletDenoiseImage method is:
%
% Image *WaveletDenoiseImage(const Image *image,const double threshold,
% const double softness,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
% o threshold: set the threshold for smoothing.
%
% o softness: attenuate the smoothing threshold.
%
% o exception: return any errors or warnings in this structure.
%
*/
static inline void HatTransform(const float *magick_restrict pixels,
const size_t stride,const size_t extent,const size_t scale,float *kernel)
{
const float
*magick_restrict p,
*magick_restrict q,
*magick_restrict r;
register ssize_t
i;
p=pixels;
q=pixels+scale*stride;
r=pixels+scale*stride;
for (i=0; i < (ssize_t) scale; i++)
{
kernel[i]=0.25f*(*p+(*p)+(*q)+(*r));
p+=stride;
q-=stride;
r+=stride;
}
for ( ; i < (ssize_t) (extent-scale); i++)
{
kernel[i]=0.25f*(2.0f*(*p)+*(p-scale*stride)+*(p+scale*stride));
p+=stride;
}
q=p-scale*stride;
r=pixels+stride*(extent-2);
for ( ; i < (ssize_t) extent; i++)
{
kernel[i]=0.25f*(*p+(*p)+(*q)+(*r));
p+=stride;
q+=stride;
r-=stride;
}
}
MagickExport Image *WaveletDenoiseImage(const Image *image,
const double threshold,const double softness,ExceptionInfo *exception)
{
CacheView
*image_view,
*noise_view;
float
*kernel,
*pixels;
Image
*noise_image;
MagickBooleanType
status;
MagickSizeType
number_pixels;
MemoryInfo
*pixels_info;
ssize_t
channel;
static const float
noise_levels[] = { 0.8002f, 0.2735f, 0.1202f, 0.0585f, 0.0291f, 0.0152f,
0.0080f, 0.0044f };
/*
Initialize noise image attributes.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
#if defined(MAGICKCORE_OPENCL_SUPPORT)
noise_image=AccelerateWaveletDenoiseImage(image,threshold,exception);
if (noise_image != (Image *) NULL)
return(noise_image);
#endif
noise_image=CloneImage(image,0,0,MagickTrue,exception);
if (noise_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(noise_image,DirectClass,exception) == MagickFalse)
{
noise_image=DestroyImage(noise_image);
return((Image *) NULL);
}
if (AcquireMagickResource(WidthResource,4*image->columns) == MagickFalse)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
pixels_info=AcquireVirtualMemory(3*image->columns,image->rows*
sizeof(*pixels));
kernel=(float *) AcquireQuantumMemory(MagickMax(image->rows,image->columns)+1,
GetOpenMPMaximumThreads()*sizeof(*kernel));
if ((pixels_info == (MemoryInfo *) NULL) || (kernel == (float *) NULL))
{
if (kernel != (float *) NULL)
kernel=(float *) RelinquishMagickMemory(kernel);
if (pixels_info != (MemoryInfo *) NULL)
pixels_info=RelinquishVirtualMemory(pixels_info);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
pixels=(float *) GetVirtualMemoryBlob(pixels_info);
status=MagickTrue;
number_pixels=(MagickSizeType) image->columns*image->rows;
image_view=AcquireAuthenticCacheView(image,exception);
noise_view=AcquireAuthenticCacheView(noise_image,exception);
for (channel=0; channel < (ssize_t) GetPixelChannels(image); channel++)
{
register ssize_t
i;
size_t
high_pass,
low_pass;
ssize_t
level,
y;
PixelChannel
pixel_channel;
PixelTrait
traits;
if (status == MagickFalse)
continue;
traits=GetPixelChannelTraits(image,(PixelChannel) channel);
if (traits == UndefinedPixelTrait)
continue;
pixel_channel=GetPixelChannelChannel(image,channel);
if ((pixel_channel != RedPixelChannel) &&
(pixel_channel != GreenPixelChannel) &&
(pixel_channel != BluePixelChannel))
continue;
/*
Copy channel from image to wavelet pixel array.
*/
i=0;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*magick_restrict p;
ssize_t
x;
p=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
pixels[i++]=(float) p[channel];
p+=GetPixelChannels(image);
}
}
/*
Low pass filter outputs are called approximation kernel & high pass
filters are referred to as detail kernel. The detail kernel
have high values in the noisy parts of the signal.
*/
high_pass=0;
for (level=0; level < 5; level++)
{
double
magnitude;
ssize_t
x,
y;
low_pass=(size_t) (number_pixels*((level & 0x01)+1));
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,1) \
magick_number_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
const int
id = GetOpenMPThreadId();
register float
*magick_restrict p,
*magick_restrict q;
register ssize_t
x;
p=kernel+id*image->columns;
q=pixels+y*image->columns;
HatTransform(q+high_pass,1,image->columns,(size_t) (1UL << level),p);
q+=low_pass;
for (x=0; x < (ssize_t) image->columns; x++)
*q++=(*p++);
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,1) \
magick_number_threads(image,image,image->columns,1)
#endif
for (x=0; x < (ssize_t) image->columns; x++)
{
const int
id = GetOpenMPThreadId();
register float
*magick_restrict p,
*magick_restrict q;
register ssize_t
y;
p=kernel+id*image->rows;
q=pixels+x+low_pass;
HatTransform(q,image->columns,image->rows,(size_t) (1UL << level),p);
for (y=0; y < (ssize_t) image->rows; y++)
{
*q=(*p++);
q+=image->columns;
}
}
/*
To threshold, each coefficient is compared to a threshold value and
attenuated / shrunk by some factor.
*/
magnitude=threshold*noise_levels[level];
for (i=0; i < (ssize_t) number_pixels; ++i)
{
pixels[high_pass+i]-=pixels[low_pass+i];
if (pixels[high_pass+i] < -magnitude)
pixels[high_pass+i]+=magnitude-softness*magnitude;
else
if (pixels[high_pass+i] > magnitude)
pixels[high_pass+i]-=magnitude-softness*magnitude;
else
pixels[high_pass+i]*=softness;
if (high_pass != 0)
pixels[i]+=pixels[high_pass+i];
}
high_pass=low_pass;
}
/*
Reconstruct image from the thresholded wavelet kernel.
*/
i=0;
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
sync;
register Quantum
*magick_restrict q;
register ssize_t
x;
ssize_t
offset;
q=GetCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
exception);
if (q == (Quantum *) NULL)
{
status=MagickFalse;
break;
}
offset=GetPixelChannelOffset(noise_image,pixel_channel);
for (x=0; x < (ssize_t) image->columns; x++)
{
MagickRealType
pixel;
pixel=(MagickRealType) pixels[i]+pixels[low_pass+i];
q[offset]=ClampToQuantum(pixel);
i++;
q+=GetPixelChannels(noise_image);
}
sync=SyncCacheViewAuthenticPixels(noise_view,exception);
if (sync == MagickFalse)
status=MagickFalse;
}
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
proceed=SetImageProgress(image,AddNoiseImageTag,(MagickOffsetType)
channel,GetPixelChannels(image));
if (proceed == MagickFalse)
status=MagickFalse;
}
}
noise_view=DestroyCacheView(noise_view);
image_view=DestroyCacheView(image_view);
kernel=(float *) RelinquishMagickMemory(kernel);
pixels_info=RelinquishVirtualMemory(pixels_info);
if (status == MagickFalse)
noise_image=DestroyImage(noise_image);
return(noise_image);
}
| 33.084728 | 84 | 0.583612 |
2eb210cc223691737dea6b9dbe1235dc8919f390 | 3,380 | c | C | resis/ResDebug.c | wisehackermonkey/magic | fb85e97b9233cff352d964823173c18527c714aa | [
"TCL",
"X11",
"MIT"
] | null | null | null | resis/ResDebug.c | wisehackermonkey/magic | fb85e97b9233cff352d964823173c18527c714aa | [
"TCL",
"X11",
"MIT"
] | null | null | null | resis/ResDebug.c | wisehackermonkey/magic | fb85e97b9233cff352d964823173c18527c714aa | [
"TCL",
"X11",
"MIT"
] | null | null | null |
#ifndef lint
static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/resis/ResDebug.c,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $";
#endif /* not lint */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "utils/magic.h"
#include "utils/geometry.h"
#include "utils/geofast.h"
#include "tiles/tile.h"
#include "utils/hash.h"
#include "database/database.h"
#include "utils/malloc.h"
#include "textio/textio.h"
#include "extract/extract.h"
#include "extract/extractInt.h"
#include "windows/windows.h"
#include "dbwind/dbwind.h"
#include "utils/utils.h"
#include "utils/tech.h"
#include "textio/txcommands.h"
#include "utils/stack.h"
#include "resis/resis.h"
#define MAXNAME 1000
#define KV_TO_mV 1000000
/*
*-------------------------------------------------------------------------
*
* ResPrintNodeList-- Prints out all the nodes in nodelist.
*
*
* Results:
* None.
*
* Side effects:
* prints out the 'nodes' in list to fp.
*
*-------------------------------------------------------------------------
*/
void
ResPrintNodeList(fp, list)
FILE *fp;
resNode *list;
{
for (; list != NULL; list = list->rn_more)
{
fprintf(fp, "node %p: (%d %d) r= %d\n",
list, list->rn_loc.p_x, list->rn_loc.p_y, list->rn_noderes);
}
}
/*
*-------------------------------------------------------------------------
*
* ResPrintResistorList--
*
*
* results: none
*
*
* side effects: prints out Resistors in list to file fp.
*
*-------------------------------------------------------------------------
*/
void
ResPrintResistorList(fp, list)
FILE *fp;
resResistor *list;
{
for (; list != NULL; list = list->rr_nextResistor)
{
if (fp == stdout)
TxPrintf("r (%d,%d) (%d,%d) r=%d\n",
list->rr_connection1->rn_loc.p_x,
list->rr_connection1->rn_loc.p_y,
list->rr_connection2->rn_loc.p_x,
list->rr_connection2->rn_loc.p_y,
list->rr_value);
else
fprintf(fp, "r (%d,%d) (%d,%d) r=%d\n",
list->rr_connection1->rn_loc.p_x,
list->rr_connection1->rn_loc.p_y,
list->rr_connection2->rn_loc.p_x,
list->rr_connection2->rn_loc.p_y,
list->rr_value);
}
}
/*
*-------------------------------------------------------------------------
*
* ResPrintDeviceList--
*
*
* Results: none
*
* Side effects: prints out devices in list to file fp.
*
*-------------------------------------------------------------------------
*/
void
ResPrintDeviceList(fp, list)
FILE *fp;
resDevice *list;
{
static char termtype[] = {'g','s','d','c'};
int i;
for (; list != NULL; list = list->rd_nextDev)
{
if (list->rd_status & RES_DEV_PLUG) continue;
if (fp == stdout)
TxPrintf("t w %d l %d ", list->rd_width, list->rd_length);
else
fprintf(fp, "t w %d l %d ", list->rd_width, list->rd_length);
for (i = 0; i != list->rd_nterms; i++)
{
if (list->rd_terminals[i] == NULL) continue;
if (fp == stdout)
TxPrintf("%c (%d,%d) ",termtype[i],
list->rd_terminals[i]->rn_loc.p_x,
list->rd_terminals[i]->rn_loc.p_y);
else
fprintf(fp, "%c (%d,%d) ",termtype[i],
list->rd_terminals[i]->rn_loc.p_x,
list->rd_terminals[i]->rn_loc.p_y);
}
if (fp == stdout)
TxPrintf("\n");
else
fprintf(fp,"\n");
}
}
| 22.993197 | 138 | 0.521302 |
2eda2aaf1b32757d5bc5d275a22c0e816857e998 | 2,424 | h | C | include/Map.h | IamCrazyAlien/dephpX | d732e679c038d2abeb10f686e40f1efe4cf61ce5 | [
"MIT"
] | null | null | null | include/Map.h | IamCrazyAlien/dephpX | d732e679c038d2abeb10f686e40f1efe4cf61ce5 | [
"MIT"
] | null | null | null | include/Map.h | IamCrazyAlien/dephpX | d732e679c038d2abeb10f686e40f1efe4cf61ce5 | [
"MIT"
] | null | null | null | /*
///////////////////////////////////////////////////////////////////////////////
//
// FileName : Map.h
// Version : 1.0
// Creator : RM
// Create Date : 2006-01-01
// Comment :
//
///////////////////////////////////////////////////////////////////////////////
*/
#ifndef __MAP_H__
#define __MAP_H__
#ifdef __cplusplus
extern "C"
{
#endif
/*
///////////////////////////////////////////////////////////////////////////////
// D E F I N E S
///////////////////////////////////////////////////////////////////////////////
*/
#define MAP_FILE_QUERY 0x1
#define MAP_FILE_WRITE 0x2
#define MAP_FILE_READ 0x4
#define MAP_FILE_EXECUTE 0x8
#define MAP_FILE_READWRITE ( MAP_FILE_WRITE | MAP_FILE_READ )
#define MAP_FILE_ALL ( MAP_FILE_QUERY | MAP_FILE_WRITE | MAP_FILE_READ )
#define MAP_FILE_GENERIC_WRITE 0x200
#define MAP_FILE_GENERIC_READ 0x400
#define MAP_FILE_GENERIC_EXECUTE 0x800
#define MAP_FILE_GENERIC_READWRITE ( MAP_FILE_GENERIC_WRITE | MAP_FILE_GENERIC_READ )
#define MAP_FILE_GENERIC_ALL ( MAP_FILE_GENERIC_WRITE | MAP_FILE_GENERIC_READ | MAP_FILE_GENERIC_EXECUTE )
#define MAP_FILE_SHARE_WRITE 0x20000
#define MAP_FILE_SHARE_READ 0x40000
#define MAP_FILE_SHARE_DELETE 0x80000
#define MAP_FILE_SHARE_READWRITE ( MAP_FILE_SHARE_WRITE | MAP_FILE_SHARE_READ )
#define MAP_FILE_SHARE_ALL ( MAP_FILE_SHARE_WRITE | MAP_FILE_SHARE_READ | MAP_FILE_SHARE_DELETE )
/*
///////////////////////////////////////////////////////////////////////////////
// S T R U C T U R E S
///////////////////////////////////////////////////////////////////////////////
*/
/*
///////////////////////////////////////////////////////////////////////////////
// G L O B A L S
///////////////////////////////////////////////////////////////////////////////
*/
/*
///////////////////////////////////////////////////////////////////////////////
// F U N C T I O N S
///////////////////////////////////////////////////////////////////////////////
*/
ULONG MapFile( LPCTSTR FileName, PVOID *Map, ULONG *FileSizePtr, ULONG *FileSizeHighPtr );
ULONG MapFileEx( LPCTSTR FileName, PVOID *Map, ULONG *FileSizePtr, ULONG *FileSizeHighPtr, ULONG Flags );
ULONG UnMapFile( PVOID Map );
#ifdef __cplusplus
}
#endif
/*
///////////////////////////////////////////////////////////////////////////////
// E N D O F F I L E
///////////////////////////////////////////////////////////////////////////////
*/
#endif /* __MAP_H__ */ | 32.756757 | 106 | 0.449257 |
c8cbb0e98fca75190ad6445bf1d838e454165090 | 1,724 | h | C | src/websockets-hixie76.h | gtritchie/httpuv | 2e69d2315bfd320714878d4206e00de2be912938 | [
"BSL-1.0"
] | 181 | 2015-01-20T10:10:54.000Z | 2022-03-06T05:01:32.000Z | src/websockets-hixie76.h | gtritchie/httpuv | 2e69d2315bfd320714878d4206e00de2be912938 | [
"BSL-1.0"
] | 241 | 2015-03-06T00:02:03.000Z | 2022-03-31T21:15:59.000Z | src/websockets-hixie76.h | gtritchie/httpuv | 2e69d2315bfd320714878d4206e00de2be912938 | [
"BSL-1.0"
] | 76 | 2015-01-01T00:50:45.000Z | 2022-03-05T22:30:43.000Z | #ifndef WEBSOCKETS_HIXIE76_H
#define WEBSOCKETS_HIXIE76_H
#include "websockets.h"
#include "websockets-hybi03.h"
enum Hixie76State {
// Starting state, also what we return to after finishing a frame
H76_START,
// We saw 0x00 indicating text frame, now looking for matching 0xFF.
// Everything in between is payload data.
H76_IN_TEXT_FRAME,
// We just saw 0xFF, the next byte will determine if it's a close
// message (i.e. if it's 0x00) or if it's a regular binary frame.
H76_IN_BINARY_OR_CLOSE_FRAME_LENGTH,
// The current byte is part of the frame length info; if the high-order
// bit is set to 1, then the next byte is also part of the frame length
// info.
H76_IN_BINARY_FRAME_LENGTH,
// We are in the binary payload, with _bytesLeft to go.
H76_IN_BINARY_FRAME
};
class WSHixie76Parser : public WSParser {
private:
WSParserCallbacks* _pCallbacks;
WebSocketProto_HyBi03 _hybi03;
int _state;
size_t _bytesLeft;
public:
WSHixie76Parser(WSParserCallbacks* pCallbacks) :
_pCallbacks(pCallbacks), _state(H76_START) {
}
~WSHixie76Parser() {}
void handshake(const std::string& url,
const RequestHeaders& requestHeaders,
char** ppData, size_t* pLen,
ResponseHeaders* responseHeaders,
std::vector<uint8_t>* pResponse) const;
void createFrameHeaderFooter(
Opcode opcode, bool mask, size_t payloadSize,
int32_t maskingKey,
char pHeaderData[MAX_HEADER_BYTES], size_t* pHeaderLen,
char pFooterData[MAX_FOOTER_BYTES], size_t* pFooterLen
) const;
void read(const char* data, size_t len);
};
#endif // WEBSOCKETS_HIXIE76_H
| 31.925926 | 73 | 0.692575 |
c8eeb7dbb6242babaace3f8512c5c083a0a51a3f | 81,127 | c | C | PERKO-1/GccApplication5/GccApplication5.c | slaviber/PERKO-1 | 729e84d3a62b4da868bba299ae863a39bf8702ea | [
"CC0-1.0"
] | null | null | null | PERKO-1/GccApplication5/GccApplication5.c | slaviber/PERKO-1 | 729e84d3a62b4da868bba299ae863a39bf8702ea | [
"CC0-1.0"
] | null | null | null | PERKO-1/GccApplication5/GccApplication5.c | slaviber/PERKO-1 | 729e84d3a62b4da868bba299ae863a39bf8702ea | [
"CC0-1.0"
] | null | null | null | /*
* GccApplication5.c
*
* Created: 15.01.07 17:52:05
* Author: Administrator
*/
//#define STACK_SIZE 112640
#include <sam4e8c.h>
#include <fastmath.h>
#define IOPORT_PIOD 3
#define IOPORT_CREATE_PIN(port, pin) ((IOPORT_ ## port) * 32 + (pin))
#define LED_0_PIN IOPORT_CREATE_PIN(PIOD, 24)
#define OPA_EN IOPORT_CREATE_PIN(PIOD, 10)
#define D_CS IOPORT_CREATE_PIN(PIOD, 11)
#define D_RW IOPORT_CREATE_PIN(PIOD, 12)
#define ENABLE_L IOPORT_CREATE_PIN(PIOD, 13)
#define ENABLE_H IOPORT_CREATE_PIN(PIOD, 14)
/**
* \brief Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
typedef unsigned char uchar;
//uchar video_H[1000] = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
//uchar video_L[31000] = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
//#include "header.h"
//const unsigned short indexes[512][240] = {{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30}};
#include "index.h"
//const uchar sine256[] = {
//127,130,133,136,139,143,146,149,152,155,158,161,164,167,170,173,176,178,181,184,187,190,192,195,198,200,203,205,208,210,212,215,217,219,221,223,225,227,229,231,233,234,236,238,239,240,
//242,243,244,245,247,248,249,249,250,251,252,252,253,253,253,254,254,254,254,254,254,254,253,253,253,252,252,251,250,249,249,248,247,245,244,243,242,240,239,238,236,234,233,231,229,227,225,223,
//221,219,217,215,212,210,208,205,203,200,198,195,192,190,187,184,181,178,176,173,170,167,164,161,158,155,152,149,146,143,139,136,133,130,127,124,121,118,115,111,108,105,102,99,96,93,90,87,84,81,78,
//76,73,70,67,64,62,59,56,54,51,49,46,44,42,39,37,35,33,31,29,27,25,23,21,20,18,16,15,14,12,11,10,9,7,6,5,5,4,3,2,2,1,1,1,0,0,0,0,0,0,0,1,1,1,2,2,3,4,5,5,6,7,9,10,11,12,14,15,16,18,20,21,23,25,27,29,31,
//33,35,37,39,42,44,46,49,51,54,56,59,62,64,67,70,73,76,78,81,84,87,90,93,96,99,102,105,108,111,115,118,121,124
//
//};
//
//const uchar sine32[] = { 16, 19, 22, 24, 27, 29, 30, 31, 31, 31, 30, 29, 27, 24, 22, 19, 16, 12, 9, 7, 4, 2, 1, 0, 0, 0, 1, 2, 4, 7, 9, 12 };
//const uchar sine16[] = { 8, 11, 13, 15, 15, 15, 13, 11, 8, 4, 2, 0, 0, 0, 2, 4 };
Pio* base;
Pio* data;
Uart* pf_uart;
uint32_t mask;
TcChannel *tc_channel;
unsigned char c = 0;
uint8_t buffer[30] = {149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21, 149, 43, 21};
uint8_t buffer_usart[20] = {55};
static int incr = 0;
Pwm* p_pwm = (Pwm*)(uintptr_t)PWM;
__attribute__((optimize("unroll-loops")))
int main(void)
{
/* Initialize the SAM system */
SystemInit();
PMC->PMC_PCER0 = 1 << ID_PIOD; //enable port D
base = (Pio *)(uintptr_t)PIOD;
mask = (1U << (LED_0_PIN & 0x1F)) | (1U << (OPA_EN & 0x1F)) | (1U << (D_RW & 0x1F)) | (1U << (D_CS & 0x1F)) | (1U << (ENABLE_L & 0x1F)) | (1U << (ENABLE_H & 0x1F)) ;
//prevent short circuit - set output bits before enabling the output register
base->PIO_SODR = 1U << (OPA_EN & 0x1F); //enable output
base->PIO_CODR = 1U << (D_RW & 0x1F); //set to low for write
base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
base->PIO_OER = mask | 1023;
base->PIO_OWER = 1023;
MATRIX->CCFG_SYSIO = CCFG_SYSIO_SYSIO4 | CCFG_SYSIO_SYSIO5 | CCFG_SYSIO_SYSIO6 | CCFG_SYSIO_SYSIO7; //PORTB config disables JTAG
//
PMC->PMC_PCER0 = 1 << ID_PIOB; //enable port B
data = (Pio *)(uintptr_t)PIOB;
data->PIO_OER = 255;
data->PIO_OWER = 255;
//base->PIO_MDER = mask;
//base->PIO_PUER = mask;
//PMC->PMC_PCER0 = 1 << ID_PIOA;
//PIOA->PIO_OER = 1<<9 | 1<<10 | 0b1111111111<<16;
//PMC->PMC_PCER0 = 1 << ID_PIOB;
//PIOB->PIO_OER = 0b11111111;
//
//
//
PMC->PMC_PCER0 = 1 << ID_TC0;
tc_channel = TC0->TC_CHANNEL + 0;//TC0->TC_CHANNEL[0]
tc_channel->TC_CCR = TC_CCR_CLKDIS;
tc_channel->TC_IDR = 0xFFFFFFFF;
tc_channel->TC_SR;
tc_channel->TC_CMR = 0 | TC_CMR_CPCTRG;
tc_channel->TC_IER = TC_IER_CPCS;
tc_channel->TC_RC = 7813;//4002365 //reg=4000280 (7813=reg/512) (32=reg/512/240)
tc_channel->TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG;
WDT->WDT_MR = WDT_MR_WDDIS;
//Pio* uartbase = (Pio *)(uintptr_t)PIOA;
//uint32_t ul_mask = PIO_PA10A_UTXD0 | PIO_PA9A_URXD0;
//uartbase->PIO_PDR = ul_mask;
//uartbase->PIO_IDR = ul_mask;
//uint32_t ul_sr = uartbase->PIO_ABCDSR[0];
//uartbase->PIO_ABCDSR[0] &= (~ul_mask & ul_sr);
//ul_sr = uartbase->PIO_ABCDSR[1];
//uartbase->PIO_ABCDSR[1] &= (~ul_mask & ul_sr);
//
//PMC->PMC_PCER0 = (1 << ID_UART0);
//pf_uart = (Uart*)(uintptr_t)UART0;
//pf_uart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
//pf_uart->UART_BRGR = 2;
//pf_uart->UART_MR = UART_MR_PAR_NO;
//pf_uart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
//pf_uart->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
//
//
//Pdc* uart = (Pdc *)(uintptr_t)PDC_UART0;
//uart->PERIPH_RPR = (uint32_t)buffer;
//uart->PERIPH_RCR = 200;
//uart->PERIPH_PTCR = PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN;
//pf_uart->UART_IER = UART_IER_RXBUFF;
//Pio* usartbase = (Pio *)(uintptr_t)PIOB;
//uint32_t ul2_mask = PIO_PB1C_TXD0;
//usartbase->PIO_PDR = ul2_mask;
//usartbase->PIO_IDR = ul2_mask;
//uint32_t ul_sr2 = usartbase->PIO_ABCDSR[0];
//usartbase->PIO_ABCDSR[0] &= (~ul_mask & ul_sr2);
//ul_sr2 = usartbase->PIO_ABCDSR[1];
//usartbase->PIO_ABCDSR[1] &= (~ul_mask & ul_sr2);
//
//PMC->PMC_PCER0 = (1 << ID_USART0);
//Usart* pf_usart = (Usart*)(uintptr_t)USART0;
//pf_usart->US_WPMR = US_WPMR_WPKEY_PASSWD;
//pf_usart->US_MR = 0;
//pf_usart->US_RTOR = 0;
//pf_usart->US_TTGR = 0;
//pf_usart->US_CR = US_CR_RSTTX | US_CR_TXDIS;
//pf_usart->US_CR = US_CR_RSTRX | US_CR_RXDIS;
//pf_usart->US_CR = US_CR_RSTSTA;
//pf_usart->US_CR = US_CR_RTSDIS;
//pf_usart->US_CR = US_CR_DTRDIS;
////pf_usart->US_MR |= US_MR_OVER; //8x
//pf_usart->US_BRGR = (2 << US_BRGR_CD_Pos) | (0 << US_BRGR_FP_Pos);
//pf_usart->US_MR |= US_MR_CHRL_8_BIT | US_MR_PAR_NO | US_MR_CHMODE_NORMAL | US_MR_NBSTOP_1_BIT;
//pf_usart->US_IDR = 0xffffffff;
//pf_usart->US_CR = US_CR_TXEN;
//pf_usart->US_CR = US_CR_RXEN;
//
//Pdc* usart = (Pdc *)(uintptr_t)PDC_USART0;
//usart->PERIPH_PTCR = PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN;
//usart->PERIPH_TPR = (uint32_t)buffer_usart;
//usart->PERIPH_TCR = 20;
//pf_usart->US_IER = US_IER_TXBUFE;
//
//
//PMC->PMC_PCER0 = 1 << ID_PIOD;
//base = (Pio *)(uintptr_t)PIOD;
//mask = 1U << (LED_0_PIN & 0x1F);
//base->PIO_PDR = mask;
//base->PIO_IDR = mask;
//
//
//int PWMs = ID_PWM-32;
//PMC->PMC_PCER1 = (1 << PWMs);
//p_pwm->PWM_DIS = (1 << 0); //channel 0
//p_pwm->PWM_CLK = 0; //no divider
//uint32_t tmp_reg =
//0 |
//(1 << 9) |
//(0) |
//(0 << 16) |
//(0 << 17) |
//(0 << 18) |
//(0 << 8);
////no prescaler
////polarity high
////counter event at end
////no dead time
////pwmh not inverted
////pwml not inverted
////left alignment
//
//p_pwm->PWM_CH_NUM[0].PWM_CMR = tmp_reg;
//
//p_pwm->PWM_CH_NUM[0].PWM_CDTY = 8;
//p_pwm->PWM_CH_NUM[0].PWM_CPRD = 15;
//
//
//
//
//
//p_pwm->PWM_IER1 = (1 << 0) | (1 << (0 + 16));
//
///* Configure interrupt and enable PWM interrupt */
//NVIC_DisableIRQ(PWM_IRQn);
//NVIC_ClearPendingIRQ(PWM_IRQn);
////NVIC_SetPriority(PWM_IRQn, 0);
//NVIC_EnableIRQ(PWM_IRQn);
//
//p_pwm->PWM_ENA = (1 << 0); //channel 0
//
//
//
//
//
//
NVIC_DisableIRQ(ID_TC0);
NVIC_DisableIRQ(UART0_IRQn);
NVIC_DisableIRQ(USART0_IRQn);
NVIC_DisableIRQ(PWM_IRQn);
NVIC_ClearPendingIRQ(ID_TC0);
NVIC_SetPriority(ID_TC0,0);
//NVIC_ClearPendingIRQ(UART0_IRQn);
//NVIC_SetPriority(UART0_IRQn,1);
//NVIC_ClearPendingIRQ(USART0_IRQn);
//NVIC_SetPriority(USART0_IRQn,0);
NVIC_EnableIRQ(ID_TC0);
//NVIC_EnableIRQ(UART0_IRQn);
//NVIC_EnableIRQ(USART0_IRQn);
//short num = 0;
//char even = 0;
//int a = 0;
base->PIO_SODR = 1U << (OPA_EN & 0x1F); //enable output
base->PIO_CODR = 1U << (D_RW & 0x1F); //set to low for write
base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
base->PIO_CODR = 1023; //reset output data
base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//unsigned int i = 0;
//unsigned int counter = 0;
//unsigned int led = 0;
//
while(1){
}
//while (1)
//{
//++counter;
//counter %= 800;
//if(!counter)++i;
//if(!i){
// ++led;
// led %= 12;
//}
//i %= 1024;
//num = 0;
//incr = 0;
//for(int g = 0; g < 2; ++g){
//int f = 0;
//while(f < 15){
//short C = buffer[indexes[num][incr++]] - 16;
//short D = buffer[indexes[num][incr++]] - 128;
//short E = buffer[indexes[num][incr++]] - 128;
//
//if(g == f)++f;
//
//base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
//base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
//data->PIO_CODR = 255;
//data->PIO_SODR = g | f<<4;
//base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
//base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//
////RED
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_CODR = 1023; //reset output data
//base->PIO_SODR = 512; //set output data
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
//base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
//data->PIO_CODR = 255;
//data->PIO_SODR = g | f<<4;
//base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
//base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//
////GREEN
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_CODR = 1023; //reset output data
//base->PIO_SODR = 0; //set output data
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
//base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
//data->PIO_CODR = 255;
//data->PIO_SODR = g | f<<4;
//base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
//base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//
////BLUE
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_CODR = 1023; //reset output data
//base->PIO_SODR = 0; //set output data
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//}
//}
//}
//base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
//base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//
//incr = 0;
//for(int g = 0; g < 2; ++g){
//for(int f = 0; f < 16; ++f){
//
//
//signed int C = 235 - 16;
//signed int D = 128 - 128;
//signed int E = 128 - 128;
//
////if(g == f)++f;
//
////data->PIO_CODR = 255;
////data->PIO_SODR = g | f<<4;
//
//
////RED
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
////base->PIO_CODR = 1023; //reset output data
////base->PIO_SODR = 260+(( 298 * C + 409 * E + 128) >> 8)*2.89f; //set output data
//base->PIO_ODSR = 260+(( 298 * C + 409 * E + 128) >> 8)*2.89f;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
////++f;
//if(g == f)++f;
//
////data->PIO_CODR = 255;
////data->PIO_SODR = g | f<<4;
//data->PIO_ODSR = g | f<<4;
//
////GREEN
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
////base->PIO_CODR = 1023; //reset output data
////base->PIO_SODR = 315+(( 298 * C - 100 * D - 208 * E + 128) >> 8)*1.11f; //set output data
//base->PIO_ODSR = 315+(( 298 * C - 100 * D - 208 * E + 128) >> 8)*1.11f;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//
////data->PIO_CODR = 255;
////data->PIO_SODR = g | f<<4;
//data->PIO_ODSR = g | f<<4;
//
////BLUE
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
////base->PIO_CODR = 1023; //reset output data
////base->PIO_SODR = 350+(( 298 * C + 516 * D + 128) >> 8)*1.36f; //set output data
//base->PIO_ODSR = 350+(( 298 * C + 516 * D + 128) >> 8)*1.36f;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//
////data->PIO_CODR = 255;
////data->PIO_SODR = g | f<<4;
//data->PIO_ODSR = g | f<<4;
//
////RESET equal
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_CODR = 1023; //reset output data
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//////RED
////base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
////base->PIO_CODR = 1023; //reset output data
////base->PIO_SODR = buffer[indexes[0][incr++]]*4; //set output data
////base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
////
////data->PIO_CODR = 255;
////data->PIO_SODR = g | i<<4;
//}
//}
//}
//}
/*
base->PIO_SODR = mask;
asm("nop");
asm("nop");
asm("nop");
for(int i = 0; i < 15; ++i){
asm("nop");
}
base->PIO_CODR = mask;
for(int i = 0; i < 15; ++i){
asm("nop");
}
*/
//while (!(UART0->UART_SR & UART_SR_TXRDY));
//pf_uart->UART_THR = 'z';
//while(!(UART0->UART_SR & UART_SR_RXRDY));
//pf_uart->UART_THR = (uint8_t) pf_uart->UART_RHR;
//for(int i = 0; i < 100; ++i){
// array[i] *= 10;
// array[99-i] = i;
// array[i] = array[i]*array[99-i];
//}
//base->PIO_CODR = mask;
//float f = sin(0.5f);
//char a = array[0];
//even = !even;
//++a;
//a = a%100;
//if(even){
//base->PIO_SODR = mask;
//////base->PIO_OER = mask;
//////base->PIO_SODR = mask;
//////base->PIO_SODR = mask;
//asm("nop");
//asm("nop");
//asm("nop");
//asm("nop");
//asm("nop");
//asm("nop");
//asm("nop");
//asm("nop");
//
//
//for(int i = 0; i < 15; ++i){
//asm("nop");
//}
////
//////}
//////else {
//base->PIO_CODR = mask;
//////base->PIO_ODR = mask;
//////base->PIO_CODR = mask;
//////base->PIO_CODR = mask;
//for(int i = 0; i < 15; ++i){
//asm("nop");
//}
//}
//++num;
//num %= 512;
//short C;
//short D;
//short E;
//
//incr = 0;
////256 everywhere + *3!
////green = 225
////max 2ma???
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOB->PIO_CODR = 15;
//PIOB->PIO_SODR = 1;
//C = video_H[indexes[num][incr++]] - 16;
//D = video_H[indexes[num][incr++]] - 128;
//E = video_H[indexes[num][incr++]] - 128;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 409 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C - 100 * D - 208 * E + 128))<<16;
//PIOB->PIO_CODR = 15<<4;
//PIOB->PIO_SODR = 1<<4;
//PIOA->PIO_CODR = 0b1111111111<<16;
//PIOA->PIO_SODR = (205+( 298 * C + 516 * D + 128))<<16;
//PIOA->PIO_CODR = 0b1111111111<<16;
//
//}
}
void PWM_Handler(void)
{
//static uint32_t ul_count = 0; /* PWM counter value */
//static uint32_t ul_duty = 128; /* PWM duty cycle rate */
//static uint8_t fade_in = 1; /* LED fade in flag */
static uchar sin;
uint32_t events = p_pwm->PWM_ISR1;
/* Interrupt on PIN_PWM_LED0_CHANNEL */
if ((events & (1 << 0)) ==
(1 << 0)) {
++sin;
sin %= 16;
p_pwm->PWM_CH_NUM[0].PWM_CDTYUPD = 0; // sine16[sin]; //
//ul_count++;
//
///* Fade in/out */
//if (ul_count == (500000 / (255 - 128))) {
///* Fade in */
//if (fade_in) {
//ul_duty++;
//if (ul_duty == 255) {
//fade_in = 0;
//}
//} else {
///* Fade out */
//ul_duty--;
//if (ul_duty == 128) {
//fade_in = 1;
//}
//}
//
///* Set new duty cycle */
//ul_count = 0;
//p_pwm->PWM_CH_NUM[0].PWM_CDTYUPD = ul_duty;
//}
}
}
void TC0_Handler(void){
(void)(tc_channel->TC_SR);
//static int row = 0;
//static int pixel = 0;
//if(!pixel){
//++row;
//row %= 512;
//}
//
//++pixel;
//pixel %= 240;
//static uint8_t n_pixel = 0;
//++n_pixel;
//if(n_pixel/16 == n_pixel%16)++n_pixel; //invalid bus combinations
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//uint8_t Ydata = hbuf[led_index[row*80+pixel/3] + offset[row*80+pixel/3]];
//int16_t C = Ydata - 16;
//base->PIO_ODSR = ((298*C)>>8)*3.9; //B/W only
//if(row == 10)base->PIO_ODSR = 1023;
//else base->PIO_ODSR = 0;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//data->PIO_ODSR = (n_pixel/16) | (n_pixel%16)<<4;
int16_t result;
static int row = 0;
uint8_t n_pixel = 0;
int last_line;
int curr_line;
for(int i = 0; i < 80; ++i){
int pos = row*80+i;
int lind = led_index[pos];
int32_t Ydata = (hbuf[lind + offset[pos]] - 16)*298;
int16_t Udata = hbuf[lind] - 128;
int16_t Vdata = hbuf[lind+1] - 128;
base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
result = (( Ydata + 409 * Vdata + 128) >> 6);
result = result < 0 ? 0 : result;
result = result > 1023 ? 1023 : result;
base->PIO_ODSR = result;
base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
last_line = n_pixel/16;
++n_pixel;
if(n_pixel/16 == n_pixel%16)++n_pixel; //invalid bus combinations
curr_line = n_pixel/16;
if(last_line != curr_line){ //current change
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
}
data->PIO_ODSR = curr_line | (n_pixel%16)<<4;
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
result = (( Ydata - 100 * Udata - 208 * Vdata + 128) >> 6);
result = result < 0 ? 0 : result;
result = result > 1023 ? 1023 : result;
base->PIO_ODSR = result;
base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
last_line = n_pixel/16;
++n_pixel;
if(n_pixel/16 == n_pixel%16)++n_pixel; //invalid bus combinations
curr_line = n_pixel/16;
if(last_line != curr_line){ //current change
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
}
data->PIO_ODSR = curr_line | (n_pixel%16)<<4;
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
result = (( Ydata + 516 * Udata + 128) >> 6);
result = result < 0 ? 0 : result;
result = result > 1023 ? 1023 : result;
base->PIO_ODSR = result;
base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
last_line = n_pixel/16;
++n_pixel;
if(n_pixel/16 == n_pixel%16)++n_pixel; //invalid bus combinations
curr_line = n_pixel/16;
if(last_line != curr_line){ //current change
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
}
data->PIO_ODSR = curr_line | (n_pixel%16)<<4;
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
__asm("nop");
base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
base->PIO_ODSR = 0; //reset
base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
}
++row;
row %= 512;
//static int row = 0;
//row++;
//row %= 512;
////c = !c;
////
////if(!c){
//// base->PIO_CODR = mask;
////}
////else{
//// base->PIO_SODR = mask;
////}
//base->PIO_CODR = 1U << (ENABLE_H & 0x1F); //enable LED HIGH
//base->PIO_CODR = 1U << (ENABLE_L & 0x1F); //enable LED LOW
//
//incr = 0;
//for(int g = 0; g < 2; ++g){
//char first = 1;
//for(int f = 0; f < 16; ++f){
//
//uint8_t R = row%255;
//uint8_t G = row%255;
//uint8_t B = row%255;
//
//uint8_t Y = ( ( 66 * R + 129 * G + 25 * B + 128) >> 8) + 16;
//uint8_t U = ( ( -38 * R - 74 * G + 112 * B + 128) >> 8) + 128;
//uint8_t V = ( ( 112 * R - 94 * G - 18 * B + 128) >> 8) + 128;
//
//signed int C = Y - 16;
//signed int D = U - 128;
//signed int E = V - 128;
//
//
//
////RED
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_ODSR = (( 298 * C + 409 * E + 128) >> 8)*4;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
////++f;
//if(g == f)++f;
//
//data->PIO_ODSR = g | f<<4;
//
//if(first){
//first = 0;
////wait for the current to swap
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//
//}
//
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//
////GREEN
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_ODSR = (( 298 * C - 100 * D - 208 * E + 128) >> 8)*4;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//
//data->PIO_ODSR = g | f<<4;
//
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//
////BLUE
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_ODSR = (( 298 * C + 516 * D + 128) >> 8)*4;
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//++f;
//if(g == f)++f;
//
//data->PIO_ODSR = g | f<<4;
//
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//__asm("nop");
//
////RESET equal
//base->PIO_CODR = 1U << (D_CS & 0x1F); //set CS to low when loading data
//base->PIO_CODR = 1023; //reset output data
//base->PIO_SODR = 1U << (D_CS & 0x1F); //set CS to high and flush data
//
//}
//}
//
//
//
////base->PIO_SODR = 1U << (ENABLE_H & 0x1F); //disable LED HIGH
////base->PIO_SODR = 1U << (ENABLE_L & 0x1F); //disable LED LOW
//
//
//
}
void UART0_Handler(void)
{
if ((UART0->UART_SR & UART_SR_RXBUFF) == UART_SR_RXBUFF) {
for(int i = 0; i < 200; ++i){
while (!(UART0->UART_SR & UART_SR_TXRDY));
UART0->UART_THR = buffer[i];
}
PDC_UART0->PERIPH_RPR = (uint32_t)buffer;
PDC_UART0->PERIPH_RCR = 200;
}
}
void USART0_Handler(void)
{
if ((USART0->US_CSR & US_CSR_TXBUFE) == US_CSR_TXBUFE) {
PDC_USART0->PERIPH_TPR = (uint32_t)buffer_usart;
PDC_USART0->PERIPH_TCR = 20;
}
}
| 33.634743 | 203 | 0.538119 |
ecb3d7e6e9032853bd19c2910666d6fd273d9746 | 3,769 | h | C | include/tubeComputeTubeFlyThroughImage.h | thewtex/TubeTK | 7536c6c112e1785cead4d008e8fae5ca8f527f20 | [
"Apache-2.0"
] | null | null | null | include/tubeComputeTubeFlyThroughImage.h | thewtex/TubeTK | 7536c6c112e1785cead4d008e8fae5ca8f527f20 | [
"Apache-2.0"
] | null | null | null | include/tubeComputeTubeFlyThroughImage.h | thewtex/TubeTK | 7536c6c112e1785cead4d008e8fae5ca8f527f20 | [
"Apache-2.0"
] | null | null | null | /*=========================================================================
Library: TubeTK
Copyright 2010 Kitware Inc. 28 Corporate Drive,
Clifton Park, NY, 12065, USA.
All rights reserved.
Licensed under the Apache License, Version 2.0 ( the "License" );
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================================================*/
#ifndef __tubeComputeTubeFlyThroughImage_h
#define __tubeComputeTubeFlyThroughImage_h
// ITK includes
#include <itkProcessObject.h>
#include <itkGroupSpatialObject.h>
// TubeTK includes
#include "tubeWrappingMacros.h"
#include "itktubeComputeTubeFlyThroughImageFilter.h"
namespace tube
{
/** \class ComputeTubeFlyThroughImage
*
* \ingroup TubeTK
*/
template< class TPixel, unsigned int Dimension >
class ComputeTubeFlyThroughImage:
public itk::ProcessObject
{
public:
/** Standard class typedefs. */
typedef ComputeTubeFlyThroughImage Self;
typedef itk::ProcessObject Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
typedef itk::tube::ComputeTubeFlyThroughImageFilter< TPixel,
Dimension > FilterType;
typedef typename FilterType::TubeGroupType TubeGroupType;
typedef typename FilterType::TubeType TubeType;
typedef typename FilterType::InputImageType InputImageType;
typedef typename FilterType::OutputImageType OutputImageType;
typedef typename FilterType::OutputMaskType OutputMaskType;
/** Method for creation through the object factory. */
itkNewMacro( Self );
/** Run-time type information ( and related methods ). */
itkTypeMacro( ComputeTubeFlyThroughImage, ProcessObject );
/** Set/Get tube id for which the fly through image is to be generated */
tubeWrapSetMacro( TubeId, unsigned long, Filter );
tubeWrapGetMacro( TubeId, unsigned long, Filter );
/* Set/Get input image from which the tubes were extracted/segmented */
tubeWrapSetConstObjectMacro( InputImage, InputImageType, Filter );
tubeWrapGetConstObjectMacro( InputImage, InputImageType, Filter );
/* Set/Get input tubes */
tubeWrapSetConstObjectMacro( Input, TubeGroupType, Filter );
tubeWrapGetConstObjectMacro( Input, TubeGroupType, Filter );
/* Generates tube fly through image and mask */
tubeWrapUpdateMacro( Filter );
/* Get the generated tube fly through image */
tubeWrapGetObjectMacro( Output, OutputImageType, Filter );
/* Get the generated tube fly through image */
tubeWrapGetObjectMacro( OutputMask, OutputMaskType, Filter );
protected:
ComputeTubeFlyThroughImage( void );
~ComputeTubeFlyThroughImage() {}
void PrintSelf( std::ostream & os, itk::Indent indent ) const override;
private:
/** itkComputeTubeFlyThroughImageFilter parameters **/
ComputeTubeFlyThroughImage( const Self & );
void operator=( const Self & );
// To remove warning "was hidden [-Woverloaded-virtual]"
void SetInput( const DataObjectIdentifierType &, itk::DataObject * ) override
{};
typename FilterType::Pointer m_Filter;
};
} // End namespace tube
#ifndef ITK_MANUAL_INSTANTIATION
#include "tubeComputeTubeFlyThroughImage.hxx"
#endif
#endif // End !defined( __tubeComputeTubeFlyThroughImage_h )
| 32.491379 | 79 | 0.711329 |
aeef8f9be22cc684e7b061d571a6d94e59f64f14 | 11,107 | c | C | edge/co2sensor/firmware/nRF5_SDK_for_Thread_and_Zigbee_v4.1.0_32ce5f8/examples/zigbee/light_control/light_coordinator/main.c | zbennis/hetida4office | 07a6f8969ec7409345c279ec9d7a725593244ffe | [
"MIT"
] | 1 | 2020-11-14T19:19:31.000Z | 2020-11-14T19:19:31.000Z | edge/co2sensor/firmware/nRF5_SDK_for_Thread_and_Zigbee_v4.1.0_32ce5f8/examples/zigbee/light_control/light_coordinator/main.c | zbennis/hetida4office | 07a6f8969ec7409345c279ec9d7a725593244ffe | [
"MIT"
] | null | null | null | edge/co2sensor/firmware/nRF5_SDK_for_Thread_and_Zigbee_v4.1.0_32ce5f8/examples/zigbee/light_control/light_coordinator/main.c | zbennis/hetida4office | 07a6f8969ec7409345c279ec9d7a725593244ffe | [
"MIT"
] | 3 | 2020-11-14T17:21:41.000Z | 2020-11-16T19:23:24.000Z | /**
* Copyright (c) 2018 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/** @file
*
* @defgroup zigbee_examples_light_coordinator main.c
* @{
* @ingroup zigbee_examples
* @brief Simple Zigbee network coordinator implementation.
*/
#include "zboss_api.h"
#include "zb_mem_config_max.h"
#include "zb_error_handler.h"
#include "zigbee_helpers.h"
#include "app_timer.h"
#include "boards.h"
#include "bsp.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#define ERASE_PERSISTENT_CONFIG ZB_FALSE /**< Do not erase NVRAM to save the network parameters after device reboot or power-off. NOTE: If this option is set to ZB_TRUE then do full device erase for all network devices before running other samples. */
#define MAX_CHILDREN 10 /**< The maximum amount of connected devices. Setting this value to 0 disables association to this device. */
#define IEEE_CHANNEL_MASK (1l << ZIGBEE_CHANNEL) /**< Scan only one, predefined channel to find the coordinator. */
#ifdef BOARD_PCA10059 /**< If it is Dongle */
#define ZIGBEE_NETWORK_STATE_LED BSP_BOARD_LED_0 /**< LED indicating that network is opened for new nodes. */
#else
#define ZIGBEE_NETWORK_STATE_LED BSP_BOARD_LED_2 /**< LED indicating that network is opened for new nodes. */
#endif
#define ZIGBEE_NETWORK_REOPEN_BUTTON BSP_BOARD_BUTTON_0 /**< Button which reopens the Zigbee Network. */
#define ZIGBEE_MANUAL_STEERING ZB_FALSE /**< If set to 1 then device will not open the network after forming or reboot. */
#define ZIGBEE_PERMIT_LEGACY_DEVICES ZB_FALSE /**< If set to 1 then legacy devices (pre-Zigbee 3.0) can join the network. */
#ifndef ZB_COORDINATOR_ROLE
#error Define ZB_COORDINATOR_ROLE to compile coordinator source code.
#endif
/**@brief Function for initializing the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
/**@brief Function for the Timer initialization.
*
* @details Initializes the timer module. This creates and starts application timers.
*/
static void timers_init(void)
{
ret_code_t err_code;
// Initialize timer module.
err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
}
/**@brief Callback used in order to visualise network steering period.
*
* @param[in] param Not used. Required by callback type definition.
*/
static zb_void_t steering_finished(zb_uint8_t param)
{
UNUSED_PARAMETER(param);
NRF_LOG_INFO("Network steering finished");
bsp_board_led_off(ZIGBEE_NETWORK_STATE_LED);
}
/**@brief Callback for button events.
*
* @param[in] evt Incoming event from the BSP subsystem.
*/
static void buttons_handler(bsp_event_t evt)
{
zb_bool_t comm_status;
switch(evt)
{
case BSP_EVENT_KEY_0:
UNUSED_RETURN_VALUE(ZB_SCHEDULE_APP_ALARM_CANCEL(steering_finished, ZB_ALARM_ANY_PARAM));
comm_status = bdb_start_top_level_commissioning(ZB_BDB_NETWORK_STEERING);
if (comm_status)
{
NRF_LOG_INFO("Top level comissioning restated");
}
else
{
NRF_LOG_INFO("Top level comissioning hasn't finished yet!");
}
break;
default:
NRF_LOG_INFO("Unhandled BSP Event received: %d", evt);
break;
}
}
/**@brief Function for initializing LEDs and Buttons.
*/
static void leds_buttons_init(void)
{
uint32_t err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, buttons_handler);
APP_ERROR_CHECK(err_code);
/* By default the bsp_init attaches BSP_KEY_EVENTS_{0-4} to the PUSH events of the corresponding buttons. */
bsp_board_leds_off();
}
/**@brief Zigbee stack event handler.
*
* @param[in] bufid Reference to the Zigbee stack buffer used to pass signal.
*/
void zboss_signal_handler(zb_bufid_t bufid)
{
/* Read signal description out of memory buffer. */
zb_zdo_app_signal_hdr_t * p_sg_p = NULL;
zb_zdo_app_signal_type_t sig = zb_get_app_signal(bufid, &p_sg_p);
zb_ret_t status = ZB_GET_APP_SIGNAL_STATUS(bufid);
zb_ret_t zb_err_code;
zb_bool_t comm_status;
zb_time_t timeout_bi;
switch(sig)
{
case ZB_BDB_SIGNAL_DEVICE_REBOOT:
// BDB initialization completed after device reboot, use NVRAM contents during initialization. Device joined/rejoined and started.
if (status == RET_OK)
{
if (ZIGBEE_MANUAL_STEERING == ZB_FALSE)
{
NRF_LOG_INFO("Start network steering");
comm_status = bdb_start_top_level_commissioning(ZB_BDB_NETWORK_STEERING);
ZB_COMM_STATUS_CHECK(comm_status);
}
else
{
NRF_LOG_INFO("Coordinator restarted successfully");
}
}
else
{
NRF_LOG_ERROR("Failed to initialize Zigbee stack using NVRAM data (status: %d)", status);
}
break;
case ZB_BDB_SIGNAL_STEERING:
if (status == RET_OK)
{
if (ZIGBEE_PERMIT_LEGACY_DEVICES == ZB_TRUE)
{
NRF_LOG_INFO("Allow pre-Zigbee 3.0 devices to join the network");
zb_bdb_set_legacy_device_support(1);
}
/* Schedule an alarm to notify about the end of steering period */
NRF_LOG_INFO("Network steering started");
zb_err_code = ZB_SCHEDULE_APP_ALARM(steering_finished, 0, ZB_TIME_ONE_SECOND * ZB_ZGP_DEFAULT_COMMISSIONING_WINDOW);
ZB_ERROR_CHECK(zb_err_code);
}
#ifndef ZB_ED_ROLE
zb_enable_auto_pan_id_conflict_resolution(ZB_FALSE);
#endif
break;
case ZB_ZDO_SIGNAL_DEVICE_ANNCE:
{
zb_zdo_signal_device_annce_params_t * dev_annce_params = ZB_ZDO_SIGNAL_GET_PARAMS(p_sg_p, zb_zdo_signal_device_annce_params_t);
NRF_LOG_INFO("New device commissioned or rejoined (short: 0x%04hx)", dev_annce_params->device_short_addr);
zb_err_code = ZB_SCHEDULE_APP_ALARM_CANCEL(steering_finished, ZB_ALARM_ANY_PARAM);
if (zb_err_code == RET_OK)
{
NRF_LOG_INFO("Joining period extended.");
zb_err_code = ZB_SCHEDULE_APP_ALARM(steering_finished, 0, ZB_TIME_ONE_SECOND * ZB_ZGP_DEFAULT_COMMISSIONING_WINDOW);
ZB_ERROR_CHECK(zb_err_code);
}
}
break;
default:
/* Call default signal handler. */
ZB_ERROR_CHECK(zigbee_default_signal_handler(bufid));
break;
}
/* Update network status LED */
if (ZB_JOINED() && (ZB_SCHEDULE_GET_ALARM_TIME(steering_finished, ZB_ALARM_ANY_PARAM, &timeout_bi) == RET_OK))
{
bsp_board_led_on(ZIGBEE_NETWORK_STATE_LED);
}
else
{
bsp_board_led_off(ZIGBEE_NETWORK_STATE_LED);
}
/* All callbacks should either reuse or free passed buffers. If bufid == 0, the buffer is invalid (not passed) */
if (bufid)
{
zb_buf_free(bufid);
}
}
/**@brief Function for application main entry. */
int main(void)
{
zb_ret_t zb_err_code;
zb_ieee_addr_t ieee_addr;
// Initialize.
timers_init();
log_init();
leds_buttons_init();
/* Set Zigbee stack logging level and traffic dump subsystem. */
ZB_SET_TRACE_LEVEL(ZIGBEE_TRACE_LEVEL);
ZB_SET_TRACE_MASK(ZIGBEE_TRACE_MASK);
ZB_SET_TRAF_DUMP_OFF();
/* Initialize Zigbee stack. */
ZB_INIT("zc");
/* Set device address to the value read from FICR registers. */
zb_osif_get_ieee_eui64(ieee_addr);
zb_set_long_address(ieee_addr);
/* Set channels on which the coordinator will try to create a new network. */
zb_set_network_coordinator_role(IEEE_CHANNEL_MASK);
zb_set_max_children(MAX_CHILDREN);
/* Keep or erase NVRAM to save the network parameters after device reboot or power-off. */
zigbee_erase_persistent_storage(ERASE_PERSISTENT_CONFIG);
/** Start Zigbee Stack. */
zb_err_code = zboss_start_no_autostart();
ZB_ERROR_CHECK(zb_err_code);
while(1)
{
zboss_main_loop_iteration();
UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());
}
}
/**
* @}
*/
| 37.90785 | 291 | 0.641938 |
d80ec37419133017eca5a5b780390e6ce5a83e7c | 683 | h | C | Example/Pods/Headers/Public/SCBasicComponents/SCButton.h | wenkun/SCBasicComponents | 5ebd10bb7a5cf41f2adb1264d3f858a7713514d2 | [
"MIT"
] | null | null | null | Example/Pods/Headers/Public/SCBasicComponents/SCButton.h | wenkun/SCBasicComponents | 5ebd10bb7a5cf41f2adb1264d3f858a7713514d2 | [
"MIT"
] | null | null | null | Example/Pods/Headers/Public/SCBasicComponents/SCButton.h | wenkun/SCBasicComponents | 5ebd10bb7a5cf41f2adb1264d3f858a7713514d2 | [
"MIT"
] | null | null | null | //
// SCButton.h
// IntelligentCommunity
//
// Created by 星星 on 2018/3/1.
// Copyright © 2018年 SmartCare. All rights reserved.
//
#import <UIKit/UIKit.h>
/**
可以对Button内的元素进行自定义的布局，重写布局block，进行自定义布局 例如：
SCButton.titleRectBlock = ^CGRect(CGRect contentRect) {
return CGRectMake(0, 0, titleSize.width, contentRect.size.height);
};
*/
@interface SCButton : UIButton
@property (copy, nonatomic) CGRect (^contentRectBlock)(CGRect bounds);
@property (copy, nonatomic) CGRect (^backgroundRectBlock)(CGRect bounds);
@property (copy, nonatomic) CGRect (^imageRectBlock)(CGRect contentRect);
@property (copy, nonatomic) CGRect (^titleRectBlock)(CGRect contentRect);
@end
| 28.458333 | 74 | 0.7306 |
c1a57480d99a91591e6b6ab4c23bcc53a4e1c9cf | 1,618 | c | C | build/ImageMagick-7.1.0-2/IMDelegates/ghostscript-9.54.0/psi/ztrap.c | roMummy/imagemagick_lib_ios | 0e0e6fa77e06b471f5019d5b1b28caabd08d5e6a | [
"ImageMagick"
] | null | null | null | build/ImageMagick-7.1.0-2/IMDelegates/ghostscript-9.54.0/psi/ztrap.c | roMummy/imagemagick_lib_ios | 0e0e6fa77e06b471f5019d5b1b28caabd08d5e6a | [
"ImageMagick"
] | null | null | null | build/ImageMagick-7.1.0-2/IMDelegates/ghostscript-9.54.0/psi/ztrap.c | roMummy/imagemagick_lib_ios | 0e0e6fa77e06b471f5019d5b1b28caabd08d5e6a | [
"ImageMagick"
] | null | null | null | /* Copyright (C) 2001-2021 Artifex Software, Inc.
All Rights Reserved.
This software is provided AS-IS with no warranty, either express or
implied.
This software is distributed under license and may not be copied,
modified or distributed except as expressly authorized under the terms
of the license contained in the file LICENSE in this distribution.
Refer to licensing information at http://www.artifex.com or contact
Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato,
CA 94945, U.S.A., +1(415)492-9861, for further information.
*/
/* Operators for setting trapping parameters and zones */
#include "ghost.h"
#include "oper.h"
#include "ialloc.h"
#include "iparam.h"
#include "gstrap.h"
/* Define the current trap parameters. */
/****** THIS IS BOGUS ******/
gs_trap_params_t i_trap_params;
/* <dict> .settrapparams - */
static int
zsettrapparams(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
dict_param_list list;
int code;
check_type(*op, t_dictionary);
code = dict_param_list_read(&list, op, NULL, false, iimemory);
if (code < 0)
return code;
code = gs_settrapparams(&i_trap_params, (gs_param_list *) & list);
iparam_list_release(&list);
if (code < 0)
return code;
pop(1);
return 0;
}
/* - settrapzone - */
static int
zsettrapzone(i_ctx_t *i_ctx_p)
{
/****** NYI ******/
return_error(gs_error_undefined);
}
/* ------ Initialization procedure ------ */
const op_def ztrap_op_defs[] =
{
op_def_begin_ll3(),
{"1.settrapparams", zsettrapparams},
{"0settrapzone", zsettrapzone},
op_def_end(0)
};
| 24.892308 | 73 | 0.677379 |
cac7b01bc555a49512f730fe09f9598711010191 | 55,995 | h | C | src/unicode_defs.h | webcoding/gocr | 47bf84cbb41b43039198cb892be887dd3b253388 | [
"MIT"
] | null | null | null | src/unicode_defs.h | webcoding/gocr | 47bf84cbb41b43039198cb892be887dd3b253388 | [
"MIT"
] | null | null | null | src/unicode_defs.h | webcoding/gocr | 47bf84cbb41b43039198cb892be887dd3b253388 | [
"MIT"
] | null | null | null | /*
This is a Optical-Character-Recognition program
Copyright (C) 2000-2010 Joerg Schulenburg
The character codes in this file are Copyright (c) 1991-1999 Unicode, Inc.
All Rights reserved.
This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
No claims are made as to fitness for any particular purpose. No
warranties of any kind are expressed or implied. The recipient
agrees to determine applicability of information provided. If this
file has been provided on optical media by Unicode, Inc., the sole
remedy for any claim will be exchange of defective media within 90
days of receipt.
Unicode, Inc. hereby grants the right to freely use the information
supplied in this file in the creation of products supporting the
Unicode Standard, and to make copies of this file in any form for
internal or external distribution as long as this notice remains
attached.
For the rest of the file, the following applies:
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
see README for EMAIL-address
*/
/*
Only the codes judged necessary by the developers are present in this
file. It conforms with MES-1. You'll find also Greek characters,
mathematical symbols and some extra symbols.
Use the following regular expression to help add new codes from the
Unicode data files: ([\w\s]*);([\w\s]*);[^\n]*
*/
#ifndef G_UNICODE_DEFS_H
#define G_UNICODE_DEFS_H
/*
* Unicode codes
*/
/* E000-F8FF are for private use. We'll reserve E000-E0FF by now. */
/* the next line isnt proper, but was the easiest way to fix a problem */
#ifndef UNKNOWN
#define UNKNOWN 0xE000
#endif
#define PICTURE 0xE001
#define HEADER_FILE 0xE010
/* most codes 0x00-0x1F are not needed, but we provide them anyway. U0000 had
the name changed from NULL to UNICODE_NULL to avoid conflicts. */
#define UNICODE_NULL 0x0000
#define START_OF_HEADING 0x0001
#define START_OF_TEXT 0x0002
#define END_OF_TEXT 0x0003
#define END_OF_TRANSMISSION 0x0004
#define ENQUIRY 0x0005
#define ACKNOWLEDGE 0x0006
#define BELL 0x0007
#define BACKSPACE 0x0008
#define HORIZONTAL_TABULATION 0x0009
#define LINE_FEED 0x000A
#define VERTICAL_TABULATION 0x000B
#define FORM_FEED 0x000C
#define CARRIAGE_RETURN 0x000D
#define SHIFT_OUT 0x000E
#define SHIFT_IN 0x000F
#define DATA_LINK_ESCAPE 0x0010
#define DEVICE_CONTROL_ONE 0x0011
#define DEVICE_CONTROL_TWO 0x0012
#define DEVICE_CONTROL_THREE 0x0013
#define DEVICE_CONTROL_FOUR 0x0014
#define NEGATIVE_ACKNOWLEDGE 0x0015
#define SYNCHRONOUS_IDLE 0x0016
#define END_OF_TRANSMISSION_BLOCK 0x0017
#define CANCEL 0x0018
#define END_OF_MEDIUM 0x0019
#define SUBSTITUTE 0x001A
#define ESCAPE 0x001B
#define FILE_SEPARATOR 0x001C
#define GROUP_SEPARATOR 0x001D
#define RECORD_SEPARATOR 0x001E
#define UNIT_SEPARATOR 0x001F
/* ASCII */
#define SPACE 0x0020
#define EXCLAMATION_MARK 0x0021
#define QUOTATION_MARK 0x0022
#define NUMBER_SIGN 0x0023
#define DOLLAR_SIGN 0x0024
#define PERCENT_SIGN 0x0025
#define AMPERSAND 0x0026
#define APOSTROPHE 0x0027
#define LEFT_PARENTHESIS 0x0028
#define RIGHT_PARENTHESIS 0x0029
#define ASTERISK 0x002A
#define PLUS_SIGN 0x002B
#define COMMA 0x002C
#define HYPHEN_MINUS 0x002D
#define FULL_STOP 0x002E
#define SOLIDUS 0x002F
#define DIGIT_ZERO 0x0030
#define DIGIT_ONE 0x0031
#define DIGIT_TWO 0x0032
#define DIGIT_THREE 0x0033
#define DIGIT_FOUR 0x0034
#define DIGIT_FIVE 0x0035
#define DIGIT_SIX 0x0036
#define DIGIT_SEVEN 0x0037
#define DIGIT_EIGHT 0x0038
#define DIGIT_NINE 0x0039
#define COLON 0x003A
#define SEMICOLON 0x003B
#define LESS_THAN_SIGN 0x003C
#define EQUALS_SIGN 0x003D
#define GREATER_THAN_SIGN 0x003E
#define QUESTION_MARK 0x003F
#define COMMERCIAL_AT 0x0040
#define LATIN_CAPITAL_LETTER_A 0x0041
#define LATIN_CAPITAL_LETTER_B 0x0042
#define LATIN_CAPITAL_LETTER_C 0x0043
#define LATIN_CAPITAL_LETTER_D 0x0044
#define LATIN_CAPITAL_LETTER_E 0x0045
#define LATIN_CAPITAL_LETTER_F 0x0046
#define LATIN_CAPITAL_LETTER_G 0x0047
#define LATIN_CAPITAL_LETTER_H 0x0048
#define LATIN_CAPITAL_LETTER_I 0x0049
#define LATIN_CAPITAL_LETTER_J 0x004A
#define LATIN_CAPITAL_LETTER_K 0x004B
#define LATIN_CAPITAL_LETTER_L 0x004C
#define LATIN_CAPITAL_LETTER_M 0x004D
#define LATIN_CAPITAL_LETTER_N 0x004E
#define LATIN_CAPITAL_LETTER_O 0x004F
#define LATIN_CAPITAL_LETTER_P 0x0050
#define LATIN_CAPITAL_LETTER_Q 0x0051
#define LATIN_CAPITAL_LETTER_R 0x0052
#define LATIN_CAPITAL_LETTER_S 0x0053
#define LATIN_CAPITAL_LETTER_T 0x0054
#define LATIN_CAPITAL_LETTER_U 0x0055
#define LATIN_CAPITAL_LETTER_V 0x0056
#define LATIN_CAPITAL_LETTER_W 0x0057
#define LATIN_CAPITAL_LETTER_X 0x0058
#define LATIN_CAPITAL_LETTER_Y 0x0059
#define LATIN_CAPITAL_LETTER_Z 0x005A
#define LEFT_SQUARE_BRACKET 0x005B
#define REVERSE_SOLIDUS 0x005C
#define RIGHT_SQUARE_BRACKET 0x005D
#define CIRCUMFLEX_ACCENT 0x005E
#define LOW_LINE 0x005F
#define GRAVE_ACCENT 0x0060
#define LATIN_SMALL_LETTER_A 0x0061
#define LATIN_SMALL_LETTER_B 0x0062
#define LATIN_SMALL_LETTER_C 0x0063
#define LATIN_SMALL_LETTER_D 0x0064
#define LATIN_SMALL_LETTER_E 0x0065
#define LATIN_SMALL_LETTER_F 0x0066
#define LATIN_SMALL_LETTER_G 0x0067
#define LATIN_SMALL_LETTER_H 0x0068
#define LATIN_SMALL_LETTER_I 0x0069
#define LATIN_SMALL_LETTER_J 0x006A
#define LATIN_SMALL_LETTER_K 0x006B
#define LATIN_SMALL_LETTER_L 0x006C
#define LATIN_SMALL_LETTER_M 0x006D
#define LATIN_SMALL_LETTER_N 0x006E
#define LATIN_SMALL_LETTER_O 0x006F
#define LATIN_SMALL_LETTER_P 0x0070
#define LATIN_SMALL_LETTER_Q 0x0071
#define LATIN_SMALL_LETTER_R 0x0072
#define LATIN_SMALL_LETTER_S 0x0073
#define LATIN_SMALL_LETTER_T 0x0074
#define LATIN_SMALL_LETTER_U 0x0075
#define LATIN_SMALL_LETTER_V 0x0076
#define LATIN_SMALL_LETTER_W 0x0077
#define LATIN_SMALL_LETTER_X 0x0078
#define LATIN_SMALL_LETTER_Y 0x0079
#define LATIN_SMALL_LETTER_Z 0x007A
#define LEFT_CURLY_BRACKET 0x007B
#define VERTICAL_LINE 0x007C
#define RIGHT_CURLY_BRACKET 0x007D
#define TILDE 0x007E
/* codes 0x7F-0xBF are not needed */
#define NO_BREAK_SPACE 0x00A0
#define INVERTED_EXCLAMATION_MARK 0x00A1
#define CENT_SIGN 0x00A2
#define POUND_SIGN 0x00A3
#define CURRENCY_SIGN 0x00A4
#define YEN_SIGN 0x00A5
#define BROKEN_BAR 0x00A6
#define SECTION_SIGN 0x00A7
#define DIAERESIS 0x00A8
#define COPYRIGHT_SIGN 0x00A9
#define FEMININE_ORDINAL_INDICATOR 0x00AA
#define LEFT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK 0x00AB
#define NOT_SIGN 0x00AC
#define SOFT_HYPHEN 0x00AD
#define REGISTERED_SIGN 0x00AE
#define MACRON 0x00AF
#define DEGREE_SIGN 0x00B0
#define PLUS_MINUS_SIGN 0x00B1
#define SUPERSCRIPT_TWO 0x00B2
#define SUPERSCRIPT_THREE 0x00B3
#define ACUTE_ACCENT 0x00B4
#define MICRO_SIGN 0x00B5
#define PILCROW_SIGN 0x00B6
#define MIDDLE_DOT 0x00B7
#define CEDILLA 0x00B8
#define SUPERSCRIPT_ONE 0x00B9
#define MASCULINE_ORDINAL_INDICATOR 0x00BA
#define RIGHT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK 0x00BB
#define VULGAR_FRACTION_ONE_QUARTER 0x00BC
#define VULGAR_FRACTION_ONE_HALF 0x00BD
#define VULGAR_FRACTION_THREE_QUARTERS 0x00BE
#define INVERTED_QUESTION_MARK 0x00BF
#define LATIN_CAPITAL_LETTER_A_WITH_GRAVE 0x00C0
#define LATIN_CAPITAL_LETTER_A_WITH_ACUTE 0x00C1
#define LATIN_CAPITAL_LETTER_A_WITH_CIRCUMFLEX 0x00C2
#define LATIN_CAPITAL_LETTER_A_WITH_TILDE 0x00C3
#define LATIN_CAPITAL_LETTER_A_WITH_DIAERESIS 0x00C4
#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x00C5
#define LATIN_CAPITAL_LETTER_AE 0x00C6
#define LATIN_CAPITAL_LETTER_C_WITH_CEDILLA 0x00C7
#define LATIN_CAPITAL_LETTER_E_WITH_GRAVE 0x00C8
#define LATIN_CAPITAL_LETTER_E_WITH_ACUTE 0x00C9
#define LATIN_CAPITAL_LETTER_E_WITH_CIRCUMFLEX 0x00CA
#define LATIN_CAPITAL_LETTER_E_WITH_DIAERESIS 0x00CB
#define LATIN_CAPITAL_LETTER_I_WITH_GRAVE 0x00CC
#define LATIN_CAPITAL_LETTER_I_WITH_ACUTE 0x00CD
#define LATIN_CAPITAL_LETTER_I_WITH_CIRCUMFLEX 0x00CE
#define LATIN_CAPITAL_LETTER_I_WITH_DIAERESIS 0x00CF
#define LATIN_CAPITAL_LETTER_ETH 0x00D0
#define LATIN_CAPITAL_LETTER_N_WITH_TILDE 0x00D1
#define LATIN_CAPITAL_LETTER_O_WITH_GRAVE 0x00D2
#define LATIN_CAPITAL_LETTER_O_WITH_ACUTE 0x00D3
#define LATIN_CAPITAL_LETTER_O_WITH_CIRCUMFLEX 0x00D4
#define LATIN_CAPITAL_LETTER_O_WITH_TILDE 0x00D5
#define LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS 0x00D6
#define MULTIPLICATION_SIGN 0x00D7
#define LATIN_CAPITAL_LETTER_O_WITH_STROKE 0x00D8
#define LATIN_CAPITAL_LETTER_U_WITH_GRAVE 0x00D9
#define LATIN_CAPITAL_LETTER_U_WITH_ACUTE 0x00DA
#define LATIN_CAPITAL_LETTER_U_WITH_CIRCUMFLEX 0x00DB
#define LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS 0x00DC
#define LATIN_CAPITAL_LETTER_Y_WITH_ACUTE 0x00DD
#define LATIN_CAPITAL_LETTER_THORN 0x00DE
#define LATIN_SMALL_LETTER_SHARP_S 0x00DF
#define LATIN_SMALL_LETTER_A_WITH_GRAVE 0x00E0
#define LATIN_SMALL_LETTER_A_WITH_ACUTE 0x00E1
#define LATIN_SMALL_LETTER_A_WITH_CIRCUMFLEX 0x00E2
#define LATIN_SMALL_LETTER_A_WITH_TILDE 0x00E3
#define LATIN_SMALL_LETTER_A_WITH_DIAERESIS 0x00E4
#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x00E5
#define LATIN_SMALL_LETTER_AE 0x00E6
#define LATIN_SMALL_LETTER_C_WITH_CEDILLA 0x00E7
#define LATIN_SMALL_LETTER_E_WITH_GRAVE 0x00E8
#define LATIN_SMALL_LETTER_E_WITH_ACUTE 0x00E9
#define LATIN_SMALL_LETTER_E_WITH_CIRCUMFLEX 0x00EA
#define LATIN_SMALL_LETTER_E_WITH_DIAERESIS 0x00EB
#define LATIN_SMALL_LETTER_I_WITH_GRAVE 0x00EC
#define LATIN_SMALL_LETTER_I_WITH_ACUTE 0x00ED
#define LATIN_SMALL_LETTER_I_WITH_CIRCUMFLEX 0x00EE
#define LATIN_SMALL_LETTER_I_WITH_DIAERESIS 0x00EF
#define LATIN_SMALL_LETTER_ETH 0x00F0
#define LATIN_SMALL_LETTER_N_WITH_TILDE 0x00F1
#define LATIN_SMALL_LETTER_O_WITH_GRAVE 0x00F2
#define LATIN_SMALL_LETTER_O_WITH_ACUTE 0x00F3
#define LATIN_SMALL_LETTER_O_WITH_CIRCUMFLEX 0x00F4
#define LATIN_SMALL_LETTER_O_WITH_TILDE 0x00F5
#define LATIN_SMALL_LETTER_O_WITH_DIAERESIS 0x00F6
#define DIVISION_SIGN 0x00F7
#define LATIN_SMALL_LETTER_O_WITH_STROKE 0x00F8
#define LATIN_SMALL_LETTER_U_WITH_GRAVE 0x00F9
#define LATIN_SMALL_LETTER_U_WITH_ACUTE 0x00FA
#define LATIN_SMALL_LETTER_U_WITH_CIRCUMFLEX 0x00FB
#define LATIN_SMALL_LETTER_U_WITH_DIAERESIS 0x00FC
#define LATIN_SMALL_LETTER_Y_WITH_ACUTE 0x00FD
#define LATIN_SMALL_LETTER_THORN 0x00FE
#define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0x00FF
/* latin extended-A */
#define LATIN_CAPITAL_LETTER_A_WITH_MACRON 0x0100
#define LATIN_SMALL_LETTER_A_WITH_MACRON 0x0101
#define LATIN_CAPITAL_LETTER_A_WITH_BREVE 0x0102
#define LATIN_SMALL_LETTER_A_WITH_BREVE 0x0103
#define LATIN_CAPITAL_LETTER_A_WITH_OGONEK 0x0104
#define LATIN_SMALL_LETTER_A_WITH_OGONEK 0x0105
#define LATIN_CAPITAL_LETTER_C_WITH_ACUTE 0x0106
#define LATIN_SMALL_LETTER_C_WITH_ACUTE 0x0107
#define LATIN_CAPITAL_LETTER_C_WITH_CIRCUMFLEX 0x0108
#define LATIN_SMALL_LETTER_C_WITH_CIRCUMFLEX 0x0109
#define LATIN_CAPITAL_LETTER_C_WITH_DOT_ABOVE 0x010A
#define LATIN_SMALL_LETTER_C_WITH_DOT_ABOVE 0x010B
#define LATIN_CAPITAL_LETTER_C_WITH_CARON 0x010C
#define LATIN_SMALL_LETTER_C_WITH_CARON 0x010D
#define LATIN_CAPITAL_LETTER_D_WITH_CARON 0x010E
#define LATIN_SMALL_LETTER_D_WITH_CARON 0x010F
#define LATIN_CAPITAL_LETTER_D_WITH_STROKE 0x0110
#define LATIN_SMALL_LETTER_D_WITH_STROKE 0x0111
#define LATIN_CAPITAL_LETTER_E_WITH_MACRON 0x0112
#define LATIN_SMALL_LETTER_E_WITH_MACRON 0x0113
#define LATIN_CAPITAL_LETTER_E_WITH_BREVE 0x0114
#define LATIN_SMALL_LETTER_E_WITH_BREVE 0x0115
#define LATIN_CAPITAL_LETTER_E_WITH_DOT_ABOVE 0x0116
#define LATIN_SMALL_LETTER_E_WITH_DOT_ABOVE 0x0117
#define LATIN_CAPITAL_LETTER_E_WITH_OGONEK 0x0118
#define LATIN_SMALL_LETTER_E_WITH_OGONEK 0x0119
#define LATIN_CAPITAL_LETTER_E_WITH_CARON 0x011A
#define LATIN_SMALL_LETTER_E_WITH_CARON 0x011B
#define LATIN_CAPITAL_LETTER_G_WITH_CIRCUMFLEX 0x011C
#define LATIN_SMALL_LETTER_G_WITH_CIRCUMFLEX 0x011D
#define LATIN_CAPITAL_LETTER_G_WITH_BREVE 0x011E
#define LATIN_SMALL_LETTER_G_WITH_BREVE 0x011F
#define LATIN_CAPITAL_LETTER_G_WITH_DOT_ABOVE 0x0120
#define LATIN_SMALL_LETTER_G_WITH_DOT_ABOVE 0x0121
#define LATIN_CAPITAL_LETTER_G_WITH_CEDILLA 0x0122
#define LATIN_SMALL_LETTER_G_WITH_CEDILLA 0x0123
#define LATIN_CAPITAL_LETTER_H_WITH_CIRCUMFLEX 0x0124
#define LATIN_SMALL_LETTER_H_WITH_CIRCUMFLEX 0x0125
#define LATIN_CAPITAL_LETTER_H_WITH_STROKE 0x0126
#define LATIN_SMALL_LETTER_H_WITH_STROKE 0x0127
#define LATIN_CAPITAL_LETTER_I_WITH_TILDE 0x0128
#define LATIN_SMALL_LETTER_I_WITH_TILDE 0x0129
#define LATIN_CAPITAL_LETTER_I_WITH_MACRON 0x012A
#define LATIN_SMALL_LETTER_I_WITH_MACRON 0x012B
#define LATIN_CAPITAL_LETTER_I_WITH_BREVE 0x012C
#define LATIN_SMALL_LETTER_I_WITH_BREVE 0x012D
#define LATIN_CAPITAL_LETTER_I_WITH_OGONEK 0x012E
#define LATIN_SMALL_LETTER_I_WITH_OGONEK 0x012F
#define LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE 0x0130
#define LATIN_SMALL_LETTER_DOTLESS_I 0x0131
#define LATIN_CAPITAL_LIGATURE_IJ 0x0132
#define LATIN_SMALL_LIGATURE_IJ 0x0133
#define LATIN_CAPITAL_LETTER_J_WITH_CIRCUMFLEX 0x0134
#define LATIN_SMALL_LETTER_J_WITH_CIRCUMFLEX 0x0135
#define LATIN_CAPITAL_LETTER_K_WITH_CEDILLA 0x0136
#define LATIN_SMALL_LETTER_K_WITH_CEDILLA 0x0137
#define LATIN_SMALL_LETTER_KRA 0x0138
#define LATIN_CAPITAL_LETTER_L_WITH_ACUTE 0x0139
#define LATIN_SMALL_LETTER_L_WITH_ACUTE 0x013A
#define LATIN_CAPITAL_LETTER_L_WITH_CEDILLA 0x013B
#define LATIN_SMALL_LETTER_L_WITH_CEDILLA 0x013C
#define LATIN_CAPITAL_LETTER_L_WITH_CARON 0x013D
#define LATIN_SMALL_LETTER_L_WITH_CARON 0x013E
#define LATIN_CAPITAL_LETTER_L_WITH_MIDDLE_DOT 0x013F
#define LATIN_SMALL_LETTER_L_WITH_MIDDLE_DOT 0x0140
#define LATIN_CAPITAL_LETTER_L_WITH_STROKE 0x0141
#define LATIN_SMALL_LETTER_L_WITH_STROKE 0x0142
#define LATIN_CAPITAL_LETTER_N_WITH_ACUTE 0x0143
#define LATIN_SMALL_LETTER_N_WITH_ACUTE 0x0144
#define LATIN_CAPITAL_LETTER_N_WITH_CEDILLA 0x0145
#define LATIN_SMALL_LETTER_N_WITH_CEDILLA 0x0146
#define LATIN_CAPITAL_LETTER_N_WITH_CARON 0x0147
#define LATIN_SMALL_LETTER_N_WITH_CARON 0x0148
#define LATIN_SMALL_LETTER_N_PRECEDED_BY_APOSTROPHE 0x0149
#define LATIN_CAPITAL_LETTER_ENG 0x014A
#define LATIN_SMALL_LETTER_ENG 0x014B
#define LATIN_CAPITAL_LETTER_O_WITH_MACRON 0x014C
#define LATIN_SMALL_LETTER_O_WITH_MACRON 0x014D
#define LATIN_CAPITAL_LETTER_O_WITH_BREVE 0x014E
#define LATIN_SMALL_LETTER_O_WITH_BREVE 0x014F
#define LATIN_CAPITAL_LETTER_O_WITH_DOUBLE_ACUTE 0x0150
#define LATIN_SMALL_LETTER_O_WITH_DOUBLE_ACUTE 0x0151
#define LATIN_CAPITAL_LIGATURE_OE 0x0152
#define LATIN_SMALL_LIGATURE_OE 0x0153
#define LATIN_CAPITAL_LETTER_R_WITH_ACUTE 0x0154
#define LATIN_SMALL_LETTER_R_WITH_ACUTE 0x0155
#define LATIN_CAPITAL_LETTER_R_WITH_CEDILLA 0x0156
#define LATIN_SMALL_LETTER_R_WITH_CEDILLA 0x0157
#define LATIN_CAPITAL_LETTER_R_WITH_CARON 0x0158
#define LATIN_SMALL_LETTER_R_WITH_CARON 0x0159
#define LATIN_CAPITAL_LETTER_S_WITH_ACUTE 0x015A
#define LATIN_SMALL_LETTER_S_WITH_ACUTE 0x015B
#define LATIN_CAPITAL_LETTER_S_WITH_CIRCUMFLEX 0x015C
#define LATIN_SMALL_LETTER_S_WITH_CIRCUMFLEX 0x015D
#define LATIN_CAPITAL_LETTER_S_WITH_CEDILLA 0x015E
#define LATIN_SMALL_LETTER_S_WITH_CEDILLA 0x015F
#define LATIN_CAPITAL_LETTER_S_WITH_CARON 0x0160
#define LATIN_SMALL_LETTER_S_WITH_CARON 0x0161
#define LATIN_CAPITAL_LETTER_T_WITH_CEDILLA 0x0162
#define LATIN_SMALL_LETTER_T_WITH_CEDILLA 0x0163
#define LATIN_CAPITAL_LETTER_T_WITH_CARON 0x0164
#define LATIN_SMALL_LETTER_T_WITH_CARON 0x0165
#define LATIN_CAPITAL_LETTER_T_WITH_STROKE 0x0166
#define LATIN_SMALL_LETTER_T_WITH_STROKE 0x0167
#define LATIN_CAPITAL_LETTER_U_WITH_TILDE 0x0168
#define LATIN_SMALL_LETTER_U_WITH_TILDE 0x0169
#define LATIN_CAPITAL_LETTER_U_WITH_MACRON 0x016A
#define LATIN_SMALL_LETTER_U_WITH_MACRON 0x016B
#define LATIN_CAPITAL_LETTER_U_WITH_BREVE 0x016C
#define LATIN_SMALL_LETTER_U_WITH_BREVE 0x016D
#define LATIN_CAPITAL_LETTER_U_WITH_RING_ABOVE 0x016E
#define LATIN_SMALL_LETTER_U_WITH_RING_ABOVE 0x016F
#define LATIN_CAPITAL_LETTER_U_WITH_DOUBLE_ACUTE 0x0170
#define LATIN_SMALL_LETTER_U_WITH_DOUBLE_ACUTE 0x0171
#define LATIN_CAPITAL_LETTER_U_WITH_OGONEK 0x0172
#define LATIN_SMALL_LETTER_U_WITH_OGONEK 0x0173
#define LATIN_CAPITAL_LETTER_W_WITH_CIRCUMFLEX 0x0174
#define LATIN_SMALL_LETTER_W_WITH_CIRCUMFLEX 0x0175
#define LATIN_CAPITAL_LETTER_Y_WITH_CIRCUMFLEX 0x0176
#define LATIN_SMALL_LETTER_Y_WITH_CIRCUMFLEX 0x0177
#define LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS 0x0178
#define LATIN_CAPITAL_LETTER_Z_WITH_ACUTE 0x0179
#define LATIN_SMALL_LETTER_Z_WITH_ACUTE 0x017A
#define LATIN_CAPITAL_LETTER_Z_WITH_DOT_ABOVE 0x017B
#define LATIN_SMALL_LETTER_Z_WITH_DOT_ABOVE 0x017C
#define LATIN_CAPITAL_LETTER_Z_WITH_CARON 0x017D
#define LATIN_SMALL_LETTER_Z_WITH_CARON 0x017E
#define LATIN_SMALL_LETTER_LONG_S 0x017F
/* latin extended B */
#define LATIN_SMALL_LETTER_B_WITH_STROKE 0x0180
#define LATIN_CAPITAL_LETTER_B_WITH_HOOK 0x0181
#define LATIN_CAPITAL_LETTER_B_WITH_TOPBAR 0x0182
#define LATIN_SMALL_LETTER_B_WITH_TOPBAR 0x0183
#define LATIN_CAPITAL_LETTER_TONE_SIX 0x0184
#define LATIN_SMALL_LETTER_TONE_SIX 0x0185
#define LATIN_CAPITAL_LETTER_OPEN_O 0x0186
#define LATIN_CAPITAL_LETTER_C_WITH_HOOK 0x0187
#define LATIN_SMALL_LETTER_C_WITH_HOOK 0x0188
#define LATIN_CAPITAL_LETTER_AFRICAN_D 0x0189
#define LATIN_CAPITAL_LETTER_D_WITH_HOOK 0x018A
#define LATIN_CAPITAL_LETTER_D_WITH_TOPBAR 0x018B
#define LATIN_SMALL_LETTER_D_WITH_TOPBAR 0x018C
#define LATIN_SMALL_LETTER_TURNED_DELTA 0x018D
#define LATIN_CAPITAL_LETTER_REVERSED_E 0x018E
#define LATIN_CAPITAL_LETTER_SCHWA 0x018F
#define LATIN_CAPITAL_LETTER_OPEN_E 0x0190
#define LATIN_CAPITAL_LETTER_F_WITH_HOOK 0x0191
#define LATIN_SMALL_LETTER_F_WITH_HOOK 0x0192
#define LATIN_CAPITAL_LETTER_G_WITH_HOOK 0x0193
#define LATIN_CAPITAL_LETTER_GAMMA 0x0194
#define LATIN_SMALL_LETTER_HV 0x0195
#define LATIN_CAPITAL_LETTER_IOTA 0x0196
#define LATIN_CAPITAL_LETTER_I_WITH_STROKE 0x0197
#define LATIN_CAPITAL_LETTER_K_WITH_HOOK 0x0198
#define LATIN_SMALL_LETTER_K_WITH_HOOK 0x0199
#define LATIN_SMALL_LETTER_L_WITH_BAR 0x019A
#define LATIN_SMALL_LETTER_LAMBDA_WITH_STROKE 0x019B
#define LATIN_CAPITAL_LETTER_TURNED_M 0x019C
#define LATIN_CAPITAL_LETTER_N_WITH_LEFT_HOOK 0x019D
#define LATIN_SMALL_LETTER_N_WITH_LONG_RIGHT_LEG 0x019E
#define LATIN_CAPITAL_LETTER_O_WITH_MIDDLE_TILDE 0x019F
#define LATIN_CAPITAL_LETTER_O_WITH_HORN 0x01A0
#define LATIN_SMALL_LETTER_O_WITH_HORN 0x01A1
#define LATIN_CAPITAL_LETTER_OI 0x01A2
#define LATIN_SMALL_LETTER_OI 0x01A3
#define LATIN_CAPITAL_LETTER_P_WITH_HOOK 0x01A4
#define LATIN_SMALL_LETTER_P_WITH_HOOK 0x01A5
#define LATIN_LETTER_YR 0x01A6
#define LATIN_CAPITAL_LETTER_TONE_TWO 0x01A7
#define LATIN_SMALL_LETTER_TONE_TWO 0x01A8
#define LATIN_CAPITAL_LETTER_ESH 0x01A9
#define LATIN_LETTER_REVERSED_ESH_LOOP 0x01AA
#define LATIN_SMALL_LETTER_T_WITH_PALATAL_HOOK 0x01AB
#define LATIN_CAPITAL_LETTER_T_WITH_HOOK 0x01AC
#define LATIN_SMALL_LETTER_T_WITH_HOOK 0x01AD
#define LATIN_CAPITAL_LETTER_T_WITH_RETROFLEX_HOOK 0x01AE
#define LATIN_CAPITAL_LETTER_U_WITH_HORN 0x01AF
#define LATIN_SMALL_LETTER_U_WITH_HORN 0x01B0
#define LATIN_CAPITAL_LETTER_UPSILON 0x01B1
#define LATIN_CAPITAL_LETTER_V_WITH_HOOK 0x01B2
#define LATIN_CAPITAL_LETTER_Y_WITH_HOOK 0x01B3
#define LATIN_SMALL_LETTER_Y_WITH_HOOK 0x01B4
#define LATIN_CAPITAL_LETTER_Z_WITH_STROKE 0x01B5
#define LATIN_SMALL_LETTER_Z_WITH_STROKE 0x01B6
#define LATIN_CAPITAL_LETTER_EZH 0x01B7
#define LATIN_CAPITAL_LETTER_EZH_REVERSED 0x01B8
#define LATIN_SMALL_LETTER_EZH_REVERSED 0x01B9
#define LATIN_SMALL_LETTER_EZH_WITH_TAIL 0x01BA
#define LATIN_LETTER_TWO_WITH_STROKE 0x01BB
#define LATIN_CAPITAL_LETTER_TONE_FIVE 0x01BC
#define LATIN_SMALL_LETTER_TONE_FIVE 0x01BD
#define LATIN_LETTER_INVERTED_GLOTTAL_STOP_WITH_STROKE 0x01BE
#define LATIN_LETTER_WYNN 0x01BF
#define LATIN_LETTER_DENTAL_CLICK 0x01C0
#define LATIN_LETTER_LATERAL_CLICK 0x01C1
#define LATIN_LETTER_ALVEOLAR_CLICK 0x01C2
#define LATIN_LETTER_RETROFLEX_CLICK 0x01C3
#define LATIN_CAPITAL_LETTER_DZ_WITH_CARON 0x01C4
#define LATIN_CAPITAL_LETTER_D_WITH_SMALL_LETTER_Z_WITH_CARON 0x01C5
#define LATIN_SMALL_LETTER_DZ_WITH_CARON 0x01C6
#define LATIN_CAPITAL_LETTER_LJ 0x01C7
#define LATIN_CAPITAL_LETTER_L_WITH_SMALL_LETTER_J 0x01C8
#define LATIN_SMALL_LETTER_LJ 0x01C9
#define LATIN_CAPITAL_LETTER_NJ 0x01CA
#define LATIN_CAPITAL_LETTER_N_WITH_SMALL_LETTER_J 0x01CB
#define LATIN_SMALL_LETTER_NJ 0x01CC
#define LATIN_CAPITAL_LETTER_A_WITH_CARON 0x01CD
#define LATIN_SMALL_LETTER_A_WITH_CARON 0x01CE
#define LATIN_CAPITAL_LETTER_I_WITH_CARON 0x01CF
#define LATIN_SMALL_LETTER_I_WITH_CARON 0x01D0
#define LATIN_CAPITAL_LETTER_O_WITH_CARON 0x01D1
#define LATIN_SMALL_LETTER_O_WITH_CARON 0x01D2
#define LATIN_CAPITAL_LETTER_U_WITH_CARON 0x01D3
#define LATIN_SMALL_LETTER_U_WITH_CARON 0x01D4
#define LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS_AND_MACRON 0x01D5
#define LATIN_SMALL_LETTER_U_WITH_DIAERESIS_AND_MACRON 0x01D6
#define LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS_AND_ACUTE 0x01D7
#define LATIN_SMALL_LETTER_U_WITH_DIAERESIS_AND_ACUTE 0x01D8
#define LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS_AND_CARON 0x01D9
#define LATIN_SMALL_LETTER_U_WITH_DIAERESIS_AND_CARON 0x01DA
#define LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS_AND_GRAVE 0x01DB
#define LATIN_SMALL_LETTER_U_WITH_DIAERESIS_AND_GRAVE 0x01DC
#define LATIN_SMALL_LETTER_TURNED_E 0x01DD
#define LATIN_CAPITAL_LETTER_A_WITH_DIAERESIS_AND_MACRON 0x01DE
#define LATIN_SMALL_LETTER_A_WITH_DIAERESIS_AND_MACRON 0x01DF
#define LATIN_CAPITAL_LETTER_A_WITH_DOT_ABOVE_AND_MACRON 0x01E0
#define LATIN_SMALL_LETTER_A_WITH_DOT_ABOVE_AND_MACRON 0x01E1
#define LATIN_CAPITAL_LETTER_AE_WITH_MACRON 0x01E2
#define LATIN_SMALL_LETTER_AE_WITH_MACRON 0x01E3
#define LATIN_CAPITAL_LETTER_G_WITH_STROKE 0x01E4
#define LATIN_SMALL_LETTER_G_WITH_STROKE 0x01E5
#define LATIN_CAPITAL_LETTER_G_WITH_CARON 0x01E6
#define LATIN_SMALL_LETTER_G_WITH_CARON 0x01E7
#define LATIN_CAPITAL_LETTER_K_WITH_CARON 0x01E8
#define LATIN_SMALL_LETTER_K_WITH_CARON 0x01E9
#define LATIN_CAPITAL_LETTER_O_WITH_OGONEK 0x01EA
#define LATIN_SMALL_LETTER_O_WITH_OGONEK 0x01EB
#define LATIN_CAPITAL_LETTER_O_WITH_OGONEK_AND_MACRON 0x01EC
#define LATIN_SMALL_LETTER_O_WITH_OGONEK_AND_MACRON 0x01ED
#define LATIN_CAPITAL_LETTER_EZH_WITH_CARON 0x01EE
#define LATIN_SMALL_LETTER_EZH_WITH_CARON 0x01EF
#define LATIN_SMALL_LETTER_J_WITH_CARON 0x01F0
#define LATIN_CAPITAL_LETTER_DZ 0x01F1
#define LATIN_CAPITAL_LETTER_D_WITH_SMALL_LETTER_Z 0x01F2
#define LATIN_SMALL_LETTER_DZ 0x01F3
#define LATIN_CAPITAL_LETTER_G_WITH_ACUTE 0x01F4
#define LATIN_SMALL_LETTER_G_WITH_ACUTE 0x01F5
#define LATIN_CAPITAL_LETTER_HWAIR 0x01F6
#define LATIN_CAPITAL_LETTER_WYNN 0x01F7
#define LATIN_CAPITAL_LETTER_N_WITH_GRAVE 0x01F8
#define LATIN_SMALL_LETTER_N_WITH_GRAVE 0x01F9
#define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE_AND_ACUTE 0x01FA
#define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE_AND_ACUTE 0x01FB
#define LATIN_CAPITAL_LETTER_AE_WITH_ACUTE 0x01FC
#define LATIN_SMALL_LETTER_AE_WITH_ACUTE 0x01FD
#define LATIN_CAPITAL_LETTER_O_WITH_STROKE_AND_ACUTE 0x01FE
#define LATIN_SMALL_LETTER_O_WITH_STROKE_AND_ACUTE 0x01FF
#define LATIN_CAPITAL_LETTER_A_WITH_DOUBLE_GRAVE 0x0200
#define LATIN_SMALL_LETTER_A_WITH_DOUBLE_GRAVE 0x0201
#define LATIN_CAPITAL_LETTER_A_WITH_INVERTED_BREVE 0x0202
#define LATIN_SMALL_LETTER_A_WITH_INVERTED_BREVE 0x0203
#define LATIN_CAPITAL_LETTER_E_WITH_DOUBLE_GRAVE 0x0204
#define LATIN_SMALL_LETTER_E_WITH_DOUBLE_GRAVE 0x0205
#define LATIN_CAPITAL_LETTER_E_WITH_INVERTED_BREVE 0x0206
#define LATIN_SMALL_LETTER_E_WITH_INVERTED_BREVE 0x0207
#define LATIN_CAPITAL_LETTER_I_WITH_DOUBLE_GRAVE 0x0208
#define LATIN_SMALL_LETTER_I_WITH_DOUBLE_GRAVE 0x0209
#define LATIN_CAPITAL_LETTER_I_WITH_INVERTED_BREVE 0x020A
#define LATIN_SMALL_LETTER_I_WITH_INVERTED_BREVE 0x020B
#define LATIN_CAPITAL_LETTER_O_WITH_DOUBLE_GRAVE 0x020C
#define LATIN_SMALL_LETTER_O_WITH_DOUBLE_GRAVE 0x020D
#define LATIN_CAPITAL_LETTER_O_WITH_INVERTED_BREVE 0x020E
#define LATIN_SMALL_LETTER_O_WITH_INVERTED_BREVE 0x020F
#define LATIN_CAPITAL_LETTER_R_WITH_DOUBLE_GRAVE 0x0210
#define LATIN_SMALL_LETTER_R_WITH_DOUBLE_GRAVE 0x0211
#define LATIN_CAPITAL_LETTER_R_WITH_INVERTED_BREVE 0x0212
#define LATIN_SMALL_LETTER_R_WITH_INVERTED_BREVE 0x0213
#define LATIN_CAPITAL_LETTER_U_WITH_DOUBLE_GRAVE 0x0214
#define LATIN_SMALL_LETTER_U_WITH_DOUBLE_GRAVE 0x0215
#define LATIN_CAPITAL_LETTER_U_WITH_INVERTED_BREVE 0x0216
#define LATIN_SMALL_LETTER_U_WITH_INVERTED_BREVE 0x0217
#define LATIN_CAPITAL_LETTER_S_WITH_COMMA_BELOW 0x0218
#define LATIN_SMALL_LETTER_S_WITH_COMMA_BELOW 0x0219
#define LATIN_CAPITAL_LETTER_T_WITH_COMMA_BELOW 0x021A
#define LATIN_SMALL_LETTER_T_WITH_COMMA_BELOW 0x021B
#define LATIN_CAPITAL_LETTER_YOGH 0x021C
#define LATIN_SMALL_LETTER_YOGH 0x021D
#define LATIN_CAPITAL_LETTER_H_WITH_CARON 0x021E
#define LATIN_SMALL_LETTER_H_WITH_CARON 0x021F
#define LATIN_CAPITAL_LETTER_OU 0x0222
#define LATIN_SMALL_LETTER_OU 0x0223
#define LATIN_CAPITAL_LETTER_Z_WITH_HOOK 0x0224
#define LATIN_SMALL_LETTER_Z_WITH_HOOK 0x0225
#define LATIN_CAPITAL_LETTER_A_WITH_DOT_ABOVE 0x0226
#define LATIN_SMALL_LETTER_A_WITH_DOT_ABOVE 0x0227
#define LATIN_CAPITAL_LETTER_E_WITH_CEDILLA 0x0228
#define LATIN_SMALL_LETTER_E_WITH_CEDILLA 0x0229
#define LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS_AND_MACRON 0x022A
#define LATIN_SMALL_LETTER_O_WITH_DIAERESIS_AND_MACRON 0x022B
#define LATIN_CAPITAL_LETTER_O_WITH_TILDE_AND_MACRON 0x022C
#define LATIN_SMALL_LETTER_O_WITH_TILDE_AND_MACRON 0x022D
#define LATIN_CAPITAL_LETTER_O_WITH_DOT_ABOVE 0x022E
#define LATIN_SMALL_LETTER_O_WITH_DOT_ABOVE 0x022F
#define LATIN_CAPITAL_LETTER_O_WITH_DOT_ABOVE_AND_MACRON 0x0230
#define LATIN_SMALL_LETTER_O_WITH_DOT_ABOVE_AND_MACRON 0x0231
#define LATIN_CAPITAL_LETTER_Y_WITH_MACRON 0x0232
#define LATIN_SMALL_LETTER_Y_WITH_MACRON 0x0233
/* IPA extensions */
#define LATIN_SMALL_LETTER_TURNED_A 0x0250
#define LATIN_SMALL_LETTER_ALPHA 0x0251
#define LATIN_SMALL_LETTER_TURNED_ALPHA 0x0252
#define LATIN_SMALL_LETTER_B_WITH_HOOK 0x0253
#define LATIN_SMALL_LETTER_OPEN_O 0x0254
#define LATIN_SMALL_LETTER_C_WITH_CURL 0x0255
#define LATIN_SMALL_LETTER_D_WITH_TAIL 0x0256
#define LATIN_SMALL_LETTER_D_WITH_HOOK 0x0257
#define LATIN_SMALL_LETTER_REVERSED_E 0x0258
#define LATIN_SMALL_LETTER_SCHWA 0x0259
#define LATIN_SMALL_LETTER_SCHWA_WITH_HOOK 0x025A
#define LATIN_SMALL_LETTER_OPEN_E 0x025B
#define LATIN_SMALL_LETTER_REVERSED_OPEN_E 0x025C
#define LATIN_SMALL_LETTER_REVERSED_OPEN_E_WITH_HOOK 0x025D
#define LATIN_SMALL_LETTER_CLOSED_REVERSED_OPEN_E 0x025E
#define LATIN_SMALL_LETTER_DOTLESS_J_WITH_STROKE 0x025F
#define LATIN_SMALL_LETTER_G_WITH_HOOK 0x0260
#define LATIN_SMALL_LETTER_SCRIPT_G 0x0261
#define LATIN_LETTER_SMALL_CAPITAL_G 0x0262
#define LATIN_SMALL_LETTER_GAMMA 0x0263
#define LATIN_SMALL_LETTER_RAMS_HORN 0x0264
#define LATIN_SMALL_LETTER_TURNED_H 0x0265
#define LATIN_SMALL_LETTER_H_WITH_HOOK 0x0266
#define LATIN_SMALL_LETTER_HENG_WITH_HOOK 0x0267
#define LATIN_SMALL_LETTER_I_WITH_STROKE 0x0268
#define LATIN_SMALL_LETTER_IOTA 0x0269
#define LATIN_LETTER_SMALL_CAPITAL_I 0x026A
#define LATIN_SMALL_LETTER_L_WITH_MIDDLE_TILDE 0x026B
#define LATIN_SMALL_LETTER_L_WITH_BELT 0x026C
#define LATIN_SMALL_LETTER_L_WITH_RETROFLEX_HOOK 0x026D
#define LATIN_SMALL_LETTER_LEZH 0x026E
#define LATIN_SMALL_LETTER_TURNED_M 0x026F
#define LATIN_SMALL_LETTER_TURNED_M_WITH_LONG_LEG 0x0270
#define LATIN_SMALL_LETTER_M_WITH_HOOK 0x0271
#define LATIN_SMALL_LETTER_N_WITH_LEFT_HOOK 0x0272
#define LATIN_SMALL_LETTER_N_WITH_RETROFLEX_HOOK 0x0273
#define LATIN_LETTER_SMALL_CAPITAL_N 0x0274
#define LATIN_SMALL_LETTER_BARRED_O 0x0275
#define LATIN_LETTER_SMALL_CAPITAL_OE 0x0276
#define LATIN_SMALL_LETTER_CLOSED_OMEGA 0x0277
#define LATIN_SMALL_LETTER_PHI 0x0278
#define LATIN_SMALL_LETTER_TURNED_R 0x0279
#define LATIN_SMALL_LETTER_TURNED_R_WITH_LONG_LEG 0x027A
#define LATIN_SMALL_LETTER_TURNED_R_WITH_HOOK 0x027B
#define LATIN_SMALL_LETTER_R_WITH_LONG_LEG 0x027C
#define LATIN_SMALL_LETTER_R_WITH_TAIL 0x027D
#define LATIN_SMALL_LETTER_R_WITH_FISHHOOK 0x027E
#define LATIN_SMALL_LETTER_REVERSED_R_WITH_FISHHOOK 0x027F
#define LATIN_LETTER_SMALL_CAPITAL_R 0x0280
#define LATIN_LETTER_SMALL_CAPITAL_INVERTED_R 0x0281
#define LATIN_SMALL_LETTER_S_WITH_HOOK 0x0282
#define LATIN_SMALL_LETTER_ESH 0x0283
#define LATIN_SMALL_LETTER_DOTLESS_J_WITH_STROKE_AND_HOOK 0x0284
#define LATIN_SMALL_LETTER_SQUAT_REVERSED_ESH 0x0285
#define LATIN_SMALL_LETTER_ESH_WITH_CURL 0x0286
#define LATIN_SMALL_LETTER_TURNED_T 0x0287
#define LATIN_SMALL_LETTER_T_WITH_RETROFLEX_HOOK 0x0288
#define LATIN_SMALL_LETTER_U_BAR 0x0289
#define LATIN_SMALL_LETTER_UPSILON 0x028A
#define LATIN_SMALL_LETTER_V_WITH_HOOK 0x028B
#define LATIN_SMALL_LETTER_TURNED_V 0x028C
#define LATIN_SMALL_LETTER_TURNED_W 0x028D
#define LATIN_SMALL_LETTER_TURNED_Y 0x028E
#define LATIN_LETTER_SMALL_CAPITAL_Y 0x028F
#define LATIN_SMALL_LETTER_Z_WITH_RETROFLEX_HOOK 0x0290
#define LATIN_SMALL_LETTER_Z_WITH_CURL 0x0291
#define LATIN_SMALL_LETTER_EZH 0x0292
#define LATIN_SMALL_LETTER_EZH_WITH_CURL 0x0293
#define LATIN_LETTER_GLOTTAL_STOP 0x0294
#define LATIN_LETTER_PHARYNGEAL_VOICED_FRICATIVE 0x0295
#define LATIN_LETTER_INVERTED_GLOTTAL_STOP 0x0296
#define LATIN_LETTER_STRETCHED_C 0x0297
#define LATIN_LETTER_BILABIAL_CLICK 0x0298
#define LATIN_LETTER_SMALL_CAPITAL_B 0x0299
#define LATIN_SMALL_LETTER_CLOSED_OPEN_E 0x029A
#define LATIN_LETTER_SMALL_CAPITAL_G_WITH_HOOK 0x029B
#define LATIN_LETTER_SMALL_CAPITAL_H 0x029C
#define LATIN_SMALL_LETTER_J_WITH_CROSSED_TAIL 0x029D
#define LATIN_SMALL_LETTER_TURNED_K 0x029E
#define LATIN_LETTER_SMALL_CAPITAL_L 0x029F
#define LATIN_SMALL_LETTER_Q_WITH_HOOK 0x02A0
#define LATIN_LETTER_GLOTTAL_STOP_WITH_STROKE 0x02A1
#define LATIN_LETTER_REVERSED_GLOTTAL_STOP_WITH_STROKE 0x02A2
#define LATIN_SMALL_LETTER_DZ_DIGRAPH 0x02A3
#define LATIN_SMALL_LETTER_DEZH_DIGRAPH 0x02A4
#define LATIN_SMALL_LETTER_DZ_DIGRAPH_WITH_CURL 0x02A5
#define LATIN_SMALL_LETTER_TS_DIGRAPH 0x02A6
#define LATIN_SMALL_LETTER_TESH_DIGRAPH 0x02A7
#define LATIN_SMALL_LETTER_TC_DIGRAPH_WITH_CURL 0x02A8
#define LATIN_SMALL_LETTER_FENG_DIGRAPH 0x02A9
#define LATIN_SMALL_LETTER_LS_DIGRAPH 0x02AA
#define LATIN_SMALL_LETTER_LZ_DIGRAPH 0x02AB
#define LATIN_LETTER_BILABIAL_PERCUSSIVE 0x02AC
#define LATIN_LETTER_BIDENTAL_PERCUSSIVE 0x02AD
/* spacing modifier letters */
#define MODIFIER_LETTER_SMALL_H 0x02B0
#define MODIFIER_LETTER_SMALL_H_WITH_HOOK 0x02B1
#define MODIFIER_LETTER_SMALL_J 0x02B2
#define MODIFIER_LETTER_SMALL_R 0x02B3
#define MODIFIER_LETTER_SMALL_TURNED_R 0x02B4
#define MODIFIER_LETTER_SMALL_TURNED_R_WITH_HOOK 0x02B5
#define MODIFIER_LETTER_SMALL_CAPITAL_INVERTED_R 0x02B6
#define MODIFIER_LETTER_SMALL_W 0x02B7
#define MODIFIER_LETTER_SMALL_Y 0x02B8
#define MODIFIER_LETTER_PRIME 0x02B9
#define MODIFIER_LETTER_DOUBLE_PRIME 0x02BA
#define MODIFIER_LETTER_TURNED_COMMA 0x02BB
#define MODIFIER_LETTER_APOSTROPHE 0x02BC
#define MODIFIER_LETTER_REVERSED_COMMA 0x02BD
#define MODIFIER_LETTER_RIGHT_HALF_RING 0x02BE
#define MODIFIER_LETTER_LEFT_HALF_RING 0x02BF
#define MODIFIER_LETTER_GLOTTAL_STOP 0x02C0
#define MODIFIER_LETTER_REVERSED_GLOTTAL_STOP 0x02C1
#define MODIFIER_LETTER_LEFT_ARROWHEAD 0x02C2
#define MODIFIER_LETTER_RIGHT_ARROWHEAD 0x02C3
#define MODIFIER_LETTER_UP_ARROWHEAD 0x02C4
#define MODIFIER_LETTER_DOWN_ARROWHEAD 0x02C5
#define MODIFIER_LETTER_CIRCUMFLEX_ACCENT 0x02C6
#define CARON 0x02C7
#define MODIFIER_LETTER_VERTICAL_LINE 0x02C8
#define MODIFIER_LETTER_MACRON 0x02C9
#define MODIFIER_LETTER_ACUTE_ACCENT 0x02CA
#define MODIFIER_LETTER_GRAVE_ACCENT 0x02CB
#define MODIFIER_LETTER_LOW_VERTICAL_LINE 0x02CC
#define MODIFIER_LETTER_LOW_MACRON 0x02CD
#define MODIFIER_LETTER_LOW_GRAVE_ACCENT 0x02CE
#define MODIFIER_LETTER_LOW_ACUTE_ACCENT 0x02CF
#define MODIFIER_LETTER_TRIANGULAR_COLON 0x02D0
#define MODIFIER_LETTER_HALF_TRIANGULAR_COLON 0x02D1
#define MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING 0x02D2
#define MODIFIER_LETTER_CENTRED_LEFT_HALF_RING 0x02D3
#define MODIFIER_LETTER_UP_TACK 0x02D4
#define MODIFIER_LETTER_DOWN_TACK 0x02D5
#define MODIFIER_LETTER_PLUS_SIGN 0x02D6
#define MODIFIER_LETTER_MINUS_SIGN 0x02D7
#define BREVE 0x02D8
#define DOT_ABOVE 0x02D9
#define RING_ABOVE 0x02DA
#define OGONEK 0x02DB
#define SMALL_TILDE 0x02DC
#define DOUBLE_ACUTE_ACCENT 0x02DD
#define MODIFIER_LETTER_RHOTIC_HOOK 0x02DE
#define MODIFIER_LETTER_CROSS_ACCENT 0x02DF
#define MODIFIER_LETTER_SMALL_GAMMA 0x02E0
#define MODIFIER_LETTER_SMALL_L 0x02E1
#define MODIFIER_LETTER_SMALL_S 0x02E2
#define MODIFIER_LETTER_SMALL_X 0x02E3
#define MODIFIER_LETTER_SMALL_REVERSED_GLOTTAL_STOP 0x02E4
#define MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR 0x02E5
#define MODIFIER_LETTER_HIGH_TONE_BAR 0x02E6
#define MODIFIER_LETTER_MID_TONE_BAR 0x02E7
#define MODIFIER_LETTER_LOW_TONE_BAR 0x02E8
#define MODIFIER_LETTER_EXTRA_LOW_TONE_BAR 0x02E9
#define MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK 0x02EA
#define MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK 0x02EB
#define MODIFIER_LETTER_VOICING 0x02EC
#define MODIFIER_LETTER_UNASPIRATED 0x02ED
#define MODIFIER_LETTER_DOUBLE_APOSTROPHE 0x02EE
/* combining diacritical marks */
#define COMBINING_GRAVE_ACCENT 0x0300
#define COMBINING_ACUTE_ACCENT 0x0301
#define COMBINING_CIRCUMFLEX_ACCENT 0x0302
#define COMBINING_TILDE 0x0303
#define COMBINING_MACRON 0x0304
#define COMBINING_OVERLINE 0x0305
#define COMBINING_BREVE 0x0306
#define COMBINING_DOT_ABOVE 0x0307
#define COMBINING_DIAERESIS 0x0308
#define COMBINING_HOOK_ABOVE 0x0309
#define COMBINING_RING_ABOVE 0x030A
#define COMBINING_DOUBLE_ACUTE_ACCENT 0x030B
#define COMBINING_CARON 0x030C
#define COMBINING_VERTICAL_LINE_ABOVE 0x030D
#define COMBINING_DOUBLE_VERTICAL_LINE_ABOVE 0x030E
#define COMBINING_DOUBLE_GRAVE_ACCENT 0x030F
#define COMBINING_CANDRABINDU 0x0310
#define COMBINING_INVERTED_BREVE 0x0311
#define COMBINING_TURNED_COMMA_ABOVE 0x0312
#define COMBINING_COMMA_ABOVE 0x0313
#define COMBINING_REVERSED_COMMA_ABOVE 0x0314
#define COMBINING_COMMA_ABOVE_RIGHT 0x0315
#define COMBINING_GRAVE_ACCENT_BELOW 0x0316
#define COMBINING_ACUTE_ACCENT_BELOW 0x0317
#define COMBINING_LEFT_TACK_BELOW 0x0318
#define COMBINING_RIGHT_TACK_BELOW 0x0319
#define COMBINING_LEFT_ANGLE_ABOVE 0x031A
#define COMBINING_HORN 0x031B
#define COMBINING_LEFT_HALF_RING_BELOW 0x031C
#define COMBINING_UP_TACK_BELOW 0x031D
#define COMBINING_DOWN_TACK_BELOW 0x031E
#define COMBINING_PLUS_SIGN_BELOW 0x031F
#define COMBINING_MINUS_SIGN_BELOW 0x0320
#define COMBINING_PALATALIZED_HOOK_BELOW 0x0321
#define COMBINING_RETROFLEX_HOOK_BELOW 0x0322
#define COMBINING_DOT_BELOW 0x0323
#define COMBINING_DIAERESIS_BELOW 0x0324
#define COMBINING_RING_BELOW 0x0325
#define COMBINING_COMMA_BELOW 0x0326
#define COMBINING_CEDILLA 0x0327
#define COMBINING_OGONEK 0x0328
#define COMBINING_VERTICAL_LINE_BELOW 0x0329
#define COMBINING_BRIDGE_BELOW 0x032A
#define COMBINING_INVERTED_DOUBLE_ARCH_BELOW 0x032B
#define COMBINING_CARON_BELOW 0x032C
#define COMBINING_CIRCUMFLEX_ACCENT_BELOW 0x032D
#define COMBINING_BREVE_BELOW 0x032E
#define COMBINING_INVERTED_BREVE_BELOW 0x032F
#define COMBINING_TILDE_BELOW 0x0330
#define COMBINING_MACRON_BELOW 0x0331
#define COMBINING_LOW_LINE 0x0332
#define COMBINING_DOUBLE_LOW_LINE 0x0333
#define COMBINING_TILDE_OVERLAY 0x0334
#define COMBINING_SHORT_STROKE_OVERLAY 0x0335
#define COMBINING_LONG_STROKE_OVERLAY 0x0336
#define COMBINING_SHORT_SOLIDUS_OVERLAY 0x0337
#define COMBINING_LONG_SOLIDUS_OVERLAY 0x0338
#define COMBINING_RIGHT_HALF_RING_BELOW 0x0339
#define COMBINING_INVERTED_BRIDGE_BELOW 0x033A
#define COMBINING_SQUARE_BELOW 0x033B
#define COMBINING_SEAGULL_BELOW 0x033C
#define COMBINING_X_ABOVE 0x033D
#define COMBINING_VERTICAL_TILDE 0x033E
#define COMBINING_DOUBLE_OVERLINE 0x033F
#define COMBINING_GRAVE_TONE_MARK 0x0340
#define COMBINING_ACUTE_TONE_MARK 0x0341
#define COMBINING_GREEK_PERISPOMENI 0x0342
#define COMBINING_GREEK_KORONIS 0x0343
#define COMBINING_GREEK_DIALYTIKA_TONOS 0x0344
#define COMBINING_GREEK_YPOGEGRAMMENI 0x0345
#define COMBINING_BRIDGE_ABOVE 0x0346
#define COMBINING_EQUALS_SIGN_BELOW 0x0347
#define COMBINING_DOUBLE_VERTICAL_LINE_BELOW 0x0348
#define COMBINING_LEFT_ANGLE_BELOW 0x0349
#define COMBINING_NOT_TILDE_ABOVE 0x034A
#define COMBINING_HOMOTHETIC_ABOVE 0x034B
#define COMBINING_ALMOST_EQUAL_TO_ABOVE 0x034C
#define COMBINING_LEFT_RIGHT_ARROW_BELOW 0x034D
#define COMBINING_UPWARDS_ARROW_BELOW 0x034E
#define COMBINING_DOUBLE_TILDE 0x0360
#define COMBINING_DOUBLE_INVERTED_BREVE 0x0361
#define COMBINING_DOUBLE_RIGHTWARDS_ARROW_BELOW 0x0362
/* greek letters */
#define GREEK_NUMERAL_SIGN 0x0374
#define GREEK_LOWER_NUMERAL_SIGN 0x0375
#define GREEK_YPOGEGRAMMENI 0x037A
#define GREEK_QUESTION_MARK 0x037E
#define GREEK_TONOS 0x0384
#define GREEK_DIALYTIKA_TONOS 0x0385
#define GREEK_CAPITAL_LETTER_ALPHA_WITH_TONOS 0x0386
#define GREEK_ANO_TELEIA 0x0387
#define GREEK_CAPITAL_LETTER_EPSILON_WITH_TONOS 0x0388
#define GREEK_CAPITAL_LETTER_ETA_WITH_TONOS 0x0389
#define GREEK_CAPITAL_LETTER_IOTA_WITH_TONOS 0x038A
#define GREEK_CAPITAL_LETTER_OMICRON_WITH_TONOS 0x038C
#define GREEK_CAPITAL_LETTER_UPSILON_WITH_TONOS 0x038E
#define GREEK_CAPITAL_LETTER_OMEGA_WITH_TONOS 0x038F
#define GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA_AND_TONOS 0x0390
#define GREEK_CAPITAL_LETTER_ALPHA 0x0391
#define GREEK_CAPITAL_LETTER_BETA 0x0392
#define GREEK_CAPITAL_LETTER_GAMMA 0x0393
#define GREEK_CAPITAL_LETTER_DELTA 0x0394
#define GREEK_CAPITAL_LETTER_EPSILON 0x0395
#define GREEK_CAPITAL_LETTER_ZETA 0x0396
#define GREEK_CAPITAL_LETTER_ETA 0x0397
#define GREEK_CAPITAL_LETTER_THETA 0x0398
#define GREEK_CAPITAL_LETTER_IOTA 0x0399
#define GREEK_CAPITAL_LETTER_KAPPA 0x039A
#define GREEK_CAPITAL_LETTER_LAMDA 0x039B
#define GREEK_CAPITAL_LETTER_MU 0x039C
#define GREEK_CAPITAL_LETTER_NU 0x039D
#define GREEK_CAPITAL_LETTER_XI 0x039E
#define GREEK_CAPITAL_LETTER_OMICRON 0x039F
#define GREEK_CAPITAL_LETTER_PI 0x03A0
#define GREEK_CAPITAL_LETTER_RHO 0x03A1
#define GREEK_CAPITAL_LETTER_SIGMA 0x03A3
#define GREEK_CAPITAL_LETTER_TAU 0x03A4
#define GREEK_CAPITAL_LETTER_UPSILON 0x03A5
#define GREEK_CAPITAL_LETTER_PHI 0x03A6
#define GREEK_CAPITAL_LETTER_CHI 0x03A7
#define GREEK_CAPITAL_LETTER_PSI 0x03A8
#define GREEK_CAPITAL_LETTER_OMEGA 0x03A9
#define GREEK_CAPITAL_LETTER_IOTA_WITH_DIALYTIKA 0x03AA
#define GREEK_CAPITAL_LETTER_UPSILON_WITH_DIALYTIKA 0x03AB
#define GREEK_SMALL_LETTER_ALPHA_WITH_TONOS 0x03AC
#define GREEK_SMALL_LETTER_EPSILON_WITH_TONOS 0x03AD
#define GREEK_SMALL_LETTER_ETA_WITH_TONOS 0x03AE
#define GREEK_SMALL_LETTER_IOTA_WITH_TONOS 0x03AF
#define GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS 0x03B0
#define GREEK_SMALL_LETTER_ALPHA 0x03B1
#define GREEK_SMALL_LETTER_BETA 0x03B2
#define GREEK_SMALL_LETTER_GAMMA 0x03B3
#define GREEK_SMALL_LETTER_DELTA 0x03B4
#define GREEK_SMALL_LETTER_EPSILON 0x03B5
#define GREEK_SMALL_LETTER_ZETA 0x03B6
#define GREEK_SMALL_LETTER_ETA 0x03B7
#define GREEK_SMALL_LETTER_THETA 0x03B8
#define GREEK_SMALL_LETTER_IOTA 0x03B9
#define GREEK_SMALL_LETTER_KAPPA 0x03BA
#define GREEK_SMALL_LETTER_LAMDA 0x03BB
#define GREEK_SMALL_LETTER_MU 0x03BC
#define GREEK_SMALL_LETTER_NU 0x03BD
#define GREEK_SMALL_LETTER_XI 0x03BE
#define GREEK_SMALL_LETTER_OMICRON 0x03BF
#define GREEK_SMALL_LETTER_PI 0x03C0
#define GREEK_SMALL_LETTER_RHO 0x03C1
#define GREEK_SMALL_LETTER_FINAL_SIGMA 0x03C2
#define GREEK_SMALL_LETTER_SIGMA 0x03C3
#define GREEK_SMALL_LETTER_TAU 0x03C4
#define GREEK_SMALL_LETTER_UPSILON 0x03C5
#define GREEK_SMALL_LETTER_PHI 0x03C6
#define GREEK_SMALL_LETTER_CHI 0x03C7
#define GREEK_SMALL_LETTER_PSI 0x03C8
#define GREEK_SMALL_LETTER_OMEGA 0x03C9
#define GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA 0x03CA
#define GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA 0x03CB
#define GREEK_SMALL_LETTER_OMICRON_WITH_TONOS 0x03CC
#define GREEK_SMALL_LETTER_UPSILON_WITH_TONOS 0x03CD
#define GREEK_SMALL_LETTER_OMEGA_WITH_TONOS 0x03CE
#define GREEK_BETA_SYMBOL 0x03D0
#define GREEK_THETA_SYMBOL 0x03D1
#define GREEK_UPSILON_WITH_HOOK_SYMBOL 0x03D2
#define GREEK_UPSILON_WITH_ACUTE_AND_HOOK_SYMBOL 0x03D3
#define GREEK_UPSILON_WITH_DIAERESIS_AND_HOOK_SYMBOL 0x03D4
#define GREEK_PHI_SYMBOL 0x03D5
#define GREEK_PI_SYMBOL 0x03D6
#define GREEK_KAI_SYMBOL 0x03D7
#define GREEK_LETTER_STIGMA 0x03DA
#define GREEK_SMALL_LETTER_STIGMA 0x03DB
#define GREEK_LETTER_DIGAMMA 0x03DC
#define GREEK_SMALL_LETTER_DIGAMMA 0x03DD
#define GREEK_LETTER_KOPPA 0x03DE
#define GREEK_SMALL_LETTER_KOPPA 0x03DF
#define GREEK_LETTER_SAMPI 0x03E0
#define GREEK_SMALL_LETTER_SAMPI 0x03E1
/* general punctuation (partial) */
#define HYPHEN 0x2010
#define NON_BREAKING_HYPHEN 0x2011
#define FIGURE_DASH 0x2012
#define EN_DASH 0x2013
#define EM_DASH 0x2014
#define HORIZONTAL_BAR 0x2015
#define LEFT_SINGLE_QUOTATION_MARK 0x2018
#define RIGHT_SINGLE_QUOTATION_MARK 0x2019
#define SINGLE_LOW_9_QUOTATION_MARK 0x201A
#define SINGLE_HIGH_REVERSED_9_QUOTATION_MARK 0x201B
#define LEFT_DOUBLE_QUOTATION_MARK 0x201C
#define RIGHT_DOUBLE_QUOTATION_MARK 0x201D
#define DOUBLE_LOW_9_QUOTATION_MARK 0x201E
#define DOUBLE_HIGH_REVERSED_9_QUOTATION_MARK 0x201F
#define DAGGER 0x2020
#define DOUBLE_DAGGER 0x2021
#define BULLET 0x2022
#define TRIANGULAR_BULLET 0x2023
#define HYPHENATION_POINT 0x2027
#define HORIZONTAL_ELLIPSIS 0x2026
#define PER_MILLE_SIGN 0x2030
#define SINGLE_LEFT_POINTING_ANGLE_QUOTATION_MARK 0x2039
#define SINGLE_RIGHT_POINTING_ANGLE_QUOTATION_MARK 0x203A
#define EURO_CURRENCY_SIGN 0x20AC
/* mathematical operators */
#define FOR_ALL 0x2200
#define COMPLEMENT 0x2201
#define PARTIAL_DIFFERENTIAL 0x2202
#define THERE_EXISTS 0x2203
#define THERE_DOES_NOT_EXIST 0x2204
#define EMPTY_SET 0x2205
#define INCREMENT 0x2206
#define NABLA 0x2207
#define ELEMENT_OF 0x2208
#define NOT_AN_ELEMENT_OF 0x2209
#define SMALL_ELEMENT_OF 0x220A
#define CONTAINS_AS_MEMBER 0x220B
#define DOES_NOT_CONTAIN_AS_MEMBER 0x220C
#define SMALL_CONTAINS_AS_MEMBER 0x220D
#define END_OF_PROOF 0x220E
#define N_ARY_PRODUCT 0x220F
#define N_ARY_COPRODUCT 0x2210
#define N_ARY_SUMMATION 0x2211
#define MINUS_SIGN 0x2212
#define MINUS_OR_PLUS_SIGN 0x2213
#define DOT_PLUS 0x2214
#define DIVISION_SLASH 0x2215
#define SET_MINUS 0x2216
#define ASTERISK_OPERATOR 0x2217
#define RING_OPERATOR 0x2218
#define BULLET_OPERATOR 0x2219
#define SQUARE_ROOT 0x221A
#define CUBE_ROOT 0x221B
#define FOURTH_ROOT 0x221C
#define PROPORTIONAL_TO 0x221D
/* INFINITY conflicts with math.h */
#define UNICODE_INFINITY 0x221E
#define RIGHT_ANGLE 0x221F
#define ANGLE 0x2220
#define MEASURED_ANGLE 0x2221
#define SPHERICAL_ANGLE 0x2222
#define DIVIDES 0x2223
#define DOES_NOT_DIVIDE 0x2224
#define PARALLEL_TO 0x2225
#define NOT_PARALLEL_TO 0x2226
#define LOGICAL_AND 0x2227
#define LOGICAL_OR 0x2228
#define INTERSECTION 0x2229
#define UNION 0x222A
#define INTEGRAL 0x222B
#define DOUBLE_INTEGRAL 0x222C
#define TRIPLE_INTEGRAL 0x222D
#define CONTOUR_INTEGRAL 0x222E
#define SURFACE_INTEGRAL 0x222F
#define VOLUME_INTEGRAL 0x2230
#define CLOCKWISE_INTEGRAL 0x2231
#define CLOCKWISE_CONTOUR_INTEGRAL 0x2232
#define ANTICLOCKWISE_CONTOUR_INTEGRAL 0x2233
#define THEREFORE 0x2234
#define BECAUSE 0x2235
#define RATIO 0x2236
#define PROPORTION 0x2237
#define DOT_MINUS 0x2238
#define EXCESS 0x2239
#define GEOMETRIC_PROPORTION 0x223A
#define HOMOTHETIC 0x223B
#define TILDE_OPERATOR 0x223C
#define REVERSED_TILDE 0x223D
#define INVERTED_LAZY_S 0x223E
#define SINE_WAVE 0x223F
#define WREATH_PRODUCT 0x2240
#define NOT_TILDE 0x2241
#define MINUS_TILDE 0x2242
#define ASYMPTOTICALLY_EQUAL_TO 0x2243
#define NOT_ASYMPTOTICALLY_EQUAL_TO 0x2244
#define APPROXIMATELY_EQUAL_TO 0x2245
#define APPROXIMATELY_BUT_NOT_ACTUALLY_EQUAL_TO 0x2246
#define NEITHER_APPROXIMATELY_NOR_ACTUALLY_EQUAL_TO 0x2247
#define ALMOST_EQUAL_TO 0x2248
#define NOT_ALMOST_EQUAL_TO 0x2249
#define ALMOST_EQUAL_OR_EQUAL_TO 0x224A
#define TRIPLE_TILDE 0x224B
#define ALL_EQUAL_TO 0x224C
#define EQUIVALENT_TO 0x224D
#define GEOMETRICALLY_EQUIVALENT_TO 0x224E
#define DIFFERENCE_BETWEEN 0x224F
#define APPROACHES_THE_LIMIT 0x2250
#define GEOMETRICALLY_EQUAL_TO 0x2251
#define APPROXIMATELY_EQUAL_TO_OR_THE_IMAGE_OF 0x2252
#define IMAGE_OF_OR_APPROXIMATELY_EQUAL_TO 0x2253
#define COLON_EQUALS 0x2254
#define EQUALS_COLON 0x2255
#define RING_IN_EQUAL_TO 0x2256
#define RING_EQUAL_TO 0x2257
#define CORRESPONDS_TO 0x2258
#define ESTIMATES 0x2259
#define EQUIANGULAR_TO 0x225A
#define STAR_EQUALS 0x225B
#define DELTA_EQUAL_TO 0x225C
#define EQUAL_TO_BY_DEFINITION 0x225D
#define MEASURED_BY 0x225E
#define QUESTIONED_EQUAL_TO 0x225F
#define NOT_EQUAL_TO 0x2260
#define IDENTICAL_TO 0x2261
#define NOT_IDENTICAL_TO 0x2262
#define STRICTLY_EQUIVALENT_TO 0x2263
#define LESS_THAN_OR_EQUAL_TO 0x2264
#define GREATER_THAN_OR_EQUAL_TO 0x2265
#define LESS_THAN_OVER_EQUAL_TO 0x2266
#define GREATER_THAN_OVER_EQUAL_TO 0x2267
#define LESS_THAN_BUT_NOT_EQUAL_TO 0x2268
#define GREATER_THAN_BUT_NOT_EQUAL_TO 0x2269
#define MUCH_LESS_THAN 0x226A
#define MUCH_GREATER_THAN 0x226B
#define BETWEEN 0x226C
#define NOT_EQUIVALENT_TO 0x226D
#define NOT_LESS_THAN 0x226E
#define NOT_GREATER_THAN 0x226F
#define NEITHER_LESS_THAN_NOR_EQUAL_TO 0x2270
#define NEITHER_GREATER_THAN_NOR_EQUAL_TO 0x2271
#define LESS_THAN_OR_EQUIVALENT_TO 0x2272
#define GREATER_THAN_OR_EQUIVALENT_TO 0x2273
#define NEITHER_LESS_THAN_NOR_EQUIVALENT_TO 0x2274
#define NEITHER_GREATER_THAN_NOR_EQUIVALENT_TO 0x2275
#define LESS_THAN_OR_GREATER_THAN 0x2276
#define GREATER_THAN_OR_LESS_THAN 0x2277
#define NEITHER_LESS_THAN_NOR_GREATER_THAN 0x2278
#define NEITHER_GREATER_THAN_NOR_LESS_THAN 0x2279
#define PRECEDES 0x227A
#define SUCCEEDS 0x227B
#define PRECEDES_OR_EQUAL_TO 0x227C
#define SUCCEEDS_OR_EQUAL_TO 0x227D
#define PRECEDES_OR_EQUIVALENT_TO 0x227E
#define SUCCEEDS_OR_EQUIVALENT_TO 0x227F
#define DOES_NOT_PRECEDE 0x2280
#define DOES_NOT_SUCCEED 0x2281
#define SUBSET_OF 0x2282
#define SUPERSET_OF 0x2283
#define NOT_A_SUBSET_OF 0x2284
#define NOT_A_SUPERSET_OF 0x2285
#define SUBSET_OF_OR_EQUAL_TO 0x2286
#define SUPERSET_OF_OR_EQUAL_TO 0x2287
#define NEITHER_A_SUBSET_OF_NOR_EQUAL_TO 0x2288
#define NEITHER_A_SUPERSET_OF_NOR_EQUAL_TO 0x2289
#define SUBSET_OF_WITH_NOT_EQUAL_TO 0x228A
#define SUPERSET_OF_WITH_NOT_EQUAL_TO 0x228B
#define MULTISET 0x228C
#define MULTISET_MULTIPLICATION 0x228D
#define MULTISET_UNION 0x228E
#define SQUARE_IMAGE_OF 0x228F
#define SQUARE_ORIGINAL_OF 0x2290
#define SQUARE_IMAGE_OF_OR_EQUAL_TO 0x2291
#define SQUARE_ORIGINAL_OF_OR_EQUAL_TO 0x2292
#define SQUARE_CAP 0x2293
#define SQUARE_CUP 0x2294
#define CIRCLED_PLUS 0x2295
#define CIRCLED_MINUS 0x2296
#define CIRCLED_TIMES 0x2297
#define CIRCLED_DIVISION_SLASH 0x2298
#define CIRCLED_DOT_OPERATOR 0x2299
#define CIRCLED_RING_OPERATOR 0x229A
#define CIRCLED_ASTERISK_OPERATOR 0x229B
#define CIRCLED_EQUALS 0x229C
#define CIRCLED_DASH 0x229D
#define SQUARED_PLUS 0x229E
#define SQUARED_MINUS 0x229F
#define SQUARED_TIMES 0x22A0
#define SQUARED_DOT_OPERATOR 0x22A1
#define RIGHT_TACK 0x22A2
#define LEFT_TACK 0x22A3
#define DOWN_TACK 0x22A4
#define UP_TACK 0x22A5
#define ASSERTION 0x22A6
#define MODELS 0x22A7
/* TRUE conflicts with gcc/alphaev7-dec-osf5.1/3.4.3/include/stdlib.h */
#define UNICODE_TRUE 0x22A8
#define FORCES 0x22A9
#define TRIPLE_VERTICAL_BAR_RIGHT_TURNSTILE 0x22AA
#define DOUBLE_VERTICAL_BAR_DOUBLE_RIGHT_TURNSTILE 0x22AB
#define DOES_NOT_PROVE 0x22AC
#define NOT_TRUE 0x22AD
#define DOES_NOT_FORCE 0x22AE
#define NEGATED_DOUBLE_VERTICAL_BAR_DOUBLE_RIGHT_TURNSTILE 0x22AF
#define PRECEDES_UNDER_RELATION 0x22B0
#define SUCCEEDS_UNDER_RELATION 0x22B1
#define NORMAL_SUBGROUP_OF 0x22B2
#define CONTAINS_AS_NORMAL_SUBGROUP 0x22B3
#define NORMAL_SUBGROUP_OF_OR_EQUAL_TO 0x22B4
#define CONTAINS_AS_NORMAL_SUBGROUP_OR_EQUAL_TO 0x22B5
#define ORIGINAL_OF 0x22B6
#define IMAGE_OF 0x22B7
#define MULTIMAP 0x22B8
#define HERMITIAN_CONJUGATE_MATRIX 0x22B9
#define INTERCALATE 0x22BA
#define XOR 0x22BB
#define NAND 0x22BC
#define NOR 0x22BD
#define RIGHT_ANGLE_WITH_ARC 0x22BE
#define RIGHT_TRIANGLE 0x22BF
#define N_ARY_LOGICAL_AND 0x22C0
#define N_ARY_LOGICAL_OR 0x22C1
#define N_ARY_INTERSECTION 0x22C2
#define N_ARY_UNION 0x22C3
#define DIAMOND_OPERATOR 0x22C4
#define DOT_OPERATOR 0x22C5
#define STAR_OPERATOR 0x22C6
#define DIVISION_TIMES 0x22C7
#define BOWTIE 0x22C8
#define LEFT_NORMAL_FACTOR_SEMIDIRECT_PRODUCT 0x22C9
#define RIGHT_NORMAL_FACTOR_SEMIDIRECT_PRODUCT 0x22CA
#define LEFT_SEMIDIRECT_PRODUCT 0x22CB
#define RIGHT_SEMIDIRECT_PRODUCT 0x22CC
#define REVERSED_TILDE_EQUALS 0x22CD
#define CURLY_LOGICAL_OR 0x22CE
#define CURLY_LOGICAL_AND 0x22CF
#define DOUBLE_SUBSET 0x22D0
#define DOUBLE_SUPERSET 0x22D1
#define DOUBLE_INTERSECTION 0x22D2
#define DOUBLE_UNION 0x22D3
#define PITCHFORK 0x22D4
#define EQUAL_AND_PARALLEL_TO 0x22D5
#define LESS_THAN_WITH_DOT 0x22D6
#define GREATER_THAN_WITH_DOT 0x22D7
#define VERY_MUCH_LESS_THAN 0x22D8
#define VERY_MUCH_GREATER_THAN 0x22D9
#define LESS_THAN_EQUAL_TO_OR_GREATER_THAN 0x22DA
#define GREATER_THAN_EQUAL_TO_OR_LESS_THAN 0x22DB
#define EQUAL_TO_OR_LESS_THAN 0x22DC
#define EQUAL_TO_OR_GREATER_THAN 0x22DD
#define EQUAL_TO_OR_PRECEDES 0x22DE
#define EQUAL_TO_OR_SUCCEEDS 0x22DF
#define DOES_NOT_PRECEDE_OR_EQUAL 0x22E0
#define DOES_NOT_SUCCEED_OR_EQUAL 0x22E1
#define NOT_SQUARE_IMAGE_OF_OR_EQUAL_TO 0x22E2
#define NOT_SQUARE_ORIGINAL_OF_OR_EQUAL_TO 0x22E3
#define SQUARE_IMAGE_OF_OR_NOT_EQUAL_TO 0x22E4
#define SQUARE_ORIGINAL_OF_OR_NOT_EQUAL_TO 0x22E5
#define LESS_THAN_BUT_NOT_EQUIVALENT_TO 0x22E6
#define GREATER_THAN_BUT_NOT_EQUIVALENT_TO 0x22E7
#define PRECEDES_BUT_NOT_EQUIVALENT_TO 0x22E8
#define SUCCEEDS_BUT_NOT_EQUIVALENT_TO 0x22E9
#define NOT_NORMAL_SUBGROUP_OF 0x22EA
#define DOES_NOT_CONTAIN_AS_NORMAL_SUBGROUP 0x22EB
#define NOT_NORMAL_SUBGROUP_OF_OR_EQUAL_TO 0x22EC
#define DOES_NOT_CONTAIN_AS_NORMAL_SUBGROUP_OR_EQUAL 0x22ED
#define VERTICAL_ELLIPSIS 0x22EE
#define MIDLINE_HORIZONTAL_ELLIPSIS 0x22EF
#define UP_RIGHT_DIAGONAL_ELLIPSIS 0x22F0
#define DOWN_RIGHT_DIAGONAL_ELLIPSIS 0x22F1
/* Optical Character Recognition in Unicode (see wikipedia/OCR)
* range: 0x2440-0x245F
*/
#define OCR_Hook 0x2440
#define OCR_Chair 0x2441
#define OCR_Fork 0x2442
#define OCR_Inverted_Fork 0x2443
#define OCR_Belt_Buckle 0x2444
#define OCR_Bow_Tie 0x2445
/* the following 4 MICR chars (magnetic ink character recognition)
* They look like: |: ,|' ||' ||| (known also as MICR-A,B,C,D)
*/
#define OCR_Branch_Bank_Identification 0x2446
#define OCR_Amount_Of_Check 0x2447
#define OCR_Customer_Account_Number 0x2448
#define OCR_Dash 0x2449
#define OCR_Double_Backslash 0x244A
/* latin ligatures */
#define LATIN_SMALL_LIGATURE_FF 0xFB00
#define LATIN_SMALL_LIGATURE_FI 0xFB01
#define LATIN_SMALL_LIGATURE_FL 0xFB02
#define LATIN_SMALL_LIGATURE_FFI 0xFB03
#define LATIN_SMALL_LIGATURE_FFL 0xFB04
#define LATIN_SMALL_LIGATURE_LONG_S_T 0xFB05
#define LATIN_SMALL_LIGATURE_ST 0xFB06
#endif
| 44.939807 | 78 | 0.811501 |
6cd88fa5fdc2a48f8f1a416fe268a2bb6375f4fe | 853 | h | C | demo/stm32g030c8/pikascript/pikascript-api/PikaStdDevice_UART.h | oblonka/pikascript | 3e3c80c754515c1cf8acf08e85d5ca0c0cc49ca3 | [
"MIT"
] | 1 | 2021-09-23T16:54:35.000Z | 2021-09-23T16:54:35.000Z | demo/stm32g070cb/pikascript/pikascript-api/PikaStdDevice_UART.h | oblonka/pikascript | 3e3c80c754515c1cf8acf08e85d5ca0c0cc49ca3 | [
"MIT"
] | null | null | null | demo/stm32g070cb/pikascript/pikascript-api/PikaStdDevice_UART.h | oblonka/pikascript | 3e3c80c754515c1cf8acf08e85d5ca0c0cc49ca3 | [
"MIT"
] | null | null | null | /* ******************************** */
/* Warning! Don't modify this file! */
/* ******************************** */
#ifndef __PikaStdDevice_UART__H
#define __PikaStdDevice_UART__H
#include <stdio.h>
#include <stdlib.h>
#include "PikaObj.h"
PikaObj *New_PikaStdDevice_UART(Args *args);
void PikaStdDevice_UART_enable(PikaObj *self);
void PikaStdDevice_UART_init(PikaObj *self);
void PikaStdDevice_UART_platformEnable(PikaObj *self, int baudRate, int id);
char * PikaStdDevice_UART_platformRead(PikaObj *self, int id, int length);
void PikaStdDevice_UART_platformWrite(PikaObj *self, char * data, int id);
char * PikaStdDevice_UART_read(PikaObj *self, int length);
void PikaStdDevice_UART_setBaudRate(PikaObj *self, int baudRate);
void PikaStdDevice_UART_setId(PikaObj *self, int id);
void PikaStdDevice_UART_write(PikaObj *self, char * data);
#endif
| 37.086957 | 76 | 0.730363 |
bb663073c8f665ab04efb23dcb7078819205b757 | 972 | h | C | source/measures.h | DavidAce/2Component_GL | b0821956ebe1d65355b2afd954b099ed18b9ad54 | [
"MIT"
] | null | null | null | source/measures.h | DavidAce/2Component_GL | b0821956ebe1d65355b2afd954b099ed18b9ad54 | [
"MIT"
] | null | null | null | source/measures.h | DavidAce/2Component_GL | b0821956ebe1d65355b2afd954b099ed18b9ad54 | [
"MIT"
] | null | null | null | //
// Created by ilaria on 2019-11-16.
//
#ifndef MEASURES_H
#define MEASURES_H
#include "main.h"
#include <fstream>
struct Measures{
double E = 0.; //Energy
double E_pot = 0.;
double E_kin = 0.;
double E_Josephson = 0.;
double E_B = 0.;
double E_AB=0.;
double m = 0.; //magnetization (for the phase chirality of the three components
//Binder cumulant U=<m⁴>/(3*<m²>²)
double d_rhoz= 0; //Dual stiffness along z
double density_psi[NC] = {0};
int my_rank = 0;
void reset(){
*this = Measures();
}
};
void dual_stiffness(struct Measures &mis, struct H_parameters &Hp, struct Node* Site);
void magnetization(struct Measures &mis, struct Node* Site);
void energy(struct Measures &mis, struct H_parameters &Hp, struct Node* Site);
void density_psi(struct Measures &mis, struct Node* Site);
void save_lattice(struct Node* Site, const fs::path & directory_write, std::string configuration);
#endif //MEASURES_H
| 24.923077 | 98 | 0.675926 |
183efe78947420bfd7ccf50dcb226a998f3fbdaa | 417 | c | C | Programiranje2/vaje02/pitagorejska-trojica/testi/pitagora.c | RokKos/FRI_Programiranje | d1b0c73585af049be9283447039f5f3e3fa4bdd9 | [
"MIT"
] | 5 | 2016-11-26T14:24:53.000Z | 2020-07-29T07:54:38.000Z | Programiranje2/vaje02/pitagorejska-trojica/testi/pitagora.c | RokKos/FRI_Programiranje | d1b0c73585af049be9283447039f5f3e3fa4bdd9 | [
"MIT"
] | 8 | 2016-12-07T19:32:57.000Z | 2021-06-11T17:58:11.000Z | Programiranje2/vaje02/pitagorejska-trojica/testi/pitagora.c | RokKos/FRI_Programiranje | d1b0c73585af049be9283447039f5f3e3fa4bdd9 | [
"MIT"
] | 12 | 2016-11-27T17:00:26.000Z | 2018-05-22T04:44:08.000Z | #include <stdio.h>
#include <math.h>
int main() {
int a,b;
scanf("%d %d", &a, &b);
int je[b-a + 1];
for (int i = 0; i < b-a + 1; ++i){
je[i] = 0;
}
int c = 0;
for (int i = 1; i <=b; ++i) {
for (int j = i; j <=b; ++j) {
int g = i*i + j*j;
double t = sqrt(g);
if ( (int)t == t && t >= a && t <=b && je[(int)t-a] == 0){
c++;
je[(int)t-a] = 1;
}
}
}
printf("%d\n", c);
return 0;
} | 16.68 | 62 | 0.388489 |
120a03a63879c1273f0a38cb89f0ffdfbe15e7cd | 309 | c | C | first/factoriao.c | catarinaacsilva/c-algorithms | 958da92cd17024b3135c41a328edc7b364a71ae8 | [
"MIT"
] | null | null | null | first/factoriao.c | catarinaacsilva/c-algorithms | 958da92cd17024b3135c41a328edc7b364a71ae8 | [
"MIT"
] | null | null | null | first/factoriao.c | catarinaacsilva/c-algorithms | 958da92cd17024b3135c41a328edc7b364a71ae8 | [
"MIT"
] | null | null | null | #include <stdio.h>
#include <math.h>
int fatoriao(int base);
int main(void){
result = factoriao(10);
printf("%d", result);
}
int factoriao(int base){
int result = 0;
int p = pow(10,6);
int factorial;
do{
for(int i=0;; i++){
for(int j=0;;j++){
}
}
}while(result < p);
}
int factorial | 12.36 | 24 | 0.579288 |
15de334460bde38896c4153e43b2930404c22ec6 | 427 | h | C | WeChat-Headers/IPOILocationDisplayExt-Protocol.h | RockerHX/FishChat | d47f3228dd1f05a7547300330adfe45a09e0175d | [
"MIT"
] | 678 | 2017-11-17T08:33:19.000Z | 2022-03-26T10:40:20.000Z | WeChat-Headers/IPOILocationDisplayExt-Protocol.h | 274077005/FishChat | 5432fbc1a9be0c886b2d5800e28118c11df1f0c0 | [
"MIT"
] | 22 | 2019-04-16T05:51:53.000Z | 2021-11-08T06:18:45.000Z | WeChat-Headers/IPOILocationDisplayExt-Protocol.h | 274077005/FishChat | 5432fbc1a9be0c886b2d5800e28118c11df1f0c0 | [
"MIT"
] | 170 | 2018-06-10T07:59:20.000Z | 2022-03-22T16:19:33.000Z | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "NSObject.h"
@class CLLocation, NSDictionary, NSString;
@protocol IPOILocationDisplayExt <NSObject>
- (void)onGetPOIDisplayName:(NSString *)arg1 ForLocation:(CLLocation *)arg2 Scene:(int)arg3 SrcDisplayName:(NSString *)arg4 extraInfo:(NSDictionary *)arg5 Error:(int)arg6;
@end
| 28.466667 | 171 | 0.728337 |
5cdebfd65a23a42d04ea93dbec0ff6666e960753 | 356 | c | C | misc/mmap.c | ash-nolan/sunder | f974a4e0609651699af193fd665f970ecec94ab3 | [
"Apache-2.0"
] | 7 | 2021-09-29T20:06:36.000Z | 2022-01-24T23:47:34.000Z | misc/mmap.c | ash-nolan/sunder | f974a4e0609651699af193fd665f970ecec94ab3 | [
"Apache-2.0"
] | 51 | 2021-09-17T02:27:45.000Z | 2022-03-26T01:21:02.000Z | misc/mmap.c | ash-nolan/nova | 225f8b5ea589bdfdc853a2dbf4140b71bb8e08b3 | [
"Apache-2.0"
] | null | null | null | #include <sys/mman.h>
#include <stdio.h>
int
main(void)
{
int const prot = PROT_READ | PROT_WRITE;
int const flags = MAP_PRIVATE | MAP_ANONYMOUS;
void* const mapped = mmap((void*)0xDEADBEEF, 4096, prot, flags, -1, 0);
printf("prot %#x\n", prot); // 0x3
printf("flags %#x\n", flags); // 0x22
printf("%p\n", mapped); // 0xdeadb000
}
| 25.428571 | 75 | 0.617978 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.