FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/mlz.c
Date: 2024-04-20 14:10:07
Exec Total Coverage
Lines: 0 130 0.0%
Functions: 0 6 0.0%
Branches: 0 61 0.0%

Line Branch Exec Source
1 /*
2 * Copyright (c) 2016 Umair Khan <omerjerk@gmail.com>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "libavutil/mem.h"
22 #include "mlz.h"
23
24 av_cold int ff_mlz_init_dict(void *context, MLZ *mlz)
25 {
26 mlz->dict = av_mallocz(TABLE_SIZE * sizeof(*mlz->dict));
27 if (!mlz->dict)
28 return AVERROR(ENOMEM);
29
30 mlz->flush_code = FLUSH_CODE;
31 mlz->current_dic_index_max = DIC_INDEX_INIT;
32 mlz->dic_code_bit = CODE_BIT_INIT;
33 mlz->bump_code = (DIC_INDEX_INIT - 1);
34 mlz->next_code = FIRST_CODE;
35 mlz->freeze_flag = 0;
36 mlz->context = context;
37
38 return 0;
39 }
40
41 av_cold void ff_mlz_flush_dict(MLZ *mlz) {
42 MLZDict *dict = mlz->dict;
43 int i;
44 for ( i = 0; i < TABLE_SIZE; i++ ) {
45 dict[i].string_code = CODE_UNSET;
46 dict[i].parent_code = CODE_UNSET;
47 dict[i].match_len = 0;
48 }
49 mlz->current_dic_index_max = DIC_INDEX_INIT;
50 mlz->dic_code_bit = CODE_BIT_INIT; // DicCodeBitInit;
51 mlz->bump_code = mlz->current_dic_index_max - 1;
52 mlz->next_code = FIRST_CODE;
53 mlz->freeze_flag = 0;
54 }
55
56 static void set_new_entry_dict(MLZDict* dict, int string_code, int parent_code, int char_code) {
57 dict[string_code].parent_code = parent_code;
58 dict[string_code].string_code = string_code;
59 dict[string_code].char_code = char_code;
60 if (parent_code < FIRST_CODE) {
61 dict[string_code].match_len = 2;
62 } else {
63 dict[string_code].match_len = (dict[parent_code].match_len) + 1;
64 }
65 }
66
67 static int decode_string(MLZ* mlz, unsigned char *buff, int string_code, int *first_char_code, unsigned long bufsize) {
68 MLZDict* dict = mlz->dict;
69 unsigned long count, offset;
70 int current_code, parent_code, tmp_code;
71
72 count = 0;
73 current_code = string_code;
74 *first_char_code = CODE_UNSET;
75
76 while (count < bufsize) {
77 switch (current_code) {
78 case CODE_UNSET:
79 return count;
80 break;
81 default:
82 if (current_code < FIRST_CODE) {
83 *first_char_code = current_code;
84 buff[0] = current_code;
85 count++;
86 return count;
87 } else {
88 offset = dict[current_code].match_len - 1;
89 tmp_code = dict[current_code].char_code;
90 if (offset >= bufsize) {
91 av_log(mlz->context, AV_LOG_ERROR, "MLZ offset error.\n");
92 return count;
93 }
94 buff[offset] = tmp_code;
95 count++;
96 }
97 current_code = dict[current_code].parent_code;
98 if ((current_code < 0) || (current_code > (DIC_INDEX_MAX - 1))) {
99 av_log(mlz->context, AV_LOG_ERROR, "MLZ dic index error.\n");
100 return count;
101 }
102 if (current_code > FIRST_CODE) {
103 parent_code = dict[current_code].parent_code;
104 offset = (dict[current_code].match_len) - 1;
105 if (parent_code < 0 || parent_code > DIC_INDEX_MAX-1) {
106 av_log(mlz->context, AV_LOG_ERROR, "MLZ dic index error.\n");
107 return count;
108 }
109 if (( offset > (DIC_INDEX_MAX - 1))) {
110 av_log(mlz->context, AV_LOG_ERROR, "MLZ dic offset error.\n");
111 return count;
112 }
113 }
114 break;
115 }
116 }
117 return count;
118 }
119
120 static int input_code(GetBitContext* gb, int len) {
121 int tmp_code = 0;
122 int i;
123 for (i = 0; i < len; ++i) {
124 tmp_code |= get_bits1(gb) << i;
125 }
126 return tmp_code;
127 }
128
129 int ff_mlz_decompression(MLZ* mlz, GetBitContext* gb, int size, unsigned char *buff) {
130 MLZDict *dict = mlz->dict;
131 unsigned long output_chars;
132 int string_code, last_string_code, char_code;
133
134 string_code = 0;
135 char_code = -1;
136 last_string_code = -1;
137 output_chars = 0;
138
139 while (output_chars < size) {
140 string_code = input_code(gb, mlz->dic_code_bit);
141 switch (string_code) {
142 case FLUSH_CODE:
143 case MAX_CODE:
144 ff_mlz_flush_dict(mlz);
145 char_code = -1;
146 last_string_code = -1;
147 break;
148 case FREEZE_CODE:
149 mlz->freeze_flag = 1;
150 break;
151 default:
152 if (string_code > mlz->current_dic_index_max) {
153 av_log(mlz->context, AV_LOG_ERROR, "String code %d exceeds maximum value of %d.\n", string_code, mlz->current_dic_index_max);
154 return output_chars;
155 }
156 if (string_code == (int) mlz->bump_code) {
157 ++mlz->dic_code_bit;
158 mlz->current_dic_index_max *= 2;
159 mlz->bump_code = mlz->current_dic_index_max - 1;
160 } else {
161 if (string_code >= mlz->next_code) {
162 int ret = decode_string(mlz, &buff[output_chars], last_string_code, &char_code, size - output_chars);
163 if (ret < 0 || ret > size - output_chars) {
164 av_log(mlz->context, AV_LOG_ERROR, "output chars overflow\n");
165 return output_chars;
166 }
167 output_chars += ret;
168 ret = decode_string(mlz, &buff[output_chars], char_code, &char_code, size - output_chars);
169 if (ret < 0 || ret > size - output_chars) {
170 av_log(mlz->context, AV_LOG_ERROR, "output chars overflow\n");
171 return output_chars;
172 }
173 output_chars += ret;
174 set_new_entry_dict(dict, mlz->next_code, last_string_code, char_code);
175 if (mlz->next_code >= TABLE_SIZE - 1) {
176 av_log(mlz->context, AV_LOG_ERROR, "Too many MLZ codes\n");
177 return output_chars;
178 }
179 mlz->next_code++;
180 } else {
181 int ret = decode_string(mlz, &buff[output_chars], string_code, &char_code, size - output_chars);
182 if (ret < 0 || ret > size - output_chars) {
183 av_log(mlz->context, AV_LOG_ERROR, "output chars overflow\n");
184 return output_chars;
185 }
186 output_chars += ret;
187 if (output_chars <= size && !mlz->freeze_flag) {
188 if (last_string_code != -1) {
189 set_new_entry_dict(dict, mlz->next_code, last_string_code, char_code);
190 if (mlz->next_code >= TABLE_SIZE - 1) {
191 av_log(mlz->context, AV_LOG_ERROR, "Too many MLZ codes\n");
192 return output_chars;
193 }
194 mlz->next_code++;
195 }
196 } else {
197 break;
198 }
199 }
200 last_string_code = string_code;
201 }
202 break;
203 }
204 }
205 return output_chars;
206 }
207