1 #include <inttypes.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <assert.h>
6
7 #include "edid.h"
8 #include "info.h"
9 #include "memory-stream.h"
10
11 /* Generated file pnp-id-table.c: */
12 const char *
13 pnp_id_table(const char *key);
14
15 static bool
di_cta_data_block_allowed_multiple(enum di_cta_data_block_tag tag)16 di_cta_data_block_allowed_multiple(enum di_cta_data_block_tag tag)
17 {
18 /* See CTA-861-H, 7.6 Multiple Instances of Data Blocks. */
19 switch (tag) {
20 case DI_CTA_DATA_BLOCK_SPEAKER_ALLOC:
21 case DI_CTA_DATA_BLOCK_VESA_DISPLAY_TRANSFER_CHARACTERISTIC:
22 case DI_CTA_DATA_BLOCK_VIDEO_CAP:
23 case DI_CTA_DATA_BLOCK_VESA_DISPLAY_DEVICE:
24 case DI_CTA_DATA_BLOCK_COLORIMETRY:
25 case DI_CTA_DATA_BLOCK_HDR_STATIC_METADATA:
26 case DI_CTA_DATA_BLOCK_VIDEO_FORMAT_PREF:
27 case DI_CTA_DATA_BLOCK_YCBCR420_CAP_MAP:
28 case DI_CTA_DATA_BLOCK_HDMI_AUDIO:
29 case DI_CTA_DATA_BLOCK_ROOM_CONFIG:
30 case DI_CTA_DATA_BLOCK_HDMI_EDID_EXT_OVERRIDE:
31 case DI_CTA_DATA_BLOCK_HDMI_SINK_CAP:
32 return false;
33 default:
34 return true;
35 }
36 }
37
38 static const struct di_cta_data_block *
di_edid_get_cta_data_block(const struct di_edid * edid,enum di_cta_data_block_tag tag)39 di_edid_get_cta_data_block(const struct di_edid *edid,
40 enum di_cta_data_block_tag tag)
41 {
42 const struct di_edid_ext *const *ext;
43
44 /*
45 * Here we do not handle blocks that are allowed to occur in
46 * multiple instances.
47 */
48 assert(!di_cta_data_block_allowed_multiple(tag));
49
50 for (ext = di_edid_get_extensions(edid); *ext; ext++) {
51 const struct di_edid_cta *cta;
52 const struct di_cta_data_block *const *block;
53
54 if (di_edid_ext_get_tag(*ext) != DI_EDID_EXT_CEA)
55 continue;
56
57 cta = di_edid_ext_get_cta(*ext);
58 for (block = di_edid_cta_get_data_blocks(cta); *block; block++) {
59 if (di_cta_data_block_get_tag(*block) == tag)
60 return *block;
61 }
62 }
63
64 return NULL;
65 }
66
67 static void
derive_edid_hdr_static_metadata(const struct di_edid * edid,struct di_hdr_static_metadata * hsm)68 derive_edid_hdr_static_metadata(const struct di_edid *edid,
69 struct di_hdr_static_metadata *hsm)
70 {
71 const struct di_cta_data_block *block;
72 const struct di_cta_hdr_static_metadata_block *cta_hsm;
73
74 /* By default, everything unset and only traditional gamma supported. */
75 hsm->traditional_sdr = true;
76
77 block = di_edid_get_cta_data_block(edid, DI_CTA_DATA_BLOCK_HDR_STATIC_METADATA);
78 if (!block)
79 return;
80
81 cta_hsm = di_cta_data_block_get_hdr_static_metadata(block);
82 assert(cta_hsm);
83
84 hsm->desired_content_max_luminance = cta_hsm->desired_content_max_luminance;
85 hsm->desired_content_max_frame_avg_luminance = cta_hsm->desired_content_max_frame_avg_luminance;
86 hsm->desired_content_min_luminance = cta_hsm->desired_content_min_luminance;
87 hsm->type1 = cta_hsm->descriptors->type1;
88 hsm->traditional_sdr = cta_hsm->eotfs->traditional_sdr;
89 hsm->traditional_hdr = cta_hsm->eotfs->traditional_hdr;
90 hsm->pq = cta_hsm->eotfs->pq;
91 hsm->hlg = cta_hsm->eotfs->hlg;
92 }
93
94 static void
derive_edid_color_primaries(const struct di_edid * edid,struct di_color_primaries * cc)95 derive_edid_color_primaries(const struct di_edid *edid,
96 struct di_color_primaries *cc)
97 {
98 const struct di_edid_chromaticity_coords *cm;
99 const struct di_edid_misc_features *misc;
100
101 /* Trust the flag more than the fields. */
102 misc = di_edid_get_misc_features(edid);
103 if (misc->srgb_is_primary) {
104 /*
105 * https://www.w3.org/Graphics/Color/sRGB.html
106 * for lack of access to IEC 61966-2-1
107 */
108 cc->primary[0].x = 0.640f; /* red */
109 cc->primary[0].y = 0.330f;
110 cc->primary[1].x = 0.300f; /* green */
111 cc->primary[1].y = 0.600f;
112 cc->primary[2].x = 0.150f; /* blue */
113 cc->primary[2].y = 0.060f;
114 cc->has_primaries = true;
115 cc->default_white.x = 0.3127f; /* D65 */
116 cc->default_white.y = 0.3290f;
117 cc->has_default_white_point = true;
118
119 return;
120 }
121
122 cm = di_edid_get_chromaticity_coords(edid);
123
124 /*
125 * Broken EDID might have only partial values.
126 * Require all values to report anything.
127 */
128 if (cm->red_x > 0.0f &&
129 cm->red_y > 0.0f &&
130 cm->green_x > 0.0f &&
131 cm->green_y > 0.0f &&
132 cm->blue_x > 0.0f &&
133 cm->blue_y > 0.0f) {
134 cc->primary[0].x = cm->red_x;
135 cc->primary[0].y = cm->red_y;
136 cc->primary[1].x = cm->green_x;
137 cc->primary[1].y = cm->green_y;
138 cc->primary[2].x = cm->blue_x;
139 cc->primary[2].y = cm->blue_y;
140 cc->has_primaries = true;
141 }
142 if (cm->white_x > 0.0f && cm->white_y > 0.0f) {
143 cc->default_white.x = cm->white_x;
144 cc->default_white.y = cm->white_y;
145 cc->has_default_white_point = true;
146 }
147 }
148
149 static void
derive_edid_supported_signal_colorimetry(const struct di_edid * edid,struct di_supported_signal_colorimetry * ssc)150 derive_edid_supported_signal_colorimetry(const struct di_edid *edid,
151 struct di_supported_signal_colorimetry *ssc)
152 {
153 const struct di_cta_data_block *block;
154 const struct di_cta_colorimetry_block *cm;
155
156 /* Defaults to all unsupported. */
157
158 block = di_edid_get_cta_data_block(edid, DI_CTA_DATA_BLOCK_COLORIMETRY);
159 if (!block)
160 return;
161
162 cm = di_cta_data_block_get_colorimetry(block);
163 assert(cm);
164
165 ssc->bt2020_cycc = cm->bt2020_cycc;
166 ssc->bt2020_ycc = cm->bt2020_ycc;
167 ssc->bt2020_rgb = cm->bt2020_rgb;
168 ssc->st2113_rgb = cm->st2113_rgb;
169 ssc->ictcp = cm->ictcp;
170 }
171
172 struct di_info *
di_info_parse_edid(const void * data,size_t size)173 di_info_parse_edid(const void *data, size_t size)
174 {
175 struct memory_stream failure_msg;
176 struct di_edid *edid;
177 struct di_info *info;
178 char *failure_msg_str = NULL;
179
180 if (!memory_stream_open(&failure_msg))
181 return NULL;
182
183 edid = _di_edid_parse(data, size, failure_msg.fp);
184 if (!edid)
185 goto err_failure_msg_file;
186
187 info = calloc(1, sizeof(*info));
188 if (!info)
189 goto err_edid;
190
191 info->edid = edid;
192
193 failure_msg_str = memory_stream_close(&failure_msg);
194 if (failure_msg_str && failure_msg_str[0] != '\0')
195 info->failure_msg = failure_msg_str;
196 else
197 free(failure_msg_str);
198
199 derive_edid_hdr_static_metadata(info->edid, &info->derived.hdr_static_metadata);
200 derive_edid_color_primaries(info->edid, &info->derived.color_primaries);
201 derive_edid_supported_signal_colorimetry(info->edid, &info->derived.supported_signal_colorimetry);
202
203 return info;
204
205 err_edid:
206 _di_edid_destroy(edid);
207 err_failure_msg_file:
208 memory_stream_cleanup(&failure_msg);
209 return NULL;
210 }
211
212 void
di_info_destroy(struct di_info * info)213 di_info_destroy(struct di_info *info)
214 {
215 _di_edid_destroy(info->edid);
216 free(info->failure_msg);
217 free(info);
218 }
219
220 const struct di_edid *
di_info_get_edid(const struct di_info * info)221 di_info_get_edid(const struct di_info *info)
222 {
223 return info->edid;
224 }
225
226 const char *
di_info_get_failure_msg(const struct di_info * info)227 di_info_get_failure_msg(const struct di_info *info)
228 {
229 return info->failure_msg;
230 }
231
232 static void
encode_ascii_byte(FILE * out,char ch)233 encode_ascii_byte(FILE *out, char ch)
234 {
235 uint8_t c = (uint8_t)ch;
236
237 /*
238 * Replace ASCII control codes and non-7-bit codes
239 * with an escape string. The result is guaranteed to be valid
240 * UTF-8.
241 */
242 if (c < 0x20 || c >= 0x7f)
243 fprintf(out, "\\x%02x", c);
244 else
245 fputc(c, out);
246 }
247
248 static void
encode_ascii_string(FILE * out,const char * str)249 encode_ascii_string(FILE *out, const char *str)
250 {
251 size_t len = strlen(str);
252 size_t i;
253
254 for (i = 0; i < len; i++)
255 encode_ascii_byte(out, str[i]);
256 }
257
258 char *
di_info_get_make(const struct di_info * info)259 di_info_get_make(const struct di_info *info)
260 {
261 const struct di_edid_vendor_product *evp;
262 char pnp_id[(sizeof(evp->manufacturer)) + 1] = { 0, };
263 const char *manuf;
264 struct memory_stream m;
265
266 if (!info->edid)
267 return NULL;
268
269 if (!memory_stream_open(&m))
270 return NULL;
271
272 evp = di_edid_get_vendor_product(info->edid);
273 memcpy(pnp_id, evp->manufacturer, sizeof(evp->manufacturer));
274
275 manuf = pnp_id_table(pnp_id);
276 if (manuf) {
277 encode_ascii_string(m.fp, manuf);
278 return memory_stream_close(&m);
279 }
280
281 fputs("PNP(", m.fp);
282 encode_ascii_string(m.fp, pnp_id);
283 fputs(")", m.fp);
284
285 return memory_stream_close(&m);
286 }
287
288 char *
di_info_get_model(const struct di_info * info)289 di_info_get_model(const struct di_info *info)
290 {
291 const struct di_edid_vendor_product *evp;
292 const struct di_edid_display_descriptor *const *desc;
293 struct memory_stream m;
294 size_t i;
295 enum di_edid_display_descriptor_tag tag;
296 const char *str;
297
298 if (!info->edid)
299 return NULL;
300
301 if (!memory_stream_open(&m))
302 return NULL;
303
304 desc = di_edid_get_display_descriptors(info->edid);
305 for (i = 0; desc[i]; i++) {
306 tag = di_edid_display_descriptor_get_tag(desc[i]);
307 if (tag != DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_NAME)
308 continue;
309 str = di_edid_display_descriptor_get_string(desc[i]);
310 if (str[0] == '\0')
311 continue;
312 encode_ascii_string(m.fp, str);
313 return memory_stream_close(&m);
314 }
315
316 evp = di_edid_get_vendor_product(info->edid);
317 fprintf(m.fp, "0x%04" PRIX16, evp->product);
318
319 return memory_stream_close(&m);
320 }
321
322 char *
di_info_get_serial(const struct di_info * info)323 di_info_get_serial(const struct di_info *info)
324 {
325 const struct di_edid_display_descriptor *const *desc;
326 const struct di_edid_vendor_product *evp;
327 struct memory_stream m;
328 size_t i;
329 enum di_edid_display_descriptor_tag tag;
330 const char *str;
331
332 if (!info->edid)
333 return NULL;
334
335 if (!memory_stream_open(&m))
336 return NULL;
337
338 desc = di_edid_get_display_descriptors(info->edid);
339 for (i = 0; desc[i]; i++) {
340 tag = di_edid_display_descriptor_get_tag(desc[i]);
341 if (tag != DI_EDID_DISPLAY_DESCRIPTOR_PRODUCT_SERIAL)
342 continue;
343 str = di_edid_display_descriptor_get_string(desc[i]);
344 if (str[0] == '\0')
345 continue;
346 encode_ascii_string(m.fp, str);
347 return memory_stream_close(&m);
348 }
349
350 evp = di_edid_get_vendor_product(info->edid);
351 if (evp->serial != 0) {
352 fprintf(m.fp, "0x%08" PRIX32, evp->serial);
353 return memory_stream_close(&m);
354 }
355
356 memory_stream_cleanup(&m);
357 return NULL;
358 }
359
360 const struct di_hdr_static_metadata *
di_info_get_hdr_static_metadata(const struct di_info * info)361 di_info_get_hdr_static_metadata(const struct di_info *info)
362 {
363 return &info->derived.hdr_static_metadata;
364 }
365
366 const struct di_color_primaries *
di_info_get_default_color_primaries(const struct di_info * info)367 di_info_get_default_color_primaries(const struct di_info *info)
368 {
369 return &info->derived.color_primaries;
370 }
371
372 const struct di_supported_signal_colorimetry *
di_info_get_supported_signal_colorimetry(const struct di_info * info)373 di_info_get_supported_signal_colorimetry(const struct di_info *info)
374 {
375 return &info->derived.supported_signal_colorimetry;
376 }
377
378 static const struct di_displayid *
edid_get_displayid(const struct di_edid * edid)379 edid_get_displayid(const struct di_edid *edid)
380 {
381 const struct di_edid_ext *const *ext;
382
383 for (ext = di_edid_get_extensions(edid); *ext; ext++) {
384 enum di_edid_ext_tag tag = di_edid_ext_get_tag(*ext);
385
386 if (tag == DI_EDID_EXT_DISPLAYID)
387 return di_edid_ext_get_displayid(*ext);
388 }
389
390 return NULL;
391 }
392
393 static const struct di_displayid_display_params *
displayid_get_display_params(const struct di_displayid * did)394 displayid_get_display_params(const struct di_displayid *did)
395 {
396 const struct di_displayid_data_block *const *block =
397 di_displayid_get_data_blocks(did);
398
399 for (; *block; block++) {
400 enum di_displayid_data_block_tag tag = di_displayid_data_block_get_tag(*block);
401
402 if (tag == DI_DISPLAYID_DATA_BLOCK_DISPLAY_PARAMS)
403 return di_displayid_data_block_get_display_params(*block);
404 }
405
406 return NULL;
407 }
408
409 float
di_info_get_default_gamma(const struct di_info * info)410 di_info_get_default_gamma(const struct di_info *info)
411 {
412 const struct di_edid *edid;
413 const struct di_displayid *did;
414 const struct di_edid_misc_features *misc;
415
416 edid = di_info_get_edid(info);
417 if (!edid)
418 return 0.0f;
419
420 did = edid_get_displayid(edid);
421 if (did) {
422 const struct di_displayid_display_params *did_params;
423
424 did_params = displayid_get_display_params(did);
425 if (did_params)
426 return did_params->gamma;
427 }
428
429 /* Trust the flag more than the gamma field value. */
430 misc = di_edid_get_misc_features(edid);
431 if (misc->srgb_is_primary)
432 return 2.2f;
433
434 return di_edid_get_basic_gamma(edid);
435 }
436