We received notification today that our trademark on “Silverpine” was registered with the USPTO. We first filed for application back in August, so it’s been a long time coming. While it’s certainly not critical to our business operations, it’s nice to have protection around our brand. I’ll have to get used to writing Silverpine® from now on though.
Disclaimer:
This post comes from my old blog back in 2004. I’m reposting it here so that I don’t lose the content. The source was hand-written HTML so the formatting probably appears a bit off.
About seven years ago I wrote some code to do Mu-Law and A-Law compression. About six years ago, I decided to publish an article along with the source code for it. You can find it here. Anyway, the other day I received an email from someone who had taken it and modified it for what he was doing. In doing so, he found a piece of misinformation that has been in my article since I originally published it. Not a big deal, and I intend to rectify the issue. However, as we chatted over email, I asked him what he was using Mu-Law/A-Law compression for. Here is a clip from our email:
> So if you don’t mind me asking, what are you working on that has 13 bit
> unsigned audio input?
Sure. I am designing a system that monitors lots of radio stations to capture and
detect Emergency Alert System activations – those ugly tones and occasional
voice messages you hear on the radio. The system has some rather incredible
shortcomings for a critical system in 2005. When the emergency management
office triggers an alert they have no way of knowing whether or not radio stations
actually broadcast the alert. Sometimes the system fails – too often. So our
system listens to the stations and sends a report back to Emergency HQ. In
most cases an exception report that shows which stations did not properly
send out the alert. So if the dam is breaking or the nuke is going critical they
can try again, use the phone, send a helicopter or something.
Whoa. Code that I originally wrote to compress audio in children’s games is now being used to help monitor Emergency situations. Talk about your unintended consequences!
-Jon
Disclaimer:
This post comes from my old blog back in 2004. I’m reposting it here so that I don’t lose the content. The source was hand-written HTML so the formatting probably appears a bit off.
|
No matter how careful of a programmer you are, there will always be times when a hardware exception will occur in your code. Perhaps it was a third party component that was the culprit. Perhaps, it was a fellow co-worker that broke something. Or maybe it was Microsoft itself not playing fair with its documentation and/or implementations. Whatever the case, it is often very useful to be able to capture a run-time exception that was generated by the CPU. Sure, you can use a catch(…) to be your fail-safe, but wouldn’t it be great to be able to convert that exception that was generated by the hardware into a C++ exception? I created this class in order to do that very thing. In fact, this class was the basis for my super assert that I created, because I found that I could cause a hardware exception any time I wanted, and by using this C++ hardware exception container, I could access each thread’s stack frame at run-time. This would eventually enable me to perform a stack trace inside of an assert, but I will explain that more in a different tutorial. Anyway, I hope that this is useful to someone. I spent a while digging around in the mire that is Microsoft’s documentation before I put this together. Perhaps this will save someone else time in the future. Enjoy. -BossHogg
#ifndef HARDWARE_EXCEPTION
#define HARDWARE_EXCEPTION 1
enum HWExceptionType
{
eIllegalMemoryAccess = EXCEPTION_ACCESS_VIOLATION,
eUnexpectedBreakpoint = EXCEPTION_BREAKPOINT,
eDataTypeMisalignment = EXCEPTION_DATATYPE_MISALIGNMENT,
eSingleStepInstruction = EXCEPTION_SINGLE_STEP,
eArrayBoundsExceeded = EXCEPTION_ARRAY_BOUNDS_EXCEEDED,
eDenormalFloat = EXCEPTION_FLT_DENORMAL_OPERAND,
eFloatDivideByZero = EXCEPTION_FLT_DIVIDE_BY_ZERO,
eFloatInexactResult = EXCEPTION_FLT_INEXACT_RESULT,
eFloatInvalidOperation = EXCEPTION_FLT_INVALID_OPERATION,
eFloatOverflow = EXCEPTION_FLT_OVERFLOW,
eFloatStackCorrupted = EXCEPTION_FLT_STACK_CHECK,
eFloatUnderflow = EXCEPTION_FLT_UNDERFLOW,
eIntDivideByZero = EXCEPTION_INT_DIVIDE_BY_ZERO,
eIntOverflow = EXCEPTION_INT_OVERFLOW,
ePrivelegedInstruction = EXCEPTION_PRIV_INSTRUCTION,
eUncontinuableException = EXCEPTION_NONCONTINUABLE_EXCEPTION
};
class HWException
{
public:
HWException(HWExceptionType aType,
EXCEPTION_POINTERS* pExp):
itsCategory(aType),
itsPointers(pExp),
itsLocation(pExp->ExceptionRecord->ExceptionAddress)
{
}
HWExceptionType GetCategory() const {return itsCategory;}
DWORD GetLocation() const {return itsLocation;}
EXCEPTION_POINTERS* GetSysPointer()const {return itsPointers;}
protected:
HWExceptionType itsCategory;
DWORD itsLocation;
EXCEPTION_POINTERS* itsPointers;
};
static void HWTranslateException(unsigned int u,
EXCEPTION_POINTERS* pExp)
{
throw HWException((HWExceptionType)u,pExp);
}
#endif
///////////////////////////////////////////////////////////////////////
Example usage:
///////////////////////////////////////////////////////////////////////
#include "windows.h"
#include "HWException.h"
int main()
{
//Note, setting the exception translator must be done
//on a per thread basis.
_set_se_translator(HWTranslateException);
try {
//This will cause an access violation
char* ptr = NULL;
*ptr = 5;
}
catch (HWException& e)
{
//We can now know both the type and the
//memory location of the instruction that
//caused the exception. Cool!
HWExceptionType exceptionType = e.GetCategory();
DWORD address = e.GetLocation();
}
catch (...)
{
//If we got here, then it was some other kind
//of C++ exception...
}
return 0;
}
|
Disclaimer:
This post comes from my old blog back in 2004. I’m reposting it here so that I don’t lose the content. The source was hand-written HTML so the formatting probably appears a bit off.
CPU Detection Code
|
I dug this code up from a project that I worked on a long time ago. Unfortunately, it is woefully out of date, especially with any of the latest P4 processors. Also unfortunately, I don’t have a large suite of machines on which to test this, however, I have verified a large number of these, but not all. Also missing from the list are any AMD processors since my old companies didn’t explicitly support AMD. Oh, well. As always, this code is to be used at your own expense, and I guess with this particular set of code, that means a little more. Anyway, I hope someone finds this interesting, and if you have any questions, feel free to ask. -BossHogg
bool QueryCPUID(); bool Is8086() } bool Is80286() } bool Is80386() } bool QueryCPUID() } bool QueryMMX() } bool QueryHyperThreading() } void QueryVendorString(char* string) |