Line |
Branch |
Exec |
Source |
1 |
|
|
/* |
2 |
|
|
* Copyright (c) 2025 - softworkz |
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 |
|
|
/** |
22 |
|
|
* @file |
23 |
|
|
* output writers for filtergraph details |
24 |
|
|
*/ |
25 |
|
|
|
26 |
|
|
#include "config.h" |
27 |
|
|
|
28 |
|
|
#include <string.h> |
29 |
|
|
|
30 |
|
|
#if CONFIG_RESOURCE_COMPRESSION |
31 |
|
|
#include <zlib.h> |
32 |
|
|
#endif |
33 |
|
|
|
34 |
|
|
#include "resman.h" |
35 |
|
|
#include "libavutil/avassert.h" |
36 |
|
|
#include "libavutil/pixdesc.h" |
37 |
|
|
#include "libavutil/dict.h" |
38 |
|
|
#include "libavutil/common.h" |
39 |
|
|
|
40 |
|
|
extern const unsigned char ff_graph_html_data[]; |
41 |
|
|
extern const unsigned int ff_graph_html_len; |
42 |
|
|
|
43 |
|
|
extern const unsigned char ff_graph_css_data[]; |
44 |
|
|
extern const unsigned ff_graph_css_len; |
45 |
|
|
|
46 |
|
|
static const FFResourceDefinition resource_definitions[] = { |
47 |
|
|
[FF_RESOURCE_GRAPH_CSS] = { FF_RESOURCE_GRAPH_CSS, "graph.css", &ff_graph_css_data[0], &ff_graph_css_len }, |
48 |
|
|
[FF_RESOURCE_GRAPH_HTML] = { FF_RESOURCE_GRAPH_HTML, "graph.html", &ff_graph_html_data[0], &ff_graph_html_len }, |
49 |
|
|
}; |
50 |
|
|
|
51 |
|
|
|
52 |
|
|
static const AVClass resman_class = { |
53 |
|
|
.class_name = "ResourceManager", |
54 |
|
|
}; |
55 |
|
|
|
56 |
|
|
typedef struct ResourceManagerContext { |
57 |
|
|
const AVClass *class; |
58 |
|
|
AVDictionary *resource_dic; |
59 |
|
|
} ResourceManagerContext; |
60 |
|
|
|
61 |
|
|
static AVMutex mutex = AV_MUTEX_INITIALIZER; |
62 |
|
|
|
63 |
|
|
static ResourceManagerContext resman_ctx = { .class = &resman_class }; |
64 |
|
|
|
65 |
|
|
|
66 |
|
|
#if CONFIG_RESOURCE_COMPRESSION |
67 |
|
|
|
68 |
|
✗ |
static int decompress_gzip(ResourceManagerContext *ctx, uint8_t *in, unsigned in_len, char **out, size_t *out_len) |
69 |
|
|
{ |
70 |
|
|
z_stream strm; |
71 |
|
✗ |
unsigned chunk = 65534; |
72 |
|
|
int ret; |
73 |
|
|
uint8_t *buf; |
74 |
|
|
|
75 |
|
✗ |
*out = NULL; |
76 |
|
✗ |
memset(&strm, 0, sizeof(strm)); |
77 |
|
|
|
78 |
|
|
// Allocate output buffer with extra byte for null termination |
79 |
|
✗ |
buf = (uint8_t *)av_mallocz(chunk + 1); |
80 |
|
✗ |
if (!buf) { |
81 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Failed to allocate decompression buffer\n"); |
82 |
|
✗ |
return AVERROR(ENOMEM); |
83 |
|
|
} |
84 |
|
|
|
85 |
|
|
// 15 + 16 tells zlib to detect GZIP or zlib automatically |
86 |
|
✗ |
ret = inflateInit2(&strm, 15 + 16); |
87 |
|
✗ |
if (ret != Z_OK) { |
88 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Error during zlib initialization: %s\n", strm.msg); |
89 |
|
✗ |
av_free(buf); |
90 |
|
✗ |
return AVERROR(ENOSYS); |
91 |
|
|
} |
92 |
|
|
|
93 |
|
✗ |
strm.avail_in = in_len; |
94 |
|
✗ |
strm.next_in = in; |
95 |
|
✗ |
strm.avail_out = chunk; |
96 |
|
✗ |
strm.next_out = buf; |
97 |
|
|
|
98 |
|
✗ |
ret = inflate(&strm, Z_FINISH); |
99 |
|
✗ |
if (ret != Z_OK && ret != Z_STREAM_END) { |
100 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Inflate failed: %d, %s\n", ret, strm.msg); |
101 |
|
✗ |
inflateEnd(&strm); |
102 |
|
✗ |
av_free(buf); |
103 |
|
✗ |
return (ret == Z_STREAM_END) ? Z_OK : ((ret == Z_OK) ? Z_BUF_ERROR : ret); |
104 |
|
|
} |
105 |
|
|
|
106 |
|
✗ |
if (strm.avail_out == 0) { |
107 |
|
|
// TODO: Error or loop decoding? |
108 |
|
✗ |
av_log(ctx, AV_LOG_WARNING, "Decompression buffer may be too small\n"); |
109 |
|
|
} |
110 |
|
|
|
111 |
|
✗ |
*out_len = chunk - strm.avail_out; |
112 |
|
✗ |
buf[*out_len] = 0; // Ensure null termination |
113 |
|
|
|
114 |
|
✗ |
inflateEnd(&strm); |
115 |
|
✗ |
*out = (char *)buf; |
116 |
|
✗ |
return Z_OK; |
117 |
|
|
} |
118 |
|
|
#endif |
119 |
|
|
|
120 |
|
✗ |
void ff_resman_uninit(void) |
121 |
|
|
{ |
122 |
|
✗ |
ff_mutex_lock(&mutex); |
123 |
|
|
|
124 |
|
✗ |
av_dict_free(&resman_ctx.resource_dic); |
125 |
|
|
|
126 |
|
✗ |
ff_mutex_unlock(&mutex); |
127 |
|
✗ |
} |
128 |
|
|
|
129 |
|
|
|
130 |
|
✗ |
char *ff_resman_get_string(FFResourceId resource_id) |
131 |
|
|
{ |
132 |
|
✗ |
ResourceManagerContext *ctx = &resman_ctx; |
133 |
|
✗ |
FFResourceDefinition resource_definition = { 0 }; |
134 |
|
|
AVDictionaryEntry *dic_entry; |
135 |
|
✗ |
char *res = NULL; |
136 |
|
|
|
137 |
|
✗ |
for (unsigned i = 0; i < FF_ARRAY_ELEMS(resource_definitions); ++i) { |
138 |
|
✗ |
FFResourceDefinition def = resource_definitions[i]; |
139 |
|
✗ |
if (def.resource_id == resource_id) { |
140 |
|
✗ |
resource_definition = def; |
141 |
|
✗ |
break; |
142 |
|
|
} |
143 |
|
|
} |
144 |
|
|
|
145 |
|
|
av_assert1(resource_definition.name); |
146 |
|
|
|
147 |
|
✗ |
ff_mutex_lock(&mutex); |
148 |
|
|
|
149 |
|
✗ |
dic_entry = av_dict_get(ctx->resource_dic, resource_definition.name, NULL, 0); |
150 |
|
|
|
151 |
|
✗ |
if (!dic_entry) { |
152 |
|
|
int dict_ret; |
153 |
|
|
|
154 |
|
|
#if CONFIG_RESOURCE_COMPRESSION |
155 |
|
|
|
156 |
|
✗ |
char *out = NULL; |
157 |
|
|
size_t out_len; |
158 |
|
|
|
159 |
|
✗ |
int ret = decompress_gzip(ctx, (uint8_t *)resource_definition.data, *resource_definition.data_len, &out, &out_len); |
160 |
|
|
|
161 |
|
✗ |
if (ret) { |
162 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Unable to decompress the resource with ID %d\n", resource_id); |
163 |
|
✗ |
goto end; |
164 |
|
|
} |
165 |
|
|
|
166 |
|
✗ |
dict_ret = av_dict_set(&ctx->resource_dic, resource_definition.name, out, 0); |
167 |
|
✗ |
if (dict_ret < 0) { |
168 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Failed to store decompressed resource in dictionary: %d\n", dict_ret); |
169 |
|
✗ |
av_freep(&out); |
170 |
|
✗ |
goto end; |
171 |
|
|
} |
172 |
|
|
|
173 |
|
✗ |
av_freep(&out); |
174 |
|
|
#else |
175 |
|
|
|
176 |
|
|
dict_ret = av_dict_set(&ctx->resource_dic, resource_definition.name, (const char *)resource_definition.data, 0); |
177 |
|
|
if (dict_ret < 0) { |
178 |
|
|
av_log(ctx, AV_LOG_ERROR, "Failed to store resource in dictionary: %d\n", dict_ret); |
179 |
|
|
goto end; |
180 |
|
|
} |
181 |
|
|
|
182 |
|
|
#endif |
183 |
|
✗ |
dic_entry = av_dict_get(ctx->resource_dic, resource_definition.name, NULL, 0); |
184 |
|
|
|
185 |
|
✗ |
if (!dic_entry) { |
186 |
|
✗ |
av_log(ctx, AV_LOG_ERROR, "Failed to retrieve resource from dictionary after storing it\n"); |
187 |
|
✗ |
goto end; |
188 |
|
|
} |
189 |
|
|
} |
190 |
|
|
|
191 |
|
✗ |
res = dic_entry->value; |
192 |
|
|
|
193 |
|
✗ |
end: |
194 |
|
✗ |
ff_mutex_unlock(&mutex); |
195 |
|
✗ |
return res; |
196 |
|
|
} |
197 |
|
|
|