에프에이리눅스 / 1611_0007_prime_oven

Blame view

kernel/linux-imx6_3.14.28/fs/jffs2/compr_rtime.c 2.84 KB
edit raw normal view history
6b13f685e   김민수   BSP 최초 추가 
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
  /*
   * JFFS2 -- Journalling Flash File System, Version 2.
   *
   * Copyright © 2001-2007 Red Hat, Inc.
   * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
   *
   * Created by Arjan van de Ven <arjanv@redhat.com>
   *
   * For licensing information, see the file 'LICENCE' in this directory.
   *
   *
   *
   * Very simple lz77-ish encoder.
   *
   * Theory of operation: Both encoder and decoder have a list of "last
   * occurrences" for every possible source-value; after sending the
   * first source-byte, the second byte indicated the "run" length of
   * matches
   *
   * The algorithm is intended to only send "whole bytes", no bit-messing.
   *
   */
  
  #include <linux/kernel.h>
  #include <linux/types.h>
  #include <linux/errno.h>
  #include <linux/string.h>
  #include <linux/jffs2.h>
  #include "compr.h"
  
  /* _compress returns the compressed size, -1 if bigger */
  static int jffs2_rtime_compress(unsigned char *data_in,
  				unsigned char *cpage_out,
  				uint32_t *sourcelen, uint32_t *dstlen)
  {
  	unsigned short positions[256];
  	int outpos = 0;
  	int pos=0;
  
  	memset(positions,0,sizeof(positions));
  
  	while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
  		int backpos, runlen=0;
  		unsigned char value;
  
  		value = data_in[pos];
  
  		cpage_out[outpos++] = data_in[pos++];
  
  		backpos = positions[value];
  		positions[value]=pos;
  
  		while ((backpos < pos) && (pos < (*sourcelen)) &&
  		       (data_in[pos]==data_in[backpos++]) && (runlen<255)) {
  			pos++;
  			runlen++;
  		}
  		cpage_out[outpos++] = runlen;
  	}
  
  	if (outpos >= pos) {
  		/* We failed */
  		return -1;
  	}
  
  	/* Tell the caller how much we managed to compress, and how much space it took */
  	*sourcelen = pos;
  	*dstlen = outpos;
  	return 0;
  }
  
  
  static int jffs2_rtime_decompress(unsigned char *data_in,
  				  unsigned char *cpage_out,
  				  uint32_t srclen, uint32_t destlen)
  {
  	unsigned short positions[256];
  	int outpos = 0;
  	int pos=0;
  
  	memset(positions,0,sizeof(positions));
  
  	while (outpos<destlen) {
  		unsigned char value;
  		int backoffs;
  		int repeat;
  
  		value = data_in[pos++];
  		cpage_out[outpos++] = value; /* first the verbatim copied byte */
  		repeat = data_in[pos++];
  		backoffs = positions[value];
  
  		positions[value]=outpos;
  		if (repeat) {
  			if (backoffs + repeat >= outpos) {
  				while(repeat) {
  					cpage_out[outpos++] = cpage_out[backoffs++];
  					repeat--;
  				}
  			} else {
  				memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
  				outpos+=repeat;
  			}
  		}
  	}
  	return 0;
  }
  
  static struct jffs2_compressor jffs2_rtime_comp = {
      .priority = JFFS2_RTIME_PRIORITY,
      .name = "rtime",
      .compr = JFFS2_COMPR_RTIME,
      .compress = &jffs2_rtime_compress,
      .decompress = &jffs2_rtime_decompress,
  #ifdef JFFS2_RTIME_DISABLED
      .disabled = 1,
  #else
      .disabled = 0,
  #endif
  };
  
  int jffs2_rtime_init(void)
  {
      return jffs2_register_compressor(&jffs2_rtime_comp);
  }
  
  void jffs2_rtime_exit(void)
  {
      jffs2_unregister_compressor(&jffs2_rtime_comp);
  }