]> git.cworth.org Git - vogl/blob - src/voglcommon/vogl_trace_packet.cpp
- Initial support for KHR_debug API's in tracer/replayer
[vogl] / src / voglcommon / vogl_trace_packet.cpp
1 /**************************************************************************
2  *
3  * Copyright 2013-2014 RAD Game Tools and Valve Software
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26 // File: vogl_trace_packet.cpp
27 #include "vogl_common.h"
28 #include "vogl_trace_packet.h"
29 #include "vogl_console.h"
30 #include "vogl_file_utils.h"
31 #include "vogl_bigint128.h"
32 #include "vogl_dynamic_stream.h"
33
34 using namespace vogl;
35
36 //----------------------------------------------------------------------------------------------------------------------
37 // vogl_trace_packet::compare
38 //----------------------------------------------------------------------------------------------------------------------
39 bool vogl_trace_packet::compare(const vogl_trace_packet &other, bool deep) const
40 {
41     VOGL_FUNC_TRACER
42
43     if ((!m_is_valid) || (!other.m_is_valid))
44         return false;
45
46     if (other.get_ctypes() != get_ctypes())
47         return false;
48
49     if (m_total_params != other.m_total_params)
50         return false;
51     if (m_has_return_value != other.m_has_return_value)
52         return false;
53
54 #define CMP(x)                          \
55     if (m_packet.x != other.m_packet.x) \
56         return false;
57
58     CMP(m_entrypoint_id);
59     CMP(m_context_handle);
60     CMP(m_thread_id);
61     CMP(m_call_counter);
62
63     if (deep)
64     {
65         CMP(m_rnd);
66         CMP(m_inv_rnd);
67         CMP(m_packet_begin_rdtsc);
68         CMP(m_gl_begin_rdtsc);
69         CMP(m_gl_end_rdtsc);
70         CMP(m_backtrace_hash_index);
71         CMP(m_packet_end_rdtsc);
72
73         CMP(m_param_size);
74         CMP(m_client_memory_size);
75         CMP(m_name_value_map_size);
76     }
77 #undef CMP
78
79     const uint total_params_to_check = m_total_params + m_has_return_value;
80     for (uint i = 0; i < total_params_to_check; i++)
81     {
82         if (m_param_ctype[i] != other.m_param_ctype[i])
83             return false;
84         if (m_param_size[i] != other.m_param_size[i])
85             return false;
86
87 #if 0
88                 if ((!deep) && ((*m_pCTypes)[m_param_ctype[i]].m_is_pointer))
89                 {
90                         bool lhs_null = (m_param_data[i] != 0);
91                         bool rhs_null = (other.m_param_data[i] != 0);
92                         if (lhs_null != rhs_null)
93                                 return false;
94                 }
95                 else
96 #endif
97         {
98             if (m_param_data[i] != other.m_param_data[i])
99                 return false;
100         }
101
102         const client_memory_desc_t &desc_lhs = m_client_memory_descs[i];
103         const client_memory_desc_t &desc_rhs = other.m_client_memory_descs[i];
104
105         if (desc_lhs.m_vec_ofs >= 0)
106         {
107             if (desc_rhs.m_vec_ofs < 0)
108                 return false;
109             if ((deep) && (desc_lhs.m_vec_ofs != desc_rhs.m_vec_ofs))
110                 return false;
111             if (desc_lhs.m_data_size != desc_rhs.m_data_size)
112                 return false;
113             if (desc_lhs.m_pointee_ctype != desc_rhs.m_pointee_ctype)
114                 return false;
115             if (memcmp(m_client_memory.get_ptr() + desc_lhs.m_vec_ofs, other.m_client_memory.get_ptr() + desc_rhs.m_vec_ofs, desc_lhs.m_data_size) != 0)
116                 return false;
117         }
118         else if (desc_rhs.m_vec_ofs >= 0)
119         {
120             return false;
121         }
122     }
123
124     if (m_key_value_map != other.m_key_value_map)
125         return false;
126
127     return true;
128 }
129
130 //----------------------------------------------------------------------------------------------------------------------
131 // vogl_trace_packet::check
132 //----------------------------------------------------------------------------------------------------------------------
133 bool vogl_trace_packet::check() const
134 {
135     VOGL_FUNC_TRACER
136
137     VOGL_ASSUME(VOGL_NUM_CTYPES < cUINT8_MAX);
138
139     if (!m_is_valid)
140         return false;
141
142     if (m_packet.m_prefix != vogl_trace_stream_packet_base::cTracePacketPrefix)
143         return false;
144     if (m_packet.m_type != cTSPTGLEntrypoint)
145         return false;
146
147     const gl_entrypoint_desc_t &entrypoint_desc = g_vogl_entrypoint_descs[m_packet.m_entrypoint_id];
148
149     if (m_total_params != entrypoint_desc.m_num_params)
150         return false;
151
152     if (entrypoint_desc.m_return_ctype == VOGL_VOID)
153     {
154         if (m_has_return_value)
155             return false;
156         if (m_param_ctype[entrypoint_desc.m_num_params] != VOGL_INVALID_CTYPE)
157             return false;
158     }
159     else
160     {
161         if (!m_has_return_value)
162             return false;
163         if (m_param_ctype[entrypoint_desc.m_num_params] != entrypoint_desc.m_return_ctype)
164             return false;
165         if (m_param_size[entrypoint_desc.m_num_params] != (*m_pCTypes)[entrypoint_desc.m_return_ctype].m_size)
166             return false;
167     }
168
169     for (uint param_iter = 0; param_iter < entrypoint_desc.m_num_params; param_iter++)
170     {
171         if (m_param_ctype[param_iter] == VOGL_INVALID_CTYPE)
172             return false;
173
174         const gl_entrypoint_param_desc_t &param_desc = g_vogl_entrypoint_param_descs[m_packet.m_entrypoint_id][param_iter];
175
176         if (m_param_ctype[param_iter] != param_desc.m_ctype)
177             return false;
178         if (m_param_size[param_iter] != (*m_pCTypes)[param_desc.m_ctype].m_size)
179             return false;
180     }
181
182     uint total_params = entrypoint_desc.m_num_params + m_has_return_value;
183     for (uint param_iter = 0; param_iter < total_params; param_iter++)
184     {
185         const client_memory_desc_t &mem_desc = m_client_memory_descs[param_iter];
186         if (mem_desc.m_vec_ofs >= 0)
187         {
188             if ((!mem_desc.m_data_size) || (mem_desc.m_data_size >= static_cast<uint32>(cINT32_MAX)))
189                 return false;
190
191             if ((mem_desc.m_vec_ofs + mem_desc.m_data_size) > m_client_memory.size())
192                 return false;
193
194             uint pointee_ctype_size = 0;
195             bool pointee_is_opaque = false;
196             bool is_opaque_ptr = false;
197             if (param_iter < entrypoint_desc.m_num_params)
198             {
199                 const gl_entrypoint_param_desc_t &param_desc = g_vogl_entrypoint_param_descs[m_packet.m_entrypoint_id][param_iter];
200
201                 is_opaque_ptr = (*m_pCTypes)[param_desc.m_ctype].m_is_opaque_pointer;
202
203                 if (!(*m_pCTypes)[param_desc.m_ctype].m_is_pointer)
204                     return false;
205
206                 if ((*m_pCTypes)[param_desc.m_ctype].m_pointee_ctype != VOGL_VOID)
207                 {
208                     pointee_ctype_size = (*m_pCTypes)[(*m_pCTypes)[param_desc.m_ctype].m_pointee_ctype].m_size;
209                     pointee_is_opaque = (*m_pCTypes)[(*m_pCTypes)[param_desc.m_ctype].m_pointee_ctype].m_is_opaque_type;
210                 }
211             }
212             else
213             {
214                 is_opaque_ptr = (*m_pCTypes)[entrypoint_desc.m_return_ctype].m_is_opaque_pointer;
215
216                 if (!(*m_pCTypes)[entrypoint_desc.m_return_ctype].m_is_pointer)
217                     return false;
218
219                 if ((*m_pCTypes)[entrypoint_desc.m_return_ctype].m_pointee_ctype != VOGL_VOID)
220                 {
221                     pointee_ctype_size = (*m_pCTypes)[(*m_pCTypes)[entrypoint_desc.m_return_ctype].m_pointee_ctype].m_size;
222                     pointee_is_opaque = (*m_pCTypes)[(*m_pCTypes)[entrypoint_desc.m_return_ctype].m_pointee_ctype].m_is_opaque_type;
223                 }
224             }
225
226             if ((pointee_ctype_size > 1) && (!is_opaque_ptr) && (!pointee_is_opaque))
227             {
228                 if (mem_desc.m_data_size % pointee_ctype_size)
229                     return false;
230             }
231         }
232         else
233         {
234             if (mem_desc.m_vec_ofs != -1)
235                 return false;
236             if (mem_desc.m_data_size)
237                 return false;
238             if (mem_desc.m_pointee_ctype != VOGL_VOID)
239                 return false;
240         }
241     }
242
243     return true;
244 }
245
246 //----------------------------------------------------------------------------------------------------------------------
247 // vogl_trace_packet::deserialize
248 //----------------------------------------------------------------------------------------------------------------------
249 bool vogl_trace_packet::deserialize(const uint8 *pPacket_data, uint packet_data_buf_size, bool check_crc)
250 {
251     VOGL_FUNC_TRACER
252
253     reset();
254
255     const vogl_trace_gl_entrypoint_packet *pTrace_gl_entrypoint_packet = reinterpret_cast<const vogl_trace_gl_entrypoint_packet *>(pPacket_data);
256
257     if (check_crc)
258     {
259         if (!pTrace_gl_entrypoint_packet->full_validation(packet_data_buf_size))
260         {
261             vogl_error_printf("%s: Trace packet failed basic validation!\n", VOGL_METHOD_NAME);
262             return false;
263         }
264     }
265     else
266     {
267         if (!pTrace_gl_entrypoint_packet->basic_validation())
268         {
269             vogl_error_printf("%s: Trace packet failed basic validation!\n", VOGL_METHOD_NAME);
270             return false;
271         }
272     }
273
274     m_packet = *reinterpret_cast<const vogl_trace_gl_entrypoint_packet *>(pTrace_gl_entrypoint_packet);
275
276     VOGL_ASSERT(m_packet.m_type == cTSPTGLEntrypoint);
277
278     if (m_packet.m_size < sizeof(vogl_trace_gl_entrypoint_packet))
279         return false;
280
281     if (m_packet.m_entrypoint_id >= VOGL_NUM_ENTRYPOINTS)
282         return false;
283
284     uint entrypoint_index = m_packet.m_entrypoint_id;
285     const gl_entrypoint_desc_t &entrypoint_desc = g_vogl_entrypoint_descs[entrypoint_index];
286     const gl_entrypoint_param_desc_t *pParam_desc = &g_vogl_entrypoint_param_descs[entrypoint_index][0];
287
288     m_total_params = entrypoint_desc.m_num_params;
289     m_has_return_value = (entrypoint_desc.m_return_ctype != VOGL_VOID);
290
291     const uint total_params_to_deserialize = m_total_params + m_has_return_value;
292
293     const uint8 *pExtra_packet_data = pPacket_data + sizeof(vogl_trace_gl_entrypoint_packet);
294     uint num_bytes_remaining = m_packet.m_size - sizeof(vogl_trace_gl_entrypoint_packet);
295
296     if (m_packet.m_param_size)
297     {
298         if (m_packet.m_param_size > num_bytes_remaining)
299             return false;
300
301         for (uint param_index = 0; param_index < total_params_to_deserialize; ++param_index, ++pParam_desc)
302         {
303             vogl_ctype_t param_ctype = (param_index >= m_total_params) ? entrypoint_desc.m_return_ctype : pParam_desc->m_ctype;
304             uint param_size = (*m_pCTypes)[param_ctype].m_size;
305
306             if (num_bytes_remaining < param_size)
307                 return false;
308
309             m_param_ctype[param_index] = param_ctype;
310             VOGL_ASSERT(param_size <= cUINT8_MAX);
311             m_param_size[param_index] = param_size;
312
313             m_param_data[param_index] = 0;
314             memcpy(&m_param_data[param_index], pExtra_packet_data, param_size);
315
316             pExtra_packet_data += param_size;
317             num_bytes_remaining -= param_size;
318         }
319     }
320
321     if (m_packet.m_client_memory_size)
322     {
323         if (m_packet.m_client_memory_size > num_bytes_remaining)
324             return false;
325
326         uint client_memory_descs_size = (total_params_to_deserialize * sizeof(client_memory_desc_t));
327         if (num_bytes_remaining < client_memory_descs_size)
328             return false;
329
330         memcpy(m_client_memory_descs, pExtra_packet_data, client_memory_descs_size);
331         pExtra_packet_data += client_memory_descs_size;
332         num_bytes_remaining -= client_memory_descs_size;
333
334         if (client_memory_descs_size > m_packet.m_client_memory_size)
335             return false;
336
337         uint client_memory_vec_size = m_packet.m_client_memory_size - client_memory_descs_size;
338
339         m_client_memory.append(pExtra_packet_data, client_memory_vec_size);
340         pExtra_packet_data += client_memory_vec_size;
341         num_bytes_remaining -= client_memory_vec_size;
342     }
343
344     if (m_packet.m_name_value_map_size)
345     {
346         if (m_packet.m_name_value_map_size > num_bytes_remaining)
347             return false;
348
349         if (!m_key_value_map.deserialize_from_buffer(pExtra_packet_data, num_bytes_remaining, true, false))
350             return false;
351
352         pExtra_packet_data += m_packet.m_name_value_map_size;
353         num_bytes_remaining -= m_packet.m_name_value_map_size;
354     }
355
356     if (num_bytes_remaining)
357         return false;
358
359     m_is_valid = true;
360
361     VOGL_ASSERT(check());
362
363     return true;
364 }
365
366 //----------------------------------------------------------------------------------------------------------------------
367 // vogl_trace_packet::deserialize
368 //----------------------------------------------------------------------------------------------------------------------
369 bool vogl_trace_packet::deserialize(const uint8_vec &packet_buf, bool check_crc)
370 {
371     VOGL_FUNC_TRACER
372
373     return deserialize(packet_buf.get_ptr(), packet_buf.size(), check_crc);
374 }
375
376 //----------------------------------------------------------------------------------------------------------------------
377 // vogl_trace_packet::serialize
378 //----------------------------------------------------------------------------------------------------------------------
379 bool vogl_trace_packet::serialize(data_stream &stream) const
380 {
381     VOGL_FUNC_TRACER
382
383     if (!m_is_valid)
384         return false;
385
386     VOGL_ASSERT(m_packet.m_gl_begin_rdtsc <= m_packet.m_gl_end_rdtsc);
387     VOGL_ASSERT(m_packet.m_packet_begin_rdtsc <= m_packet.m_packet_end_rdtsc);
388
389     vogl_trace_gl_entrypoint_packet packet(m_packet);
390
391     uint8 param_data[512];
392
393     uint total_params_to_serialize = m_total_params + m_has_return_value;
394     uint8 *pDst_param_data = param_data;
395     for (uint i = 0; i < total_params_to_serialize; i++)
396     {
397         uint size = m_param_size[i];
398         VOGL_ASSERT(size);
399         memcpy(pDst_param_data, &m_param_data[i], size);
400         pDst_param_data += size;
401         VOGL_ASSERT((pDst_param_data - param_data) <= static_cast<long>(sizeof(param_data)));
402     }
403
404     VOGL_VERIFY((pDst_param_data - param_data) <= cUINT8_MAX);
405     packet.m_param_size = static_cast<uint8>(pDst_param_data - param_data);
406
407     uint client_memory_descs_size = (total_params_to_serialize * sizeof(client_memory_desc_t));
408     packet.m_client_memory_size = client_memory_descs_size + m_client_memory.size();
409
410     uint64_t kvm_serialize_size = m_key_value_map.get_num_key_values() ? m_key_value_map.get_serialize_size(false) : 0;
411     if (kvm_serialize_size > cUINT32_MAX)
412         return false;
413     packet.m_name_value_map_size = static_cast<uint32>(kvm_serialize_size);
414
415     uint64_t total_packet_size = sizeof(vogl_trace_gl_entrypoint_packet) + packet.m_param_size + packet.m_client_memory_size + packet.m_name_value_map_size;
416     if (total_packet_size > static_cast<uint64_t>(cINT32_MAX))
417         return false;
418
419     packet.m_size = static_cast<uint32_t>(total_packet_size);
420
421     if (!m_packet_buf.try_resize(static_cast<uint32>(total_packet_size)))
422         return false;
423
424     uint8 *pDst_buf = m_packet_buf.get_ptr();
425
426 #define APPEND_TO_DST_BUF(pSrc, n)                                         \
427     do                                                                     \
428     {                                                                      \
429         VOGL_ASSERT((int64_t)n <= (int64_t)(m_packet_buf.end() - pDst_buf)); \
430         memcpy(pDst_buf, pSrc, n);                                         \
431         pDst_buf += n;                                                     \
432     } while (0)
433
434     APPEND_TO_DST_BUF(&packet, sizeof(packet));
435
436     if (packet.m_param_size)
437     {
438         APPEND_TO_DST_BUF(param_data, packet.m_param_size);
439     }
440
441     if (packet.m_client_memory_size)
442     {
443         APPEND_TO_DST_BUF(m_client_memory_descs, client_memory_descs_size);
444         APPEND_TO_DST_BUF(m_client_memory.get_ptr(), m_client_memory.size());
445     }
446
447     if (m_key_value_map.get_num_key_values())
448     {
449         if (pDst_buf >= m_packet_buf.end())
450         {
451             VOGL_VERIFY(0);
452             return false;
453         }
454
455         uint buf_remaining = static_cast<uint>(m_packet_buf.end() - pDst_buf);
456         int result = m_key_value_map.serialize_to_buffer(pDst_buf, buf_remaining, true, false);
457         if (result != static_cast<int>(packet.m_name_value_map_size))
458             return false;
459
460         pDst_buf += result;
461     }
462
463     if (pDst_buf != m_packet_buf.end())
464         return false;
465
466 #undef APPEND_TO_DST_BUF
467
468     vogl_trace_gl_entrypoint_packet *pBuf_packet = reinterpret_cast<vogl_trace_gl_entrypoint_packet *>(m_packet_buf.get_ptr());
469     pBuf_packet->finalize();
470
471     VOGL_ASSERT(pBuf_packet->full_validation(m_packet_buf.size()));
472
473     uint n = stream.write(pBuf_packet, m_packet_buf.size());
474     if (n != m_packet_buf.size())
475         return false;
476
477     return true;
478 }
479
480 //----------------------------------------------------------------------------------------------------------------------
481 // vogl_trace_packet::serialize
482 //----------------------------------------------------------------------------------------------------------------------
483 bool vogl_trace_packet::serialize(uint8_vec &buf) const
484 {
485     VOGL_FUNC_TRACER
486
487     dynamic_stream dyn_stream;
488     if (!dyn_stream.open(128))
489         return false;
490     if (!serialize(dyn_stream))
491         return false;
492     buf.swap(dyn_stream.get_buf());
493     return true;
494 }
495
496 //----------------------------------------------------------------------------------------------------------------------
497 // vogl_trace_packet::json_serialize
498 //----------------------------------------------------------------------------------------------------------------------
499 bool vogl_trace_packet::json_serialize(json_node &node, const json_serialize_params &params) const
500 {
501     VOGL_FUNC_TRACER
502
503     const char *pFunc_name = g_vogl_entrypoint_descs[m_packet.m_entrypoint_id].m_pName;
504
505     node.add_key_value("func", pFunc_name);
506
507     node.add_key_value("thread_id", dynamic_string(cVarArg, "0x%" PRIX64, m_packet.m_thread_id));
508     node.add_key_value("context", dynamic_string(cVarArg, "0x%" PRIX64, m_packet.m_context_handle));
509     node.add_key_value("call_counter", static_cast<int64_t>(m_packet.m_call_counter));
510     node.add_key_value("crc32", m_packet.m_crc);
511     node.add_key_value("begin_rdtsc", m_packet.m_packet_begin_rdtsc);
512     node.add_key_value("end_rdtsc", m_packet.m_packet_end_rdtsc);
513     node.add_key_value("gl_begin_rdtsc", m_packet.m_gl_begin_rdtsc);
514     node.add_key_value("gl_end_rdtsc", m_packet.m_gl_end_rdtsc);
515     node.add_key_value("backtrace_hash_index", m_packet.m_backtrace_hash_index);
516     node.add_key_value("rnd_check", m_packet.m_rnd);
517     node.add_key_value("inv_rnd_check", m_packet.m_inv_rnd);
518
519     json_node &gl_params_node = node.add_object("params");
520     for (uint param_index = 0; param_index < total_params(); param_index++)
521     {
522         if (!json_serialize_param(pFunc_name, gl_params_node, param_index, get_param_desc(param_index).m_pName,
523                                   get_param_data(param_index), get_param_size(param_index), get_param_ctype(param_index),
524                                   get_param_client_memory_ptr(param_index),
525                                   get_param_client_memory_data_size(param_index),
526                                   get_param_client_memory_ctype(param_index),
527                                   params))
528         {
529             return false;
530         }
531     }
532
533     if (has_return_value())
534     {
535         if (!json_serialize_param(pFunc_name, node, -1, "return",
536                                   get_return_value_data(), get_return_value_size(), get_return_value_ctype(),
537                                   get_return_client_memory_ptr(),
538                                   get_return_client_memory_data_size(),
539                                   get_return_client_memory_ctype(),
540                                   params))
541         {
542             return false;
543         }
544     }
545
546     if (m_packet.m_name_value_map_size)
547     {
548         json_node &gl_name_value_array = node.add_array("name_value_map");
549
550         dynamic_string key_str, value_str;
551
552         for (key_value_map::const_iterator it = m_key_value_map.begin(); it != m_key_value_map.end(); ++it)
553         {
554             const value &key = it->first;
555             const value &val = it->second;
556
557             json_node &entry_node = gl_name_value_array.add_object();
558
559             entry_node.add_key_value("key_type", g_value_data_type_strings[key.get_data_type()]);
560             entry_node.add_key_value("val_type", g_value_data_type_strings[val.get_data_type()]);
561
562             key.get_string(key_str, false);
563
564             if (key.get_data_type() == cDTStringHash)
565             {
566                 string_hash hash(key.get_string_hash());
567
568                 const char *pStr = find_well_known_string_hash(hash);
569                 if (pStr)
570                     key_str.set(pStr);
571             }
572
573             entry_node.add_key_value("key", key_str);
574
575             bool handle_as_blob_file = false;
576
577             if (val.is_blob())
578             {
579                 if (val.get_blob()->size() >= params.m_blob_file_size_threshold)
580                     handle_as_blob_file = true;
581                 else if (should_always_write_as_blob_file(pFunc_name))
582                     handle_as_blob_file = true;
583             }
584
585             if (handle_as_blob_file)
586             {
587                 dynamic_string id;
588
589                 uint64_t blob_crc64 = calc_crc64(CRC64_INIT, reinterpret_cast<const uint8 *>(val.get_blob()->get_ptr()), val.get_blob()->size());
590
591                 if (params.m_pBlob_manager)
592                 {
593                     //dynamic_string prefix(cVarArg, "%s_%s", params.m_output_basename.get_ptr(), pFunc_name);
594                     dynamic_string prefix(cVarArg, "%s", pFunc_name);
595
596                     id = params.m_pBlob_manager->add_buf_compute_unique_id(val.get_blob()->get_ptr(), val.get_blob()->size(), prefix, "blob", &blob_crc64);
597                     if (id.is_empty())
598                     {
599                         vogl_error_printf("%s: Failed adding blob %s to blob manager\n", VOGL_METHOD_NAME, prefix.get_ptr());
600                         return false;
601                     }
602
603                     vogl_message_printf("%s: Wrote blob id %s\n", VOGL_METHOD_NAME, id.get_ptr());
604                 }
605                 else
606                 {
607                     id = "<blob_writing_disabled>";
608                 }
609
610                 json_node &blob_node = entry_node.add_object("data");
611                 blob_node.add_key_value("blob_id", id);
612                 blob_node.add_key_value("crc64", dynamic_string(cVarArg, "0x%016" PRIX64, blob_crc64));
613                 blob_node.add_key_value("size", val.get_blob()->size());
614             }
615             else
616             {
617                 switch (val.get_data_type())
618                 {
619                     case cDTInt8:
620                     case cDTInt16:
621                     case cDTInt:
622                     case cDTInt64:
623                     {
624                         entry_node.add_key_value("data", val.get_int64());
625                         break;
626                     }
627                     case cDTUInt8:
628                     case cDTUInt16:
629                     case cDTUInt:
630                     {
631                         entry_node.add_key_value("data", val.get_uint());
632                         break;
633                     }
634                     case cDTStringHash:
635                     {
636                         string_hash hash(val.get_string_hash());
637
638                         const char *pStr = find_well_known_string_hash(hash);
639                         if (!pStr)
640                             entry_node.add_key_value("data", hash.get_hash());
641                         else
642                             entry_node.add_key_value("data", pStr);
643                         break;
644                     }
645                     case cDTFloat:
646                     {
647                         float flt_val = val.get_float();
648                         json_value &new_val = entry_node.add_key_value("data", flt_val);
649
650                         dynamic_string new_val_as_str;
651                         new_val.serialize(new_val_as_str, false);
652
653                         json_value test_val;
654                         if ((!test_val.deserialize(new_val_as_str)) || (test_val.as_float() != flt_val))
655                         {
656                             new_val.set_value(dynamic_string(cVarArg, "0x%08X", *reinterpret_cast<const uint32 *>(&flt_val)).get_ptr());
657                         }
658
659                         break;
660                     }
661                     case cDTDouble:
662                     {
663                         double dbl_val = val.get_double();
664                         json_value &new_val = entry_node.add_key_value("data", dbl_val);
665
666                         dynamic_string new_val_as_str;
667                         new_val.serialize(new_val_as_str, false);
668
669                         json_value test_val;
670                         if ((!test_val.deserialize(new_val_as_str)) || (test_val.as_double() != dbl_val))
671                         {
672                             new_val.set_value(dynamic_string(cVarArg, "0x%" PRIX64, static_cast<uint64_t>(*reinterpret_cast<const uint64_t *>(&dbl_val))).get_ptr());
673                         }
674
675                         break;
676                     }
677                     case cDTUInt64:
678                     {
679                         entry_node.add_key_value("data", dynamic_string(cVarArg, "0x%" PRIX64, val.get_uint64()).get_ptr());
680                         break;
681                     }
682                     case cDTJSONDoc:
683                     {
684                         entry_node.add_key_value("data", *val.get_json_document());
685                         break;
686                     }
687                     default:
688                     {
689                         val.get_string(value_str, false);
690                         entry_node.add_key_value("data", value_str);
691
692                         break;
693                     }
694                 }
695             }
696         }
697     }
698
699     if (params.m_write_debug_info)
700     {
701         json_node &gl_dbg_node = node.add_object("dbg");
702         gl_dbg_node.add_key_value("entrypoint_id", m_packet.m_entrypoint_id);
703         gl_dbg_node.add_key_value("total_params", total_params());
704         gl_dbg_node.add_key_value("has_return_value", has_return_value());
705         gl_dbg_node.add_key_value("is_whitelisted", get_entrypoint_desc().m_is_whitelisted);
706         gl_dbg_node.add_key_value("packet_size", m_packet.m_size);
707         gl_dbg_node.add_key_value("param_size", m_packet.m_param_size);
708         gl_dbg_node.add_key_value("client_mem_size", m_packet.m_client_memory_size);
709         gl_dbg_node.add_key_value("name_value_map_size", m_packet.m_name_value_map_size);
710     }
711
712     return true;
713 }
714
715 //----------------------------------------------------------------------------------------------------------------------
716 // print_json_context
717 //----------------------------------------------------------------------------------------------------------------------
718 static void print_json_context(const char *pDocument_filename, const json_node &node, eConsoleMessageType msg_category = cErrorConsoleMessage)
719 {
720     VOGL_FUNC_TRACER
721
722     console::printf(msg_category, "Context: JSON filename %s, on or near line %u, node path: %s\n", pDocument_filename, node.get_line(), node.get_path_to_node().get_ptr());
723 }
724
725 //----------------------------------------------------------------------------------------------------------------------
726 // print_json_context
727 //----------------------------------------------------------------------------------------------------------------------
728 static void print_json_context(const char *pDocument_filename, const json_node &node, uint node_index, eConsoleMessageType msg_category = cErrorConsoleMessage)
729 {
730     VOGL_FUNC_TRACER
731
732     console::printf(msg_category, "Context: JSON filename %s, on or near line %u, node item path: %s\n", pDocument_filename, node.get_line(), node.get_path_to_item(node_index).get_ptr());
733 }
734
735 //----------------------------------------------------------------------------------------------------------------------
736 // print_json_context
737 //----------------------------------------------------------------------------------------------------------------------
738 static void print_json_context(const char *pDocument_filename, const json_value &val, const json_node &node, eConsoleMessageType msg_category = cErrorConsoleMessage)
739 {
740     VOGL_FUNC_TRACER
741
742     console::printf(msg_category, "Context: JSON filename %s, on or near the node at line %u, on or near the value at line %u, node path: %s\n", pDocument_filename, node.get_line(), val.get_line(), node.get_path_to_node().get_ptr());
743 }
744
745 //----------------------------------------------------------------------------------------------------------------------
746 // print_json_context
747 //----------------------------------------------------------------------------------------------------------------------
748 static void print_json_context(const char *pDocument_filename, const json_value &val, const json_node &node, uint node_index, eConsoleMessageType msg_category = cErrorConsoleMessage)
749 {
750     VOGL_FUNC_TRACER
751
752     console::printf(msg_category, "Context: JSON filename %s, on or near the node at line %u, on or near the value at line %u, item path: %s\n", pDocument_filename, node.get_line(), val.get_line(), node.get_path_to_item(node_index).get_ptr());
753 }
754
755 //----------------------------------------------------------------------------------------------------------------------
756 // vogl_trace_packet::json_deserialize
757 //----------------------------------------------------------------------------------------------------------------------
758 bool vogl_trace_packet::json_deserialize(const json_node &node, const char *pDocument_filename, const vogl_blob_manager *pBlob_manager)
759 {
760     VOGL_FUNC_TRACER
761
762     reset();
763
764     const dynamic_string gl_func_name(node.value_as_string("func"));
765     if (gl_func_name.is_empty())
766     {
767         vogl_error_printf("%s: Missing \"func\" node\n", VOGL_METHOD_NAME);
768         print_json_context(pDocument_filename, node);
769         return false;
770     }
771
772     entrypoint_name_hash_map_t::const_iterator it = g_vogl_entrypoint_hashmap.find(gl_func_name);
773     if (it == g_vogl_entrypoint_hashmap.end())
774     {
775         vogl_error_printf("%s: Unknown GL function name: \"%s\"\n", VOGL_METHOD_NAME, gl_func_name.get_ptr());
776         print_json_context(pDocument_filename, node);
777         return false;
778     }
779
780     gl_entrypoint_id_t gl_entrypoint_id = it->second;
781
782     const gl_entrypoint_desc_t &entrypoint_desc = g_vogl_entrypoint_descs[gl_entrypoint_id];
783     const gl_entrypoint_param_desc_t *pEntrypoint_params = &g_vogl_entrypoint_param_descs[gl_entrypoint_id][0];
784
785     uint64_t thread_id = 0;
786     get_uint64_from_json_node(node, "thread_id", thread_id);
787
788     uint64_t context = 0;
789     if (!get_uint64_from_json_node(node, "context", context))
790         context = 1;
791
792     uint64_t call_counter = 0;
793     get_uint64_from_json_node(node, "call_counter", call_counter);
794
795     const json_node *pParams_node = node.find_child("params");
796     json_node dummy_node;
797     if (!pParams_node)
798     {
799         if (entrypoint_desc.m_num_params)
800         {
801             vogl_error_printf("%s: Failed finding params key!\n", VOGL_METHOD_NAME);
802             print_json_context(pDocument_filename, node);
803             return false;
804         }
805         else
806         {
807             vogl_warning_printf("%s: Failed finding params key! Substituting a dummy empty node and trying to deserialize anyway.\n", VOGL_METHOD_NAME);
808         }
809         dummy_node.init_object();
810         pParams_node = &dummy_node;
811     }
812
813     if (!pParams_node->is_object())
814     {
815         vogl_error_printf("%s: Failed finding params key!\n", VOGL_METHOD_NAME);
816         print_json_context(pDocument_filename, *pParams_node);
817         return false;
818     }
819
820     uint num_params = pParams_node->size();
821     if (num_params != entrypoint_desc.m_num_params)
822     {
823         vogl_error_printf("%s: Unexpected number of param keys (expected %u, found %u)\n", VOGL_METHOD_NAME, entrypoint_desc.m_num_params, num_params);
824         print_json_context(pDocument_filename, *pParams_node);
825         return false;
826     }
827
828     const bool has_return_key = node.has_key("return");
829     if (entrypoint_desc.m_return_ctype == VOGL_VOID)
830     {
831         if (has_return_key)
832         {
833             vogl_error_printf("%s: Unexpected return key\n", VOGL_METHOD_NAME);
834             print_json_context(pDocument_filename, node);
835             return false;
836         }
837     }
838     else if (!has_return_key)
839     {
840         vogl_error_printf("%s: Missing return key\n", VOGL_METHOD_NAME);
841         print_json_context(pDocument_filename, node);
842         return false;
843     }
844
845     m_packet.m_entrypoint_id = gl_entrypoint_id;
846     m_packet.m_call_counter = call_counter;
847     m_packet.m_context_handle = context;
848     m_packet.m_thread_id = thread_id;
849
850     // All of this is optional stuff
851     m_packet.m_packet_begin_rdtsc = node.value_as_uint64("begin_rdtsc");
852     m_packet.m_packet_end_rdtsc = node.value_as_uint64("end_rdtsc");
853     m_packet.m_gl_begin_rdtsc = node.value_as_uint64("gl_begin_rdtsc");
854     m_packet.m_gl_end_rdtsc = node.value_as_uint64("gl_end_rdtsc");
855     m_packet.m_backtrace_hash_index = node.value_as_uint32("backtrace_hash_index");
856
857     m_packet.m_rnd = node.value_as_uint32("rnd_check", 1);
858
859     // The rnd value can't be 0,
860     if (m_packet.m_rnd < vogl_trace_stream_packet_base::cMinimumPossibleRnd)
861     {
862         vogl_warning_printf("%s: rnd_check value cannot be 0\n", VOGL_METHOD_NAME);
863         print_json_context(pDocument_filename, node, cWarningConsoleMessage);
864         m_packet.m_rnd = vogl_trace_stream_packet_base::cMinimumPossibleRnd;
865     }
866     m_packet.m_inv_rnd = ~m_packet.m_inv_rnd;
867
868     m_total_params = num_params;
869     m_has_return_value = has_return_key;
870
871     for (uint param_iter = 0; param_iter < num_params; param_iter++)
872     {
873         const gl_entrypoint_param_desc_t &param_desc = pEntrypoint_params[param_iter];
874
875         if (!json_deserialize_param(
876                  call_counter, gl_func_name.get_ptr(),
877                  *pParams_node,
878                  param_iter, param_desc.m_pName, param_desc.m_class, (*m_pCTypes)[param_desc.m_ctype], pDocument_filename, pBlob_manager))
879         {
880             return false;
881         }
882     }
883
884     if (m_has_return_value)
885     {
886         if (!json_deserialize_param(
887                  call_counter, gl_func_name.get_ptr(),
888                  node,
889                  num_params, "return", VOGL_VALUE_PARAM, (*m_pCTypes)[entrypoint_desc.m_return_ctype], pDocument_filename, pBlob_manager))
890         {
891             return false;
892         }
893     }
894
895     const json_node *pName_value_array = node.find_child("name_value_map");
896     if (pName_value_array)
897     {
898         if (!pName_value_array->is_array())
899         {
900             vogl_error_printf("%s: name_value_map is not an array\n", VOGL_METHOD_NAME);
901             print_json_context(pDocument_filename, *pName_value_array);
902             return false;
903         }
904
905         uint64_t size = pName_value_array->size();
906         VOGL_NOTE_UNUSED(size);
907
908         uint name_value_index = 0;
909
910         for (uint name_value_node_iter = 0; name_value_node_iter < pName_value_array->size(); name_value_node_iter++)
911         {
912             const json_node *pItem_node = pName_value_array->get_value_as_object(name_value_node_iter);
913             if (!pItem_node)
914             {
915                 vogl_error_printf("%s: Expected object in name_value_map array\n", VOGL_METHOD_NAME);
916                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
917                 return false;
918             }
919             const json_node &item_node = *pItem_node;
920
921             dynamic_string key_str(item_node.value_as_string("key"));
922             if (key_str.is_empty())
923             {
924                 vogl_error_printf("%s: Expected key in name_value_map array\n", VOGL_METHOD_NAME);
925                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
926                 return false;
927             }
928
929             const char *pKey_type_str = item_node.value_as_string_ptr("key_type");
930             const char *pValue_type_str = item_node.value_as_string_ptr("val_type");
931
932             if ((!pKey_type_str) || (!pValue_type_str))
933             {
934                 vogl_error_printf("%s: Invalid data_types array in name_value_map object\n", VOGL_METHOD_NAME);
935                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
936                 return false;
937             }
938
939             value_data_type key_type = string_to_value_data_type(pKey_type_str);
940             value_data_type value_type = string_to_value_data_type(pValue_type_str);
941             if ((key_type == cDTInvalid) || (value_type == cDTInvalid))
942             {
943                 vogl_error_printf("%s: Invalid data_types array in name_value_map object\n", VOGL_METHOD_NAME);
944                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
945                 return false;
946             }
947
948             value key, val;
949             if (!key.parse(key_str.get_ptr()))
950             {
951                 vogl_error_printf("%s: Failed parsing name_value_map key string %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
952                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
953                 return false;
954             }
955
956             if (!force_value_to_type(key, key_type))
957             {
958                 vogl_error_printf("%s: Failed parsing name_value_map key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
959                 print_json_context(pDocument_filename, *pName_value_array, name_value_node_iter);
960                 return false;
961             }
962
963             const json_value &json_val = item_node.find_value("data");
964
965             if ((value_type == cDTBlob) && (json_val.is_object()))
966             {
967                 //vogl_error_printf("%s: Expected JSON object for name_value_map node key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
968                 //print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
969                 //return false;
970
971                 const json_node &blob_node = *json_val.get_node_ptr();
972
973                 dynamic_string blob_id;
974                 if (!blob_node.get_value_as_string("blob_id", blob_id))
975                 {
976                     vogl_error_printf("%s: Failed parsing blob_file key in name_value_map node key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
977                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
978                     return false;
979                 }
980
981                 uint64_t blob_crc64 = 0;
982                 if (!get_uint64_from_json_node(blob_node, "crc64", blob_crc64))
983                 {
984                     vogl_error_printf("%s: Failed parsing crc64 key in name_value_map node key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
985                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
986                     return false;
987                 }
988
989                 uint64_t blob_size = 0;
990                 if (!get_uint64_from_json_node(blob_node, "size", blob_size))
991                 {
992                     vogl_error_printf("%s: Failed parsing size key in name_value_map node key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
993                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
994                     return false;
995                 }
996
997                 if (blob_size > cUINT32_MAX)
998                 {
999                     vogl_error_printf("%s: Blob size is too large (%" PRIu64 "), blob id %s key %s\n", VOGL_METHOD_NAME, blob_size, blob_id.get_ptr(), key_str.get_ptr());
1000                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1001                     return false;
1002                 }
1003
1004                 if (!pBlob_manager)
1005                 {
1006                     vogl_error_printf("%s: Encountered data blob in packet but no blob manager was specified, blob size %" PRIu64 " blob id %s key %s\n", VOGL_METHOD_NAME, blob_size, blob_id.get_ptr(), key_str.get_ptr());
1007                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1008                     return false;
1009                 }
1010
1011                 uint8_vec blob;
1012                 if (!pBlob_manager->get(blob_id, blob))
1013                 {
1014                     vogl_error_printf("%s: Failed retrieving data blob, blob size %" PRIu64 " blob id %s key %s CRC64 0x%" PRIX64 "\n", VOGL_METHOD_NAME, blob_size, blob_id.get_ptr(), key_str.get_ptr(), blob_crc64);
1015                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1016                     return false;
1017                 }
1018
1019                 uint64_t actual_blob_size = blob.size();
1020
1021                 // TODO: We'll eventually support enormous blob files
1022                 if (actual_blob_size > cUINT32_MAX)
1023                 {
1024                     vogl_error_printf("%s: Blob size is too large (%" PRIu64 "), blob id %s key %s\n", VOGL_METHOD_NAME, actual_blob_size, blob_id.get_ptr(), key_str.get_ptr());
1025                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1026                     return false;
1027                 }
1028
1029                 if (actual_blob_size != blob_size)
1030                 {
1031                     vogl_warning_printf("%s: Unexpected size of blob id %s (should be %" PRIu64 " bytes, but is %" PRIu64 " bytes), reading all of file and hoping for the best\n", VOGL_METHOD_NAME, blob_id.get_ptr(), blob_size, actual_blob_size);
1032                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter, cWarningConsoleMessage);
1033                 }
1034
1035                 uint64_t check_crc64 = calc_crc64(CRC64_INIT, blob.get_ptr(), blob.size());
1036                 if (check_crc64 != blob_crc64)
1037                 {
1038                     vogl_warning_printf("%s: name_value_map blob file %s's CRC64 is bad (expected 0x%016" PRIX64 " got 0x%016" PRIX64 ")\n", VOGL_METHOD_NAME, blob_id.get_ptr(), blob_crc64, check_crc64);
1039                     print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter, cWarningConsoleMessage);
1040                 }
1041
1042                 val.set_blob_take_ownership(blob);
1043             }
1044             else if (value_type == cDTJSONDoc)
1045             {
1046                 *val.init_json_document() = json_val;
1047             }
1048             else
1049             {
1050                 switch (json_val.get_type())
1051                 {
1052                     case cJSONValueTypeBool:
1053                     case cJSONValueTypeInt:
1054                     {
1055                         val.set_int64(json_val.as_int64());
1056                         break;
1057                     }
1058                     case cJSONValueTypeDouble:
1059                     {
1060                         val.set_int64(json_val.as_double());
1061                         break;
1062                     }
1063                     case cJSONValueTypeString:
1064                     {
1065                         const char *pStr = json_val.as_string_ptr();
1066                         if (!pStr || !val.parse(pStr))
1067                         {
1068                             vogl_error_printf("%s: Failed parsing name_value_map value type for key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
1069                             print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1070                             return false;
1071                         }
1072                         break;
1073                     }
1074                     default:
1075                     {
1076                         // Just skip it.
1077                         vogl_error_printf("%s: Unexpected name_value_map value type for key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
1078                         print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1079                         break;
1080                     }
1081                 }
1082             }
1083
1084             if (!force_value_to_type(val, value_type))
1085             {
1086                 vogl_error_printf("%s: Failed parsing value for name_value_map key %s\n", VOGL_METHOD_NAME, key_str.get_ptr());
1087                 print_json_context(pDocument_filename, json_val, *pName_value_array, name_value_node_iter);
1088                 return false;
1089             }
1090             m_key_value_map.insert(key, val);
1091
1092             name_value_index++;
1093
1094         } // name_value_node_iter
1095     }
1096
1097     if (!fixup_manually_edited_params(gl_entrypoint_id, gl_func_name.get_ptr(), call_counter))
1098         return false;
1099
1100     m_is_valid = true;
1101
1102     VOGL_ASSERT(check());
1103
1104     return true;
1105 }
1106
1107 //----------------------------------------------------------------------------------------------------------------------
1108 // vogl_trace_packet::validate_value_conversion
1109 // Returns true if the dest type is at least large enough to hold the parameter (or the same size in bytes for floats).
1110 //----------------------------------------------------------------------------------------------------------------------
1111 bool vogl_trace_packet::validate_value_conversion(uint dest_type_size, uint dest_type_loki_type_flags, int param_index) const
1112 {
1113     VOGL_FUNC_TRACER
1114
1115     VOGL_ASSERT((dest_type_size >= 1) && (dest_type_size <= 8));
1116
1117     const vogl_ctype_desc_t &param_ctype_desc = (param_index < 0) ? get_return_value_ctype_desc() : get_param_ctype_desc(param_index);
1118     uint64_t param_data = (param_index < 0) ? get_return_value_data() : get_param_data(param_index);
1119     uint param_size = param_ctype_desc.m_size;
1120
1121     if (param_ctype_desc.m_is_pointer)
1122     {
1123         // This func is not really intended to be used with pointer types, but try to do something.
1124         return (dest_type_size >= m_pCTypes->get_pointer_size());
1125     }
1126
1127     if (param_ctype_desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_FLOAT))
1128     {
1129         return dest_type_size == static_cast<uint>(param_ctype_desc.m_size);
1130     }
1131
1132     // unsigned ints = unsigned char, unsigned short int,unsigned int, unsigned long int, unsigned long long int
1133     // signed ints = signed char, short int,int, long int, long long int
1134     // integral = bool, char, wchar_t, or signed/unsigned ints
1135     bool param_is_signed = (param_ctype_desc.m_loki_type_flags & (LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_INT) | LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_LONG))) != 0;
1136     bool param_is_unsigned = (param_ctype_desc.m_loki_type_flags & (LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_INT) | LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_LONG))) != 0;
1137     VOGL_NOTE_UNUSED(param_is_unsigned);
1138     bool param_is_integral = (param_ctype_desc.m_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_INTEGRAL)) != 0;
1139
1140     bool dest_is_signed = (dest_type_loki_type_flags & (LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_INT) | LOKI_TYPE_BITMASK(LOKI_IS_SIGNED_LONG))) != 0;
1141     bool dest_is_unsigned = (dest_type_loki_type_flags & (LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_INT) | LOKI_TYPE_BITMASK(LOKI_IS_UNSIGNED_LONG))) != 0;
1142     VOGL_NOTE_UNUSED(dest_is_unsigned);
1143     bool dest_is_integral = (dest_type_loki_type_flags & LOKI_TYPE_BITMASK(LOKI_IS_INTEGRAL)) != 0;
1144
1145     if (param_is_integral != dest_is_integral)
1146         return false;
1147
1148     bigint128 dest_min_val, dest_max_val;
1149     bigint128::get_type_range(dest_type_size, dest_is_signed, dest_min_val, dest_max_val);
1150
1151     // not endian safe
1152     bigint128 param_val(&param_data, param_size, param_is_signed);
1153
1154     if (dest_is_signed)
1155     {
1156         return (param_val >= dest_min_val) && (param_val <= dest_max_val);
1157     }
1158     else
1159     {
1160         return param_val.unsigned_less_equal(dest_max_val);
1161     }
1162 }
1163
1164 //----------------------------------------------------------------------------------------------------------------------
1165 // vogl_trace_packet::should_always_write_as_blob_file
1166 //----------------------------------------------------------------------------------------------------------------------
1167 bool vogl_trace_packet::should_always_write_as_blob_file(const char *pFunc_name)
1168 {
1169     VOGL_FUNC_TRACER
1170
1171     if ((strstr(pFunc_name, "ShaderSource") != NULL) ||
1172         (strstr(pFunc_name, "TexSubImage") != NULL) ||
1173         (strstr(pFunc_name, "TexImage") != NULL))
1174         return true;
1175     return false;
1176 }
1177
1178 //----------------------------------------------------------------------------------------------------------------------
1179 // vogl_trace_packet::ctype_to_json_string
1180 // returns false if the returned string is a valid JSON numeric (otherwise it's a string)
1181 //----------------------------------------------------------------------------------------------------------------------
1182 void vogl_trace_packet::ctype_to_json_value(json_value &val, gl_entrypoint_id_t entrypoint_id, int param_index, uint64_t data, vogl_ctype_t ctype) const
1183 {
1184     VOGL_FUNC_TRACER
1185
1186     switch (ctype)
1187     {
1188         case VOGL_BOOL:
1189         case VOGL_GLBOOLEAN:
1190         {
1191             if (data == 0)
1192             {
1193                 val.set_value(false);
1194                 return;
1195             }
1196             else if (data == 1)
1197             {
1198                 val.set_value(true);
1199                 return;
1200             }
1201
1202             break;
1203         }
1204         case VOGL_GLENUM:
1205         {
1206             const gl_entrypoint_desc_t &entrypoint_desc = g_vogl_entrypoint_descs[entrypoint_id];
1207             VOGL_NOTE_UNUSED(entrypoint_desc);
1208             VOGL_ASSERT((param_index == -1) || (static_cast<uint>(param_index) < entrypoint_desc.m_num_params));
1209
1210             const char *pName = g_gl_enums.find_name(data, entrypoint_id, param_index);
1211
1212             if (pName)
1213             {
1214                 VOGL_ASSERT(g_gl_enums.find_enum(pName) == data);
1215
1216                 val.set_value(pName);
1217                 return;
1218             }
1219
1220             break;
1221         }
1222         case VOGL_FLOAT:
1223         case VOGL_GLFLOAT:
1224         case VOGL_GLCLAMPF:
1225         {
1226             float flt_val = *reinterpret_cast<const float *>(&data);
1227             val.set_value(flt_val);
1228
1229             dynamic_string val_as_str;
1230             val.serialize(val_as_str, false);
1231
1232             json_value test_val;
1233             if ((!test_val.deserialize(val_as_str)) || (test_val.as_float() != flt_val))
1234                 break;
1235
1236             return;
1237         }
1238         case VOGL_GLDOUBLE:
1239         case VOGL_GLCLAMPD:
1240         {
1241             double dbl_val = *reinterpret_cast<const double *>(&data);
1242             val.set_value(dbl_val);
1243
1244             dynamic_string val_as_str;
1245             val.serialize(val_as_str, false);
1246
1247             json_value test_val;
1248             if ((!test_val.deserialize(val_as_str)) || (test_val.as_double() != dbl_val))
1249                 break;
1250
1251             return;
1252         }
1253         case VOGL_GLINT:
1254         case VOGL_INT:
1255         case VOGL_INT32T:
1256         case VOGL_GLSIZEI:
1257         case VOGL_GLFIXED:
1258         {
1259             val.set_value(static_cast<int32>(data));
1260             return;
1261         }
1262         case VOGL_GLSHORT:
1263         {
1264             val.set_value(static_cast<int16>(data));
1265             return;
1266         }
1267         case VOGL_GLBYTE:
1268         {
1269             val.set_value(static_cast<int8>(data));
1270             return;
1271         }
1272         case VOGL_GLINT64:
1273         case VOGL_GLINT64EXT:
1274         {
1275             val.set_value(static_cast<int64_t>(data));
1276             return;
1277         }
1278         default:
1279         {
1280             break;
1281         }
1282     }
1283
1284     val.set_value(dynamic_string(cVarArg, "0x%" PRIX64, data).get_ptr());
1285 }
1286
1287 //----------------------------------------------------------------------------------------------------------------------
1288 // vogl_trace_packet::json_serialize_param
1289 //----------------------------------------------------------------------------------------------------------------------
1290 bool vogl_trace_packet::json_serialize_param(
1291     const char *pFunc_name,
1292     json_node &gl_params_node, int param_index, const char *pName, const uint64_t param_data, const uint param_size, vogl_ctype_t param_ctype,
1293     const void *pClient_mem, uint client_mem_size, vogl_ctype_t client_mem_ctype,
1294     const json_serialize_params &params) const
1295 {
1296     VOGL_FUNC_TRACER
1297
1298     VOGL_NOTE_UNUSED(param_size);
1299     VOGL_NOTE_UNUSED(client_mem_ctype);
1300
1301     const vogl_ctype_desc_t &param_ctype_desc = (*m_pCTypes)[param_ctype];
1302
1303     const bool has_client_memory = (pClient_mem != NULL);
1304
1305     if ((param_ctype_desc.m_is_pointer) && (param_data) && (has_client_memory))
1306     {
1307         const vogl_ctype_t pointee_ctype = param_ctype_desc.m_pointee_ctype;
1308         const uint pointee_size = (*m_pCTypes)[pointee_ctype].m_size;
1309         const bool pointee_is_ptr = (*m_pCTypes)[pointee_ctype].m_is_pointer;
1310
1311         bool print_as_cstring = false;
1312         switch (param_ctype)
1313         {
1314             case VOGL_CONST_GLUBYTE_PTR:
1315             case VOGL_CONST_GLCHAR_PTR:
1316             case VOGL_GLCHARARB_PTR:
1317             case VOGL_CONST_GLBYTE_PTR:
1318             case VOGL_GLUBYTE_PTR:
1319             case VOGL_GLCHAR_PTR:
1320             case VOGL_CONST_GLCHARARB_PTR:
1321             {
1322                 if ((client_mem_size <= 8192) && (utils::is_buffer_printable(pClient_mem, client_mem_size, true, true)))
1323                 {
1324                     print_as_cstring = true;
1325                     break;
1326                 }
1327                 break;
1328             }
1329             default:
1330                 break;
1331         }
1332
1333         if (print_as_cstring)
1334         {
1335             if ((client_mem_size >= 2) && (static_cast<const char *>(pClient_mem)[0] == '0') && (static_cast<const char *>(pClient_mem)[1] == 'x'))
1336                 print_as_cstring = false;
1337             //else if (g_vogl_entrypoint_hashmap.find(static_cast<const char *>(pClient_mem)) != g_vogl_entrypoint_hashmap.end())
1338             //   print_as_cstring = false;
1339         }
1340
1341         json_node &param_node = gl_params_node.add_object(pName);
1342
1343         if (print_as_cstring)
1344         {
1345             const char *pStr = reinterpret_cast<const char *>(pClient_mem);
1346
1347             // this was causing a crash and as far as I could tell it was a clang optimizer bug?
1348             //dynamic_string str(cVarArg, "%s", pStr);
1349             dynamic_string str(pStr);
1350             param_node.add_key_value("string", str);
1351
1352             param_node.add_key_value("ptr", dynamic_string(cVarArg, "0x%016" PRIX64, param_data));
1353         }
1354         else
1355         {
1356             param_node.add_key_value("ptr", dynamic_string(cVarArg, "0x%016" PRIX64, param_data));
1357             param_node.add_key_value("mem_size", client_mem_size);
1358
1359             uint64_t client_mem_crc64 = calc_crc64(CRC64_INIT, reinterpret_cast<const uint8 *>(pClient_mem), client_mem_size);
1360             param_node.add_key_value("crc64", dynamic_string(cVarArg, "0x%016" PRIX64, client_mem_crc64));
1361
1362             if ((pointee_size >= 1) && (pointee_size <= 8) && (math::is_power_of_2(pointee_size)) && (!(client_mem_size % pointee_size)))
1363             {
1364                 json_node &param_data_values_node = param_node.add_array("values");
1365
1366                 const uint client_mem_array_size = client_mem_size / pointee_size;
1367
1368                 for (uint i = 0; i < client_mem_array_size; i++)
1369                 {
1370                     const void *p = reinterpret_cast<const uint8 *>(pClient_mem) + i * pointee_size;
1371
1372                     uint64_t data = 0;
1373                     if (pointee_size == sizeof(uint8))
1374                         data = *reinterpret_cast<const uint8 *>(p);
1375                     else if (pointee_size == sizeof(uint16))
1376                         data = *reinterpret_cast<const uint16 *>(p);
1377                     else if (pointee_size == sizeof(uint32))
1378                         data = *reinterpret_cast<const uint32 *>(p);
1379                     else if (pointee_size == sizeof(uint64_t))
1380                         data = *reinterpret_cast<const uint64_t *>(p);
1381
1382                     json_value val;
1383                     ctype_to_json_value(val, static_cast<gl_entrypoint_id_t>(m_packet.m_entrypoint_id), param_index, data, pointee_ctype);
1384
1385                     param_data_values_node.add_value(val);
1386                 }
1387             }
1388             else
1389             {
1390                 if ((!should_always_write_as_blob_file(pFunc_name)) && (client_mem_size < params.m_blob_file_size_threshold))
1391                 {
1392                     dynamic_string buf;
1393
1394                     buf.set_len(2 + client_mem_size * 2);
1395                     buf.set_char(0, '0');
1396                     buf.set_char(1, 'x');
1397
1398                     for (uint i = 0; i < client_mem_size; i++)
1399                     {
1400                         const uint8 c = reinterpret_cast<const uint8 *>(pClient_mem)[(client_mem_size - 1) - i];
1401                         buf.set_char(2 + i * 2 + 0, utils::to_hex((c >> 4) & 0xF));
1402                         buf.set_char(2 + i * 2 + 1, utils::to_hex(c & 0xF));
1403                     }
1404
1405                     param_node.add_key_value("bytes", buf);
1406                 }
1407                 else
1408                 {
1409                     dynamic_string id;
1410
1411                     if (params.m_pBlob_manager)
1412                     {
1413                         //dynamic_string prefix(cVarArg, "%s_%s_param_%i", params.m_output_basename.get_ptr(), pFunc_name, param_index);
1414                         dynamic_string prefix(cVarArg, "%s_%s", pFunc_name, g_vogl_entrypoint_param_descs[m_packet.m_entrypoint_id][param_index].m_pName);
1415
1416                         id = params.m_pBlob_manager->add_buf_compute_unique_id(pClient_mem, client_mem_size, prefix, "blob", &client_mem_crc64);
1417                         if (id.is_empty())
1418                         {
1419                             vogl_error_printf("%s: Failed adding blob %s to blob manager\n", VOGL_METHOD_NAME, prefix.get_ptr());
1420                             return false;
1421                         }
1422
1423                         vogl_message_printf("%s: Wrote blob id %s\n", VOGL_METHOD_NAME, id.get_ptr());
1424                     }
1425                     else
1426                     {
1427                         id = "<blob_writing_disabled>";
1428                     }
1429
1430                     param_node.add_key_value("blob_id", id);
1431                 }
1432             }
1433
1434             if (params.m_write_debug_info)
1435             {
1436                 json_node &param_dbg_node = param_node.add_object("dbg");
1437                 param_dbg_node.add_key_value("ctype", (*m_pCTypes)[param_ctype].m_pCType);
1438                 param_dbg_node.add_key_value("pointee_ctype", (*m_pCTypes)[pointee_ctype].m_pCType);
1439                 param_dbg_node.add_key_value("pointee_ctype_size", (*m_pCTypes)[pointee_ctype].m_size);
1440                 param_dbg_node.add_key_value("pointee_ctype_is_opaque", (*m_pCTypes)[pointee_ctype].m_is_opaque_pointer);
1441                 param_dbg_node.add_key_value("pointee_is_ptr", pointee_is_ptr);
1442                 param_dbg_node.add_key_value("pointee_size", pointee_size);
1443             }
1444         }
1445     }
1446     else
1447     {
1448         json_value param_value;
1449         // This helper can return a hex string (beginning with 0x chars) for values that can't be losslessly converted to a JSON numeric
1450         ctype_to_json_value(param_value, static_cast<gl_entrypoint_id_t>(m_packet.m_entrypoint_id), param_index, param_data, param_ctype);
1451         gl_params_node.add_key_value(pName, param_value);
1452     }
1453
1454     return true;
1455 }
1456
1457 //----------------------------------------------------------------------------------------------------------------------
1458 // vogl_trace_packet::convert_json_value_to_ctype_data
1459 //----------------------------------------------------------------------------------------------------------------------
1460 bool vogl_trace_packet::convert_json_value_to_ctype_data(uint64_t &data, const json_value &val, vogl_ctype_t ctype, const char *pName, int param_iter, gl_entrypoint_param_class_t param_class, bool permit_client_strings, const json_node &node, const char *pDocument_filename)
1461 {
1462     VOGL_FUNC_TRACER
1463
1464     VOGL_NOTE_UNUSED(param_class);
1465
1466     const bool is_pointer = (*m_pCTypes)[ctype].m_is_pointer;
1467
1468     // could either be a pointer to a string, or pointer value with no associated client memory, or a param value
1469     data = 0;
1470
1471     double dbl_data = 0;
1472     uint parsed_size = 0;
1473     VOGL_NOTE_UNUSED(parsed_size);
1474     bool parsed_double = false;
1475     bool parsed_hex = false;
1476
1477     if (val.is_string())
1478     {
1479         dynamic_string str(val.as_string());
1480
1481         if ((str.get_len() >= 3) && (str[0] == '0') && (str[1] == 'x'))
1482         {
1483             // hex parameter data - should be <= sizeof(uint64_t)
1484             // could be a pointer to unspecified client memory, or a non-ptr param value that couldn't be serialized to a regular json type
1485
1486             const char *pBuf = str.get_ptr();
1487             if (!string_ptr_to_uint64(pBuf, data))
1488             {
1489                 vogl_error_printf("Failed parsing hex numeric value of parameter %s\n", pName);
1490                 print_json_context(pDocument_filename, val, node);
1491                 return false;
1492             }
1493             parsed_size = sizeof(uint64_t);
1494             parsed_hex = true;
1495         }
1496         else if (is_pointer)
1497         {
1498             if (!permit_client_strings)
1499             {
1500                 vogl_error_printf("Unexpected string for parameter %s\n", pName);
1501                 print_json_context(pDocument_filename, val, node);
1502                 return false;
1503             }
1504
1505             // must be a zero terminated string originally from client memory
1506             data = 0xFFFFFFFF;
1507             parsed_size = sizeof(uint32);
1508
1509             if (!is_pointer)
1510             {
1511                 vogl_error_printf("Encountered string for non-pointer parameter %s\n", pName);
1512                 print_json_context(pDocument_filename, val, node);
1513                 return false;
1514             }
1515
1516             client_memory_desc_t &mem_desc = m_client_memory_descs[param_iter];
1517             mem_desc.m_vec_ofs = m_client_memory.size();
1518             mem_desc.m_data_size = str.get_len() + 1;
1519             mem_desc.m_pointee_ctype = (*m_pCTypes)[ctype].m_pointee_ctype;
1520
1521             m_client_memory.append(reinterpret_cast<const uint8 *>(str.get_ptr()), str.get_len() + 1);
1522         }
1523         else
1524         {
1525             uint64_t gl_enum = g_gl_enums.find_enum(str);
1526             if (gl_enum == gl_enums::cUnknownEnum)
1527             {
1528                 vogl_error_printf("Unexpected string for parameter %s\n", pName);
1529                 print_json_context(pDocument_filename, val, node);
1530                 return false;
1531             }
1532
1533             // TODO - Fix this so it doesn't downcast to uint (can it safely return uint64_t?)
1534             VOGL_ASSERT(gl_enum <= cUINT32_MAX);
1535
1536             // a GL enum
1537             data = static_cast<uint>(gl_enum);
1538             parsed_size = sizeof(uint);
1539         }
1540     }
1541     else
1542     {
1543         // parameter data
1544         if (val.is_bool())
1545         {
1546             bool b = val.as_bool();
1547             memcpy(&data, &b, 1);
1548             parsed_size = 1;
1549         }
1550         else if (val.is_double())
1551         {
1552             dbl_data = val.as_double();
1553             memcpy(&data, &dbl_data, sizeof(dbl_data));
1554             parsed_size = sizeof(dbl_data);
1555             parsed_double = true;
1556         }
1557         else if (val.is_int())
1558         {
1559             int64_t v = val.as_int64();
1560             memcpy(&data, &v, sizeof(data));
1561             parsed_size = sizeof(int64_t);
1562         }
1563         else
1564         {
1565             vogl_error_printf("Invalid JSON node type for parameter %s\n", pName);
1566             print_json_context(pDocument_filename, val, node);
1567             return false;
1568         }
1569     }
1570
1571     int64_t idata = static_cast<int64_t>(data);
1572
1573     switch (ctype)
1574     {
1575         case VOGL_FLOAT:
1576         case VOGL_GLFLOAT:
1577         case VOGL_GLCLAMPF:
1578         {
1579             float v = 0;
1580             if (parsed_double)
1581                 v = static_cast<float>(dbl_data);
1582             else if (parsed_hex)
1583                 v = *reinterpret_cast<const float *>(&data);
1584             else
1585             {
1586                 v = static_cast<float>(idata);
1587                 vogl_debug_printf("Parameter %s should be a float, but a non-float value was specified in the JSON file\n", pName);
1588                 print_json_context(pDocument_filename, val, node, cDebugConsoleMessage);
1589             }
1590
1591             data = 0;
1592             memcpy(&data, &v, sizeof(v));
1593             break;
1594         }
1595         case VOGL_GLDOUBLE:
1596         case VOGL_GLCLAMPD:
1597         {
1598             double v = 0;
1599             if (parsed_double)
1600                 v = dbl_data;
1601             else if (parsed_hex)
1602                 v = *reinterpret_cast<const double *>(&data);
1603             else
1604             {
1605                 v = static_cast<double>(idata);
1606                 vogl_debug_printf("Parameter %s should be a double, but a non-double value was specified in the JSON file\n", pName);
1607                 print_json_context(pDocument_filename, val, node, cDebugConsoleMessage);
1608             }
1609             memcpy(&data, &v, sizeof(v));
1610             break;
1611         }
1612         default:
1613         {
1614             if (parsed_double)
1615             {
1616                 vogl_warning_printf("Float point value specified for non-float parameter %s, casting to integer\n", pName);
1617                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1618                 data = idata = static_cast<int64_t>(dbl_data);
1619             }
1620             break;
1621         }
1622     } // switch (ctype)
1623
1624     switch (ctype)
1625     {
1626         case VOGL_BOOL:
1627         case VOGL_GLBOOLEAN:
1628         {
1629             //if ((data != 0) && (data != 1))
1630             //   vogl_warning_printf("Expected bool value for parameter %s\n", pName);
1631             break;
1632         }
1633         case VOGL_GLBITFIELD:
1634         case VOGL_GLUINT:
1635         case VOGL_UNSIGNED_INT:
1636         case VOGL_GLENUM:
1637         case VOGL_GLHANDLEARB:
1638         {
1639             if (data > cUINT32_MAX)
1640             {
1641                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1642                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1643             }
1644             break;
1645         }
1646         case VOGL_GLINT:
1647         case VOGL_INT:
1648         case VOGL_INT32T:
1649         case VOGL_GLFIXED:
1650         case VOGL_GLSIZEI:
1651         {
1652             if ((idata < cINT32_MIN) || (idata > cINT32_MAX))
1653             {
1654                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1655                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1656             }
1657             break;
1658         }
1659         case VOGL_GLBYTE:
1660         case VOGL_GLCHARARB:
1661         {
1662             if ((idata < -cINT8_MAX) || (idata > cINT8_MAX))
1663             {
1664                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1665                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1666             }
1667             break;
1668         }
1669         case VOGL_GLCHAR:
1670         case VOGL_GLUBYTE:
1671         {
1672             if (data > cUINT8_MAX)
1673             {
1674                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1675                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1676             }
1677             break;
1678         }
1679         case VOGL_GLHALFNV:
1680         case VOGL_GLUSHORT:
1681         {
1682             if (data > cUINT16_MAX)
1683             {
1684                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1685                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1686             }
1687             break;
1688         }
1689         case VOGL_GLSHORT:
1690         {
1691             if ((idata < cINT16_MIN) || (idata > cINT16_MAX))
1692             {
1693                 vogl_warning_printf("Value out of range for parameter %s\n", pName);
1694                 print_json_context(pDocument_filename, val, node, cWarningConsoleMessage);
1695             }
1696             break;
1697         }
1698         default:
1699             break;
1700     }
1701
1702     return true;
1703 }
1704
1705 //----------------------------------------------------------------------------------------------------------------------
1706 // vogl_trace_packet::json_deserialize_param
1707 //----------------------------------------------------------------------------------------------------------------------
1708 bool vogl_trace_packet::json_deserialize_param(
1709     uint64_t cur_call_counter, const char *pFunc_name,
1710     const json_node &params_node, uint param_iter, const char *pParam_name, gl_entrypoint_param_class_t param_class, const vogl_ctype_desc_t &param_ctype_desc,
1711     const char *pDocument_filename, const vogl_blob_manager *pBlob_manager)
1712 {
1713     VOGL_FUNC_TRACER
1714
1715     VOGL_NOTE_UNUSED(cur_call_counter);
1716
1717     int param_index = params_node.find_key(pParam_name);
1718     if (param_index < 0)
1719     {
1720         vogl_error_printf("Failed finding function parameter \"%s\"\n", pParam_name);
1721         print_json_context(pDocument_filename, params_node);
1722         return false;
1723     }
1724
1725     const json_value &val = params_node.get_value(param_index);
1726     if ((val.is_null()) || (val.is_array()))
1727     {
1728         vogl_error_printf("Invalid JSON node type for parameter %s\n", pParam_name);
1729         print_json_context(pDocument_filename, params_node);
1730         return false;
1731     }
1732
1733     if (val.is_object())
1734     {
1735         // must be pointer to client memory of some sort
1736         if (!param_ctype_desc.m_is_pointer)
1737         {
1738             vogl_error_printf("A memory object was specified for parameter %s, but parameter is not a pointer to client memory\n", pParam_name);
1739             print_json_context(pDocument_filename, val, params_node);
1740             return false;
1741         }
1742
1743         vogl_ctype_t pointee_ctype = param_ctype_desc.m_pointee_ctype;
1744         VOGL_ASSERT(pointee_ctype != VOGL_INVALID_CTYPE);
1745
1746         uint pointee_ctype_size = (*m_pCTypes)[pointee_ctype].m_size;
1747
1748         const json_node *pParam_obj = val.get_node_ptr();
1749
1750         uint64_t ptr = 0;
1751         if (!get_uint64_from_json_node(*pParam_obj, "ptr", ptr, 0))
1752         {
1753             vogl_warning_printf("Failed parsing ptr field of parameter %s (the pointer is only for debugging, not replay, so this is not a hard failure)\n", pParam_name);
1754             print_json_context(pDocument_filename, *pParam_obj, cWarningConsoleMessage);
1755         }
1756
1757         if (pParam_obj->has_key("string"))
1758         {
1759             const char *pStr = pParam_obj->find_value("string").as_string_ptr();
1760             uint str_len = vogl_strlen(pStr);
1761
1762             client_memory_desc_t &mem_desc = m_client_memory_descs[param_iter];
1763             mem_desc.m_vec_ofs = m_client_memory.size();
1764             mem_desc.m_data_size = str_len + 1;
1765             mem_desc.m_pointee_ctype = pointee_ctype;
1766
1767             m_client_memory.append(reinterpret_cast<const uint8 *>(pStr), str_len + 1);
1768
1769             m_param_data[param_iter] = ptr;
1770
1771             VOGL_ASSERT(param_ctype_desc.m_size <= cUINT8_MAX);
1772             m_param_size[param_iter] = param_ctype_desc.m_size;
1773             m_param_ctype[param_iter] = param_ctype_desc.m_ctype;
1774         }
1775         else
1776         {
1777             uint64_t mem_size = 0;
1778             if (!get_uint64_from_json_node(*pParam_obj, "mem_size", mem_size, 0))
1779             {
1780                 vogl_error_printf("Failed parsing mem_size field of parameter %s\n", pParam_name);
1781                 print_json_context(pDocument_filename, *pParam_obj);
1782                 return false;
1783             }
1784
1785             if (mem_size > 0x7FFF0000)
1786             {
1787                 vogl_error_printf("Client memory blob size is too large for parameter %s\n", pParam_name);
1788                 print_json_context(pDocument_filename, *pParam_obj);
1789                 return false;
1790             }
1791
1792             uint64_t blob_crc64 = 0;
1793             bool has_blob_crc64 = get_uint64_from_json_node(*pParam_obj, "crc64", blob_crc64, 0);
1794
1795             vogl::vector<uint8> blob(static_cast<uint32>(mem_size));
1796
1797             if (pParam_obj->find_child("values"))
1798             {
1799                 if (pointee_ctype_size <= 0)
1800                 {
1801                     vogl_error_printf("Can't specify a values array for void* parameter %s\n", pParam_name);
1802                     print_json_context(pDocument_filename, *pParam_obj);
1803                     return false;
1804                 }
1805
1806                 const json_node *pValues = pParam_obj->find_child("values");
1807
1808                 if (!pValues->is_array())
1809                 {
1810                     vogl_error_printf("Expected array for values field of parameter %s\n", pParam_name);
1811                     print_json_context(pDocument_filename, *pValues);
1812                     return false;
1813                 }
1814
1815                 uint num_vals = pValues->size();
1816                 if (num_vals != (mem_size / pointee_ctype_size))
1817                 {
1818                     vogl_error_printf("Array size is invalid for parameter %s\n", pParam_name);
1819                     print_json_context(pDocument_filename, *pValues);
1820                     return false;
1821                 }
1822
1823                 if ((mem_size % pointee_ctype_size) != 0)
1824                 {
1825                     vogl_error_printf("Mem size is invalid for parameter %s\n", pParam_name);
1826                     print_json_context(pDocument_filename, *pValues);
1827                     return false;
1828                 }
1829
1830                 for (uint val_iter = 0; val_iter < num_vals; val_iter++)
1831                 {
1832                     const json_value &val = pValues->get_value(val_iter);
1833
1834                     uint64_t param_data;
1835                     if (!convert_json_value_to_ctype_data(param_data, val, pointee_ctype, "values", -1, VOGL_VALUE_PARAM, false, *pValues, pDocument_filename))
1836                         return false;
1837
1838                     memcpy(blob.get_ptr() + val_iter * pointee_ctype_size, &param_data, pointee_ctype_size);
1839                 }
1840             }
1841             else if (pParam_obj->has_key("blob_id"))
1842             {
1843                 dynamic_string blob_id;
1844                 pParam_obj->get_value_as_string("blob_id", blob_id);
1845
1846                 if (!pBlob_manager)
1847                 {
1848                     vogl_error_printf("%s: No blob manager specified, blob id %s\n", VOGL_METHOD_NAME, blob_id.get_ptr());
1849                     print_json_context(pDocument_filename, *pParam_obj);
1850                     return false;
1851                 }
1852
1853                 uint8_vec data_blob;
1854                 if (!pBlob_manager->get(blob_id, data_blob))
1855                 {
1856                     vogl_error_printf("%s: Failed retrieving data blob, blob size %" PRIu64 " blob id %s CRC64 0x%" PRIX64 "\n", VOGL_METHOD_NAME, mem_size, blob_id.get_ptr(), blob_crc64);
1857                     print_json_context(pDocument_filename, *pParam_obj);
1858                     return false;
1859                 }
1860
1861                 // TODO: We'll support uint64_t blob sizes eventually
1862                 uint64_t file_size = data_blob.size();
1863                 if (file_size > cUINT32_MAX)
1864                 {
1865                     vogl_error_printf("%s: Blob file %s is too large (%" PRIu64 ")\n", VOGL_METHOD_NAME, blob_id.get_ptr(), file_size);
1866                     print_json_context(pDocument_filename, *pParam_obj);
1867                     return false;
1868                 }
1869
1870                 blob.swap(data_blob);
1871
1872                 if (file_size != mem_size)
1873                 {
1874                     vogl_warning_printf("Unexpected size of blob file %s (should be %" PRIu64 " bytes, but is %" PRIu64 " bytes), reading all of file and hoping for the best\n", blob_id.get_ptr(), mem_size, file_size);
1875                     print_json_context(pDocument_filename, *pParam_obj, cWarningConsoleMessage);
1876                 }
1877             }
1878             else if (pParam_obj->has_key("bytes"))
1879             {
1880                 const json_value &bytes_val = pParam_obj->find_value("bytes");
1881                 const char *pByte_str = bytes_val.as_string_ptr();
1882                 if (!pByte_str)
1883                 {
1884                     vogl_error_printf("Expected bytes value string for parameter %s\n", pFunc_name);
1885                     print_json_context(pDocument_filename, *pParam_obj);
1886                     return false;
1887                 }
1888
1889                 uint bytes_len = vogl_strlen(pByte_str);
1890                 if ((bytes_len != 2 + 2 * mem_size) || (pByte_str[0] != '0') || (pByte_str[1] != 'x'))
1891                 {
1892                     vogl_error_printf("Can't parse bytes value string for parameter %s (either size is bad, or string doesn't start with 0x)\n", pFunc_name);
1893                     print_json_context(pDocument_filename, *pParam_obj);
1894                     return false;
1895                 }
1896
1897                 for (uint i = 0; i < mem_size; i++)
1898                 {
1899                     char c0 = pByte_str[2 + i * 2 + 0];
1900                     char c1 = pByte_str[2 + i * 2 + 1];
1901
1902                     int val_c0 = utils::from_hex(c0);
1903                     int val_c1 = utils::from_hex(c1);
1904
1905                     if ((val_c0 < 0) || (val_c1 < 0))
1906                     {
1907                         vogl_error_printf("Non-hex char in bytes value at byte index %u for parameter %s\n", i, pFunc_name);
1908                         print_json_context(pDocument_filename, *pParam_obj);
1909                         return false;
1910                     }
1911
1912                     blob[(static_cast<uint>(mem_size) - 1) - i] = (val_c0 << 4) | (val_c1);
1913                 }
1914             }
1915             else
1916             {
1917                 vogl_error_printf("Failed parsing array parameter %s\n", pParam_name);
1918                 print_json_context(pDocument_filename, *pParam_obj);
1919                 return false;
1920             }
1921
1922             if (has_blob_crc64)
1923             {
1924                 uint64_t check_crc64 = calc_crc64(CRC64_INIT, blob.get_ptr(), static_cast<size_t>(mem_size));
1925                 if (check_crc64 != blob_crc64)
1926                 {
1927                     vogl_warning_printf("Blob CRC64 check failed for parameter %s (expected 0x%016" PRIX64 " got 0x%016" PRIX64 ")\n", pParam_name, blob_crc64, check_crc64);
1928                     print_json_context(pDocument_filename, *pParam_obj, cWarningConsoleMessage);
1929                 }
1930             }
1931
1932             m_param_data[param_iter] = ptr;
1933
1934             VOGL_ASSERT(param_ctype_desc.m_size <= cUINT8_MAX);
1935             m_param_size[param_iter] = param_ctype_desc.m_size;
1936             m_param_ctype[param_iter] = param_ctype_desc.m_ctype;
1937
1938             client_memory_desc_t &mem_desc = m_client_memory_descs[param_iter];
1939             mem_desc.m_vec_ofs = m_client_memory.size();
1940             mem_desc.m_data_size = blob.size();
1941             mem_desc.m_pointee_ctype = pointee_ctype;
1942
1943             m_client_memory.append(blob.get_ptr(), blob.size());
1944         }
1945     }
1946     else
1947     {
1948         uint64_t param_data;
1949         if (!convert_json_value_to_ctype_data(param_data, val, param_ctype_desc.m_ctype, pParam_name, param_iter, param_class, true, params_node, pDocument_filename))
1950             return false;
1951
1952         m_param_data[param_iter] = 0;
1953         memcpy(&m_param_data[param_iter], &param_data, param_ctype_desc.m_size);
1954
1955         VOGL_ASSERT(param_ctype_desc.m_size <= cUINT8_MAX);
1956         m_param_size[param_iter] = param_ctype_desc.m_size;
1957         m_param_ctype[param_iter] = param_ctype_desc.m_ctype;
1958
1959     } // val.is_object()
1960
1961     return true;
1962 }
1963
1964 //----------------------------------------------------------------------------------------------------------------------
1965 // vogl_trace_packet::get_uint64_from_json_node
1966 // TODO: This is now outdated, we can retrieve uint64_t's directly using members in the json_node class
1967 //----------------------------------------------------------------------------------------------------------------------
1968 bool vogl_trace_packet::get_uint64_from_json_node(const json_node &node, const char *pKey, uint64_t &val, uint64_t def)
1969 {
1970     VOGL_FUNC_TRACER
1971
1972     int key_index = node.find_key(pKey);
1973     if (key_index < 0)
1974     {
1975         val = def;
1976         return false;
1977     }
1978
1979     const json_value &json_val = node.get_value(key_index);
1980
1981     if (json_val.is_string())
1982     {
1983         const char *pBuf = json_val.as_string_ptr();
1984         if (!string_ptr_to_uint64(pBuf, val))
1985         {
1986             val = def;
1987             return false;
1988         }
1989     }
1990     else
1991     {
1992         int64_t ival;
1993         if (!json_val.get_numeric(ival, static_cast<int64_t>(def)))
1994         {
1995             val = def;
1996             return false;
1997         }
1998         VOGL_ASSERT(ival >= 0);
1999         val = static_cast<uint64_t>(ival);
2000     }
2001
2002     return true;
2003 }
2004
2005 //----------------------------------------------------------------------------------------------------------------------
2006 // vogl_trace_packet::force_value_to_type
2007 //----------------------------------------------------------------------------------------------------------------------
2008 bool vogl_trace_packet::force_value_to_type(value &val, value_data_type type)
2009 {
2010     VOGL_FUNC_TRACER
2011
2012     switch (type)
2013     {
2014         case cDTBool:
2015         {
2016             val.set_bool(val.get_bool());
2017             break;
2018         }
2019         case cDTInt8:
2020         {
2021             val.set_int8(val.get_int8());
2022             break;
2023         }
2024         case cDTUInt8:
2025         {
2026             val.set_uint8(val.get_uint8());
2027             break;
2028         }
2029         case cDTInt16:
2030         {
2031             val.set_int16(val.get_int16());
2032             break;
2033         }
2034         case cDTUInt16:
2035         {
2036             val.set_uint16(val.get_uint16());
2037             break;
2038         }
2039         case cDTInt:
2040         {
2041             val.set_int(val.get_int());
2042             break;
2043         }
2044         case cDTUInt:
2045         {
2046             val.set_uint(val.get_uint());
2047             break;
2048         }
2049         case cDTInt64:
2050         {
2051             val.set_int64(val.get_int64());
2052             break;
2053         }
2054         case cDTUInt64:
2055         {
2056             val.set_uint64(val.get_uint64());
2057             break;
2058         }
2059         case cDTFloat:
2060         {
2061             val.set_float(val.get_float());
2062             break;
2063         }
2064         case cDTDouble:
2065         {
2066             val.set_double(val.get_double());
2067             break;
2068         }
2069         case cDTVoidPtr:
2070         {
2071             val.set_void_ptr((void *)val.get_uint64());
2072             break;
2073         }
2074         case cDTString:
2075         {
2076             if (val.get_data_type() != cDTString)
2077                 return false;
2078             break;
2079         }
2080         case cDTStringHash:
2081         {
2082             val.set_string_hash(val.get_string_hash());
2083             break;
2084         }
2085         case cDTBlob:
2086         {
2087             if (val.get_data_type() != cDTBlob)
2088                 return false;
2089             break;
2090         }
2091         case cDTJSONDoc:
2092         {
2093             if (val.get_data_type() != cDTJSONDoc)
2094                 return false;
2095             break;
2096         }
2097         default:
2098             return false;
2099     }
2100
2101     return true;
2102 }
2103
2104 //----------------------------------------------------------------------------------------------------------------------
2105 // vogl_trace_packet::fixup_manually_edited_params
2106 //----------------------------------------------------------------------------------------------------------------------
2107 bool vogl_trace_packet::fixup_manually_edited_params(gl_entrypoint_id_t gl_entrypoint_id, const char *pGL_func_name, uint64_t cur_call_counter)
2108 {
2109     VOGL_FUNC_TRACER
2110
2111     if ((gl_entrypoint_id == VOGL_ENTRYPOINT_glShaderSource) || (gl_entrypoint_id == VOGL_ENTRYPOINT_glShaderSourceARB))
2112     {
2113         //int count = get_param_data(1);
2114         GLsizei count = get_param_value<GLsizei>(1);
2115         if (count)
2116         {
2117             int32 *pLengths = get_param_client_memory<int32>(3);
2118             if ((pLengths) && (get_param_client_memory_data_size(3) == count * sizeof(int32)))
2119             {
2120                 for (GLsizei i = 0; i < count; i++)
2121                 {
2122                     key_value_map::const_iterator it = m_key_value_map.find(i);
2123                     if (it == m_key_value_map.end())
2124                     {
2125                         vogl_error_printf("GL func %s call counter %" PRIu64 ": Failed finding shader source blob string in GL key value map\n", pGL_func_name, cur_call_counter);
2126                         return false;
2127                     }
2128
2129                     const uint8_vec *pBlob = it->second.get_blob();
2130                     if (!pBlob)
2131                     {
2132                         vogl_error_printf("GL func %s call counter %" PRIu64 ": Failed finding shader source blob string in GL key value map\n", pGL_func_name, cur_call_counter);
2133                         return false;
2134                     }
2135
2136                     uint l = pLengths[i];
2137
2138                     if (pBlob->size() != l)
2139                     {
2140                         vogl_warning_printf("GL func %s call counter %" PRIu64 ": Shader source code line %u: blob size is %u bytes, but length field is %u bytes: Fixing up length field to match blob's size\n",
2141                                            pGL_func_name, cur_call_counter, static_cast<uint>(i), pBlob->size(), l);
2142                         pLengths[i] = pBlob->size();
2143                     }
2144                 }
2145             }
2146         }
2147     }
2148
2149     return true;
2150 }
2151
2152 //----------------------------------------------------------------------------------------------------------------------
2153 // vogl_trace_packet::pretty_print_param
2154 //----------------------------------------------------------------------------------------------------------------------
2155 bool vogl_trace_packet::pretty_print(dynamic_string &str, bool type_info) const
2156 {
2157     VOGL_FUNC_TRACER
2158
2159     if (!m_is_valid)
2160     {
2161         str.empty();
2162         return false;
2163     }
2164
2165     dynamic_string return_val;
2166     if (!pretty_print_return_value(return_val, type_info))
2167     {
2168         str.empty();
2169         return false;
2170     }
2171
2172     str.format("%s %s(", return_val.get_ptr(), get_entrypoint_desc().m_pName);
2173
2174     dynamic_string param_val;
2175     for (uint i = 0; i < m_total_params; i++)
2176     {
2177         if (!pretty_print_param(param_val, i, type_info))
2178         {
2179             str.empty();
2180             return false;
2181         }
2182
2183         str += param_val;
2184
2185         if (i != (m_total_params - 1))
2186             str += ", ";
2187     }
2188
2189     str += ")";
2190
2191     return true;
2192 }
2193
2194 //----------------------------------------------------------------------------------------------------------------------
2195 // vogl_trace_packet::pretty_print_param
2196 //----------------------------------------------------------------------------------------------------------------------
2197 bool vogl_trace_packet::pretty_print_param(dynamic_string &str, uint param_index, bool type_info) const
2198 {
2199     VOGL_FUNC_TRACER
2200
2201     str.empty();
2202
2203     if (!m_is_valid)
2204         return false;
2205
2206     const bool is_return_param = has_return_value() && (param_index == m_total_params);
2207
2208     VOGL_ASSERT((param_index < m_total_params) || is_return_param);
2209
2210     uint64_t val_data = m_param_data[param_index];
2211     //uint val_size = m_param_size[param_index];
2212
2213     const vogl_ctype_desc_t &ctype_desc = trace_ctypes()[m_param_ctype[param_index]];
2214
2215     if (type_info)
2216         str.format("(%s) ", ctype_desc.m_pCType);
2217
2218     bool handled = false;
2219
2220     if (ctype_desc.m_is_pointer)
2221     {
2222         const void *pClient_mem = NULL;
2223         uint client_mem_size = 0;
2224
2225         if (m_client_memory_descs[param_index].m_vec_ofs >= 0)
2226         {
2227             pClient_mem = &m_client_memory[m_client_memory_descs[param_index].m_vec_ofs];
2228             client_mem_size = m_client_memory_descs[param_index].m_data_size;
2229         }
2230
2231         if ((pClient_mem) && (client_mem_size))
2232         {
2233             //const vogl_ctype_t pointee_ctype = ctype_desc.m_pointee_ctype;
2234             //const uint pointee_size = (*m_pCTypes)[pointee_ctype].m_size;
2235             //const bool pointee_is_ptr = (*m_pCTypes)[pointee_ctype].m_is_pointer;
2236
2237             bool print_as_cstring = false;
2238             switch (ctype_desc.m_ctype)
2239             {
2240                 case VOGL_CONST_GLUBYTE_PTR:
2241                 case VOGL_CONST_GLCHAR_PTR:
2242                 case VOGL_GLCHARARB_PTR:
2243                 case VOGL_CONST_GLBYTE_PTR:
2244                 case VOGL_GLUBYTE_PTR:
2245                 case VOGL_GLCHAR_PTR:
2246                 case VOGL_CONST_GLCHARARB_PTR:
2247                 {
2248                     if ((client_mem_size <= 64) && (utils::is_buffer_printable(pClient_mem, client_mem_size, true, true)))
2249                     {
2250                         print_as_cstring = true;
2251                         break;
2252                     }
2253                     break;
2254                 }
2255                 default:
2256                     break;
2257             }
2258
2259             if (print_as_cstring)
2260             {
2261                 const char *pStr = reinterpret_cast<const char *>(pClient_mem);
2262                 str.format_append("\"%s\"", pStr);
2263
2264                 handled = true;
2265             }
2266         }
2267     }
2268     else
2269     {
2270         switch (ctype_desc.m_ctype)
2271         {
2272             case VOGL_BOOL:
2273             case VOGL_GLBOOLEAN:
2274             {
2275                 if (val_data == 0)
2276                 {
2277                     str += "false";
2278                     handled = true;
2279                 }
2280                 else if (val_data == 1)
2281                 {
2282                     str += "true";
2283                     handled = true;
2284                 }
2285
2286                 break;
2287             }
2288             case VOGL_GLENUM:
2289             {
2290                 const char *pName = g_gl_enums.find_name(val_data, get_entrypoint_id(), is_return_param ? -1 : param_index);
2291
2292                 if (pName)
2293                 {
2294                     VOGL_ASSERT(g_gl_enums.find_enum(pName) == val_data);
2295
2296                     str += pName;
2297                     handled = true;
2298                 }
2299
2300                 break;
2301             }
2302             case VOGL_FLOAT:
2303             case VOGL_GLFLOAT:
2304             case VOGL_GLCLAMPF:
2305             {
2306                 str.format_append("%f", *reinterpret_cast<const float *>(&val_data));
2307                 handled = true;
2308                 break;
2309             }
2310             case VOGL_GLDOUBLE:
2311             case VOGL_GLCLAMPD:
2312             {
2313                 str.format_append("%f", *reinterpret_cast<const double *>(&val_data));
2314                 handled = true;
2315                 break;
2316             }
2317             case VOGL_GLINT:
2318             case VOGL_INT:
2319             case VOGL_INT32T:
2320             case VOGL_GLSIZEI:
2321             case VOGL_GLFIXED:
2322             {
2323                 str.format_append("%i", *reinterpret_cast<const int32 *>(&val_data));
2324                 handled = true;
2325                 break;
2326             }
2327             case VOGL_GLSHORT:
2328             {
2329                 str.format_append("%i", *reinterpret_cast<const int16 *>(&val_data));
2330                 handled = true;
2331                 break;
2332             }
2333             case VOGL_GLBYTE:
2334             {
2335                 str.format_append("%i", *reinterpret_cast<const int8 *>(&val_data));
2336                 handled = true;
2337                 break;
2338             }
2339             case VOGL_GLINT64:
2340             case VOGL_GLINT64EXT:
2341             {
2342                 str.format_append("%" PRIi64, val_data);
2343                 handled = true;
2344                 break;
2345             }
2346             default:
2347                 break;
2348         }
2349     }
2350
2351     if (!handled)
2352     {
2353         if ((ctype_desc.m_is_pointer) && (!type_info))
2354             str.format_append("(%s) 0x%" PRIX64, ctype_desc.m_pCType, val_data);
2355         else
2356             str.format_append("0x%" PRIX64, val_data);
2357     }
2358
2359     return true;
2360 }
2361
2362 //----------------------------------------------------------------------------------------------------------------------
2363 // vogl_trace_packet::pretty_print_return_value
2364 //----------------------------------------------------------------------------------------------------------------------
2365 bool vogl_trace_packet::pretty_print_return_value(dynamic_string &str, bool type_info) const
2366 {
2367     VOGL_FUNC_TRACER
2368
2369     str.empty();
2370
2371     if (!m_is_valid)
2372         return false;
2373
2374     if (!has_return_value())
2375     {
2376         str = "void";
2377         return true;
2378     }
2379
2380     pretty_print_param(str, m_total_params, type_info);
2381     return true;
2382 }
2383
2384 //----------------------------------------------------------------------------------------------------------------------
2385 // vogl_does_packet_refer_to_program
2386 // This conservatively determines if a trace packet refers to a GL program or ARB program object (there may be some
2387 // false positives in here because ARB program and shader objects live in the same namespace).
2388 //----------------------------------------------------------------------------------------------------------------------
2389 bool vogl_does_packet_refer_to_program(const vogl_trace_packet &gl_packet, GLuint &program)
2390 {
2391     VOGL_FUNC_TRACER
2392
2393     program = 0;
2394
2395     gl_entrypoint_id_t entrypoint_id = gl_packet.get_entrypoint_id();
2396     const gl_entrypoint_desc_t &entrypoint_desc = gl_packet.get_entrypoint_desc();
2397
2398     if ((entrypoint_desc.m_return_namespace == VOGL_NAMESPACE_PROGRAMS) || (entrypoint_id == VOGL_ENTRYPOINT_glCreateProgramObjectARB))
2399     {
2400         program = gl_packet.get_return_value<GLuint>();
2401         return true;
2402     }
2403
2404     for (uint i = 0; i < entrypoint_desc.m_num_params; i++)
2405     {
2406         vogl_namespace_t param_namespace = g_vogl_entrypoint_param_descs[entrypoint_id][i].m_namespace;
2407
2408         if (param_namespace == VOGL_NAMESPACE_PROGRAMS)
2409         {
2410             // TODO: Make sure this never can be a ptr to an array of handles
2411             VOGL_VERIFY(!gl_packet.get_param_ctype_desc(i).m_is_pointer);
2412             program = gl_packet.get_param_value<GLuint>(i);
2413             return true;
2414         }
2415
2416         // Special case the GL_ARB_shader_objects/GL_ARB_vertex_shader GLhandleARB, which alias programs.
2417         // We want to reject handles that are clearly shader objects, and accept everything else.
2418         if ((!i) && (param_namespace == VOGL_NAMESPACE_GLHANDLEARB))
2419         {
2420             bool accept = true;
2421
2422             switch (entrypoint_id)
2423             {
2424                 case VOGL_ENTRYPOINT_glShaderSourceARB:
2425                 case VOGL_ENTRYPOINT_glCompileShaderARB:
2426                 {
2427                     accept = false;
2428                     break;
2429                 }
2430                 default:
2431                     break;
2432             }
2433
2434             if (accept)
2435             {
2436                 // TODO: Make sure this never can be a ptr to an array of handles
2437                 VOGL_VERIFY(!gl_packet.get_param_ctype_desc(i).m_is_pointer);
2438                 program = gl_packet.get_param_value<GLuint>(i);
2439                 return true;
2440             }
2441         }
2442     }
2443
2444     return false;
2445 }
2446
2447 //----------------------------------------------------------------------------------------------------------------------
2448 // vogl_write_glInternalTraceCommandRAD
2449 //----------------------------------------------------------------------------------------------------------------------
2450 bool vogl_write_glInternalTraceCommandRAD(data_stream &stream, const vogl_ctypes *pCTypes, GLuint cmd, GLuint size, const GLubyte *data)
2451 {
2452     VOGL_FUNC_TRACER
2453
2454     vogl_trace_packet packet(pCTypes);
2455
2456     packet.begin_construction(VOGL_ENTRYPOINT_glInternalTraceCommandRAD, 0, 0, 0, utils::RDTSC());
2457
2458     uint64_t cur_rdtsc = utils::RDTSC();
2459     packet.set_gl_begin_rdtsc(cur_rdtsc);
2460     packet.set_gl_end_rdtsc(cur_rdtsc + 1);
2461
2462     packet.set_param(0, VOGL_GLUINT, &cmd, sizeof(cmd));
2463     packet.set_param(1, VOGL_GLUINT, &size, sizeof(size));
2464
2465     vogl_trace_ptr_value ptr_val = reinterpret_cast<vogl_trace_ptr_value>(data);
2466     packet.set_param(2, VOGL_CONST_GLUBYTE_PTR, &ptr_val, packet.get_ctypes()->get_pointer_size());
2467
2468     switch (cmd)
2469     {
2470         case cITCRDemarcation:
2471         {
2472             break;
2473         }
2474         case cITCRKeyValueMap:
2475         {
2476             if ((size == sizeof(key_value_map)) && (data))
2477             {
2478                 // Directly jam in the key value map, so it properly serializes as readable JSON.
2479                 packet.get_key_value_map() = *reinterpret_cast<const key_value_map *>(data);
2480             }
2481             else
2482             {
2483                 VOGL_ASSERT_ALWAYS;
2484                 return false;
2485             }
2486             break;
2487         }
2488         default:
2489         {
2490             vogl_error_printf("%s: Unknown trace command type %u\n", VOGL_FUNCTION_NAME, cmd);
2491             VOGL_ASSERT_ALWAYS;
2492             return false;
2493         }
2494     }
2495
2496     packet.end_construction(utils::RDTSC());
2497
2498     return packet.serialize(stream);
2499 }