Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
att
GitHub Repository: att/ast
 Path: blob/master/src/lib/libvcodex/Vcdelta/vchamming.c
1810 views
1
/***********************************************************************

2
*                                                                      *

3
*               This software is part of the ast package               *

4
*          Copyright (c) 2003-2011 AT&T Intellectual Property          *

5
*                      and is licensed under the                       *

6
*                 Eclipse Public License, Version 1.0                  *

7
*                    by AT&T Intellectual Property                     *

8
*                                                                      *

9
*                A copy of the License is available at                 *

10
*          http://www.eclipse.org/org/documents/epl-v10.html           *

11
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

12
*                                                                      *

13
*              Information and Software Systems Research               *

14
*                            AT&T Research                             *

15
*                           Florham Park NJ                            *

16
*                                                                      *

17
*                   Phong Vo <[email protected]>                    *

18
*                                                                      *

19
***********************************************************************/

20
#include	"vcdhdr.h"

21


22
/*	Transforming data by byte-wise differencing

23
**

24
**	Written by Kiem-Phong Vo ([email protected])

25
*/

26


27
#if __STD_C

28
static ssize_t hamming(Vcodex_t* vc, const Void_t* data, size_t size, Void_t** out)

29
#else

30
static ssize_t hamming(vc, data, size, out)

31
Vcodex_t*	vc;

32
Void_t*		data;

33
size_t		size;

34
Void_t**	out;

35
#endif

36
{

37
	ssize_t		srcsz, tarsz, s, t, maxs;

38
	Vcchar_t	*srcdt, *tardt, *output, *dt;

39
	Vcdisc_t	*disc;

40


41
	if(!vc)

42
		return -1;

43


44
	vc->undone = 0;

45


46
	/* target data to be transformed */

47
	if((tarsz = (ssize_t)size) <= 0)

48
		return tarsz;

49
	if(tarsz > 0 && !(tardt = (Vcchar_t*)data) )

50
		return -1;

51


52
	/* source data to diff against */

53
	disc = vcgetdisc(vc);

54
	srcsz = disc ? (ssize_t)disc->size : 0;

55
	if(srcsz > 0 && !(srcdt = disc ? (Vcchar_t*)disc->data : NIL(Vcchar_t*)) )

56
		return -1;

57


58
	if(!(output = vcbuffer(vc, NIL(Vcchar_t*), tarsz, 0)) )

59
		return -1;

60


61
	if(srcsz <= 0) /* no source data, just copy */

62
		memcpy(output, tardt, tarsz);

63
	else /* transform data */

64
	{	for(dt = output, t = 0; t < tarsz; )

65
		{	if((maxs = tarsz-t) > srcsz)

66
				maxs = srcsz;

67
			for(s = 0; s < maxs; ++s, ++t)

68
				*dt++ = tardt[t] - srcdt[s];

69
		}

70
	}

71


72
	dt = output;

73
	if(vcrecode(vc, &output, &tarsz, 0, 0) < 0 )

74
		return -1;

75
	if(dt != output)

76
		vcbuffer(vc, dt, -1, -1);

77


78
	if(out)

79
		*out = (Void_t*)output;

80
	return tarsz;

81
}

82


83


84
#if __STD_C

85
static ssize_t unhamming(Vcodex_t* vc, const Void_t* data, size_t size, Void_t** out)

86
#else

87
static ssize_t unhamming(vc, data, size, out)

88
Vcodex_t*	vc;

89
Void_t*		data;

90
size_t		size;

91
Void_t**	out;

92
#endif

93
{

94
	ssize_t		srcsz, tarsz, s, t, maxs;

95
	Vcchar_t	*srcdt, *tardt, *output, *dt;

96
	Vcdisc_t	*disc;

97


98
	if(!vc)

99
		return -1;

100


101
	vc->undone = 0;

102


103
	/* retrieve transformed target data */

104
	if((tarsz = (ssize_t)size) <= 0)

105
		return tarsz;

106
	if(tarsz > 0 && !(tardt = (Vcchar_t*)data) )

107
		return -1;

108
	if(vcrecode(vc, &tardt, &tarsz, 0, 0) < 0 )

109
		return -1;

110


111
	/* source data to diff against */

112
	disc = vcgetdisc(vc);

113
	srcsz = disc ? (ssize_t)disc->size : 0;

114
	if(srcsz > 0 && !(srcdt = disc ? (Vcchar_t*)disc->data : NIL(Vcchar_t*)) )

115
		return -1;

116


117
	if(!(output = vcbuffer(vc, NIL(Vcchar_t*), tarsz, 0)) )

118
		return -1;

119


120
	if(srcsz <= 0)

121
		memcpy(output, tardt, tarsz);

122
	else

123
	{	for(dt = output, t = 0; t < tarsz; )

124
		{	if((maxs = tarsz-t) > srcsz)

125
				maxs = srcsz;

126
			for(s = 0; s < maxs; ++s, ++t)

127
				*dt++ = tardt[t] + srcdt[s];

128
		}

129
	}

130


131
	if(out)

132
		*out = (Void_t*)output;

133
	return tarsz;

134
}

135


136
Vcmethod_t _Vchamming =

137
{	hamming,

138
	unhamming,

139
	0,

140
	"hamming", "Byte-wise differencing (like Hamming distance).",

141
	"[-version?hamming (AT&T Research) 2003-01-01]" USAGE_LICENSE,

142
	0,

143
	1024*1024,

144
	VC_MTSOURCE

145
};

146


147
VCLIB(Vchamming)

148


149