Archive | Pointers

My thoughts on Operator Overloading are hardly a secret. Some languages, such as Haskell, support it in a sane manner. Some languages, such as C++ don’t. Either way though, I’m not a fan.

That said, there is one case where I support it; when what you are trying to overload an operator to do makes sense for your type. In other words, if it makes sense to multiply an Employee object, feel free to overload the multiplication operator. Since we don’t usually model mating when we implement an employee object, I don’t usually approve.

## Multiplying a Fraction

However, if we have a fraction class, that has a numerator and denominator component, overloading the multiplication operator suddenly becomes reasonable:

``````frac<T> operator *(const frac<T> & rhs) const
{
return frac<T>(numer * rhs.numer, denom * rhs.denom);
};``````

In C++, many of the built in operators are available to be overloaded. You can do basically anything in an operator overload, but if you do, that makes you a bad person. Here we have a straightforward implementation, that I’m going to assume you don’t need to have explained to you. But let’s talk `const` correctness.

In this signature, the `const` appears twice. The right hand side argument is a `const` reference. Since this is a reference, no copy occurs, but with references can come mutability. The `const` here prevents any mutation from occurring. There is also a `const` at the end of the signature. That means that this function cannot modify the `this` pointer.

This function returns a new `frac<t>`, so no need for `const` there.

## Convert a Fraction to a Double

Next, you can overload the casting operator, and if you are a good person you’ll use this for type conversions. Let’s implement `(double)` for our fraction:

``````operator double() const
{
return (double) numer / denom;
}``````

This code is pretty straight forward. We divide the numerator by the denominator, and cast it to double in case integer division occurs. Cast operator overloads don’t have a return type, which is a bit strange but something we can work with.

## Streaming operators

Finally, I’d like to talk about streaming operator overloads. For any overloaded operator, there are two forms: member and non-member. Member overloads take `n - 1` arguments, where the minus 1 is the current object (and the left hand side). Non member overloads can’t access the this pointer, so they need to take the left hand side as a parameter.

Member overloads obviously have access to private class members, which makes them more powerful than non-member. Which leads us to the streaming operators. Streaming operators need to return `std::ostream &`, so they must be non-member. The problem is that we want to print the private numerator and denominator fields. The solution? make it a friend:

``````friend std::ostream & operator <<(std::ostream & lhs,
const frac<T> & rhs)
{
lhs << rhs.numer << '/' << rhs.denom;
return lhs;
};``````

With that problem solved, this function becomes pretty straight forward. We stream the fields, formatted correctly, into the left hand side `std::ostream &`, then we return the left hand side argument for further use by the next part of the streaming chain.

Lately, I’ve been writing a lot of Haskell. If you’ve been following the blog, you likely are aware of this. However, I’ve been feeling the itch to try something different. I’ve been dabbling in things here and there, but for some reason I just can’t settle into a groove. It seems that Haskell has ruined programming for me.

Why? Is it the functional purity of Haskell? Is it the way that lazy evaluation changes the way you think about programming? Is it the sublime type system that catches whole classes of bugs at compile time? No, I’m afraid not. My issue is much more basic; semicolons and angle brackets.

…should you choose to accept it: write a function `fun` that does the following: takes an integer argument `acc`, and two arguments of the same generic type. This function should enforce that the two generic arguments cannot be changed. This function calls another function `given` that takes two arguments of the same generic type, that also cannot be changed. `given` does something, then returns an integer as a result. `given` can fail!

After calling `given`, if it failed, return `acc - 1`, if it succeeded, return its result + `acc`.

## In C

C is a pretty simple language. I like simplicity (it’s the whole premise of this post, right?) but C’s simplicity turns into overly verbose code in the face of the requirements of `fun`. Here is the signature of `given`

``````// please ensure that lhs and rhs have the same type
int given(int * result,
void const * const lhs,
void const * const rhs)``````

So, what’s going on here? In C, the dominant idiom for indicating success or failure is to return an error code, thus we return an `int`. However, this isn’t our return value! We use the out parameter `result` instead. Finally, we have `lhs` and `rhs`, which have the confusing types `void const * const`. These read as “constant pointer to constant void”, and ensures that neither the where the pointer points, or the value of what it points to can change. (thus documenting the requirement that it not change its arguments!) Finally, we have our comment asking the caller to pretty please, ensure `lhs` and `rhs` have the same type. There is no way in C to ensure two `void *` are actually the same type, so this is the best we can do… Now, let’s see my implementation of `fun`:

``````// please ensure that lhs and rhs have the same type
int fun(int acc,
void const * const lhs,
void const * const rhs)
{
int res = 0;
if (given(&res, lhs, rhs))
{
return acc + res;
}
else
{
return acc - 1;
}
}``````

We have the same confusing sort of signature, except here the return value is our actual return value, and `acc` is not an out parameter. (which is really obvious, right?)

Inside of this function, we allocate `res` on the stack and initialize it to 0. Then we call `given` with the address of `res`, and `lhs` and `rhs`. Taking the address of a something requires a special symbol. This function is called within an if block because `given` returns 0 on failure and something on success.

Some of this noise can be reduced, but overall it’s pretty minimal. The use of `void` pointers and our type checking comment are troubling, but that’s not really the point of this post. However, the many semicolons, curly braces, and commas add a lot of clutter.

Noise level: Moderate
Strangeness: High
Confidence that there are no bugs in my implementation: Very Low

## In C++

Next, let’s check out some C++. Here is the signature of `given`:

``````// throws an std::exception on failure!
template <typename T> int given(const T & lhs,
const T & rhs)``````

To me, this is kind of a wash from the C implementation. On one hand, we have this `template <typename T>` silliness, on the other hand we don’t have an out parameter, we only have one `const` per argument, and the compiler can actually enforce that `lhs` is of the same type as `rhs`. Next, the implementation:

``````template <typename T> int fun(int acc,
const T & lhs,
const T & rhs)
{
try
{
return acc + given<T>(lhs, rhs);
}
catch (std::exception & e)
{
return acc - 1;
}
}``````

Here we have that same yucky sort of signature, and we have these `try` and `catch` blocks. Personally, I don’t care for exceptions. However, they are a tried and true strategy accepted by the majority of the programming community, and who am I to dispute that? However, what I don’t like is the fact that we have no indication that `given` can throw. We had to read a comment. Additional weirdness here is the call to `given`: `given<T>(lhs, rhs)`. Why do I have to do `<T>`?

The usual complaints about curly braces and semicolons apply here as well.

Noise Level: High
Strangeness: Low
Confidence that there are no bugs in my implementation: Low

## In Rust

A newcomer to the scene is Rust. Rust is a low level systems programming language that has a very strong emphasis on safety. Excellent, right? Let’s see the signature of `given`:

``fn given<T>(lhs: &T, rhs: &T) -> Option<i64>``

… eew. We have twice as many angle brackets as the C++ implementation did, which is unfortunate. We’ve also added some colons. On the plus side, we have option types in rust, so no icky exceptions! Let’s see my implementation of `fun`:

``````fn fun<T>(acc: i64, lhs: &T, rhs: &T) -> i64
{
let res = given(&lhs, &rhs);
let ret = match res {
Some(x) => acc + x,
None => acc - 1,
};
ret
}``````

… and things get strange. Let’s go through this line by line:

`fn fun<T>(acc: i64, lhs: &T, rhs: &T) -> i64`: A bit noisier than I’d like, but perfectly reasonable.

`let res = given(&lhs, &rhs);`: Here we call `given`, and for some reason I have to put an & in front of `lhs` and `rhs`. At least rustc inferred the type for us!

`let ret = match res {};`: Yay, Rust has pattern matching! It’s a bit unfortunate about all those curly braces and semicolons though…

`Some(x) => acc + x,`: Nothing wrong here, in a world where commas and such are a thing…

`None => acc - 1,`: And here we have the last pattern of this match block. Why is there a comma there?! For reasons that science will never explain, in Rust, you have to put commas after the last entry in things like this! This oddity extends to structs and enums as well…

`ret`: Finally, we return. No, `ret` isn’t a keyword, it’s a variable that I bound in my pattern match. Notice the lack of a semicolon. In Rust, the last line in a function is the return value, and does not have a semicolon! However, rust has a `return` statement for early returns, and this does take a semicolon. Yes, you can use a `return` statement here, but according to the docs doing this makes you a bad person.

Noise Level: Very High
Strangeness: High
Confidence that there are no bugs in my implementation: Reasonable

Finally, let’s take a look at what I consider to be a reasonable syntax: Haskell. The signature of `given` is as follows:

``given :: a -> a -> Maybe Int``

Once you learn to read Haskell, you’ll see how simple this is. `given` is a function that takes an a, another a, and returns a `Maybe Int`. Next, let’s see my implementation of `fun`:

``````fun :: Int -> a -> a -> Int
fun acc lhs rhs = case given lhs rhs of
Just res -> acc + res
_ -> acc - 1``````

Not counting the optional function signature, this is 3 lines. The first is our pattern match, which calls `given`. The second line handles success, and the third handles failure. There is no return statement here, the result of the expression is the return value. And unlike Rust, there’s no special case that breaks the mold.

Noise Level: Low
Strangeness: Low (If your definition of strange isn’t “doesn’t look like C”)
Confidence that there are no bugs in my implementation: High

## Which Brings Me To My Point

Honestly, I believe that the reason for all of this is: “We’ll make our language look like C so that we don’t scare people away!” Personally, I believe that this is a sad state of affairs.

Strictly speaking, I do mean to criticize. C, C++, and Rust are all fine languages. They do what they set out to do, and do it well. Many people successfully use these languages every day! They are all languages worth knowing and languages worth using. However, there is no reason for all these glyphs and extra keywords!

My top feature for the new version of C++: Get rid of all uses of the angle bracket!

My top feature for the new version of Rust: Get rid of those trailing commas and the return statement!

Of course this will never happen, and for good reason: It will cause massive breakages in everybody’s codebases. But a man can dream…

It’s often been said that functional programming just isn’t cut out for certain tasks. File IO? Please… Databases? Forget about it!

I’ve always figured that the humble Doubly Linked list was on this list. After all, how do we implement these in C? An implementation would probably look something like this:

``````struct _DList
{
struct DList * next;
struct DList * prev;
void * element;
} DList;``````

In this case, the element pointed to by prev and next have pointers to this element, if they aren’t NULL. The Doubly Linked list isn’t exactly a complicated structure, this is basically the way to do it. So, how would we do this in Haskell?

In the past, I’ve thought there were three answers to this question:

1) Use C pointers. This would involve use of `unsafePerformIO`, and you’d be a monster.

2) Use a singly linked list, and pretend it’s doubly linked. This would involve a “prev” function that just walks from the beginning of the list to the element before the current one. You’d be an even bigger monster than the guy who did option 1.

3) Don’t use a doubly linked list. To me, this is actually reasonable. In a world where arrays are basically always better, the only reason to use a list is because they’re very easy to deal with. If you need the level of complexity of a doubly linked list, you’re probably just better off with a different data structure.

But recently, I thought of a way to implement a doubly linked list in Haskell without being a bad person.

## Preserved Here For Posterity

The implementation is actually quite simple. Here’s our type:

``````data DoublyLinkedList a =
DList [a] [a] |
Nil``````

Obviously, we have our `Nil` type for the empty list. We also have DList, which has two lists. Why two? On the left, we have the previous elements. This starts empty. On the right, we have our next elements. As we walk the list, we pop elements from the head of the right list to the head of the left list. The head of the right list is our current element. Let’s see some functions:

``````get :: DoublyLinkedList a -> a
get (DList _ (x:xs)) = x``````

This function returns the “current” element; the element at the current position in the list.

``````next :: DoublyLinkedList a -> DoublyLinkedList a
next (DList _ []) = undefined
next (DList prev (c:next)) = DList (c:prev) next

prev (DList [] _) = undefined
prev (DList (c:prev) next) = DList prev (c:next)``````

These two functions move the cursor forward or backward. As you can see, when next is called, the current element is popped from the next list, and pushed onto the previous list. The opposite happens when prev is called. I’ve left the edge cases undefined, but a real implementation should do something sane here. (return a Maybe, throw an exception, etc…)

``````insert :: DoublyLinkedList a -> a -> DoublyLinkedList a
insert Nil e = DList [] [e]
insert (DList prev next) e = DList prev (e:next)``````

Elements are inserted in front of the current element.

``````makeDouble :: [a] -> DoublyLinkedList a
makeDouble [] = Nil
makeDouble l = DList [] l``````

…and it is trivial to convert a singly linked list into a doubly linked list. We can even add a pretty show instance!

``````instance (Show a) => Show (DoublyLinkedList a) where
show Nil = "Nil"
show (DList prev (c:next)) = (show \$ reverse prev) ++
"*[" ++
(show c) ++
"]*" ++
show next``````

Obviously, we could go crazy and make a Monad instance and other things, but you get the idea. The final solution was very simple. One could even say simpler than the C version as you don’t have to worry about updating the next and prev pointers when adding elements. Sure, it took a bit of thought, but like many things in Haskell, the result was simple and elegant.

# DMP Photo Booth 1.0

Well, the day has come and gone. DMP Photo Booth’s final test on June 21st went off without issue, and DMP Photo Booth has left Beta and is now considered “production ready”. The initial 1.0 release can be found on GitHub.

The significance of June 21st is the very reason DMP Photo Booth was created; the 21st is the day of my wedding. My wife wanted a photo booth for the reception. We looked into renting a photo booth, but it turns out that they run around \$1,000. I turned to open source. Some quick googling turned up some options, but they were all personal projects or out of date. Sure I could get somebody else’s project working, but what’s the fun in that? I decided that we didn’t need to rent one, or download one, I could build it!

In late 2013, I set to work in earnest. I had a couple of months of downtime in school, and since I’m not currently working it was the perfect time. I decided I had three main objectives for this project: get some arduino experience, get some GTK+ experience, and do this all as portably as possible. I had initially decided to mostly ignore GLib and focus on GTK, but slowly I grew to appreciate GLib for what it is: the standard library that C never had. First I used GModule to handle shared libraries in a portable manner. Next I decided to use GLib primitives to keep from having to deal with cross-platform type wonkiness. Next, having grown tired of dealing with return codes, I refactored the project to use GLib’s exception replacement: GError.

## Lessons Learned

It’s not all roses and puppies though. There are certainly things I’d do differently. DMP Photo Booth is developed in an Object Oriented style, passing opaque structs with “method” functions that operate on them. Each component of the program are organized into their own source file with file scoped globals scattered throughout. Said globals are protected by mutexes to create a semblance of thread safety. That said, threading issues have been a major thorn in my side. Long story short: I regret this design choice. While I still feel that this is the correct way to structure C code, and that if globals are required, this is the correct way to handle them; I feel that I should have made more of an effort to limit side effects. Recently, I’ve spent some time doing functional programming, and if I could do it again I’d try to write in a more functional style. Fortunately for me, this is something that a little refactoring could help with.

Additionally, one thing I thought would be a major help is something that began to be a major thorn in my side: NetBeans. As the size of the project grew, NetBeans got slower and slower. It seemed that I spent more time fiddling with IDE settings than actually coding. Even worse is that the IDE-generated makefile is so convoluted that it’s extremely difficult to modify by hand in a satisfying way. I’ve always coded with and IDE so I wouldn’t have even considered not using one, but then I spent some time with Haskell. One of Haskell’s “problems” is that it doesn’t have good IDE support. It doesn’t seem like any IDE really handles it well, so most people use Emacs. Personally, I haven’t really warmed up to Emacs, but GEdit has syntax highlighting for Haskell and a built-in terminal for GHCI. GEdit also has syntax highlighting for C. Next time, I will seriously consider using a lighter-weight text editor for a C project. All this said, I think NetBeans for Java remains the way to go.

## What’s Next

Like any program, version 1.0 is just one of many versions. There certainly remains a lot of work to do with DMP Photo Booth. Some major items you are likely to see whenever I get around to working on DMP Photo Booth some more:

#### Options Dialog

I think anybody who has seen it will agree: the options dialog in DMP Photo Booth is bad. It’s poorly organized, and kind of wonky. Personally, I modify settings using the `.rc` file, which is telling. This is certainly a high-priority improvement.

#### Functional Refactor

Like I said above, the code could use a pass to limit side effects. Funtions need to have their side effects limited, and globals need to be eliminated unless absolutely necessary. However, C is not a functional language. While one could argue that function pointers enable functional programming in C, this is a very pedantic argument. I won’t be going crazy with functional programming techniques. There will be no Monads, or for loops being turned into mappings of function pointers.

#### Optional Module API

An idea I’ve had on the back burner for a while is an optional module API. This would be used for very specific quality-of-life things. For instance, a module could provide a GTK widget to be shown in the options dialog. Any module that doesn’t want to implement any or all of the optional API can just ignore it. The module loading function will gracefully handle the `dlsym` failure, just treating it as it is: declining to implement the API. I have no plans to change the current existing API, so all you module developers can rest easy!

#### User Interface Module

It occurred to me that it might be good to have a UI module. This would provide the UI, and wouldn’t be tied to the trigger/printer/camera module start/stop system. This module would be loaded at startup and unloaded on shutdown. This would allow the Photo Booth to use different widget toolkits: QT, Curses, Cocoa, WinForms, or whatever else. Under this scheme, the current GTK+ interface would be abstracted into the reference UI Module.

# C With Classes

No, I’m not taking an ignorant view on the nature of C++, I mean exactly that: C, with classes. “But C doesn’t have classes” you say. Technically you would be right.

One of the things I find great about C is that while it is very simple, you can build anything with it. An analogy that I’m fond of is Lego. If programming is like Lego bricks, then C is the basic tub of square bricks. They are simple, and universally useful.

Meanwhile C++, Java, C#, and whatever other fancy, “feature rich” langauge you can think of are like the specialized kits. They come with all sorts of fancy curved and bendy pieces. These pieces can be used to make some cool things but are only useful in very specific situations. If you’ve ever played with Lego, you know that the fancy kits still come with a few regular square bricks.

One might think you’d need the fancy slanted bricks to make a truly intricate model, but one would be wrong. If you scale things up, your basic square bricks can create just as intricate models as any fancy kit.

Back on the subject of programming, many large projects these days make heavy use of object-oriented features. Data is logically grouped into objects, which have behaviors. This model of programming is facilitated by “Object-Oriented” languages, which have these types of structures built into the language.

C does not have a class keyword, and classes are not built into the language. This doesn’t mean that you can’t do object-oriented programming in C.

## What Constitutes a Class

Books have been written about this topic, and given the audience of a programming blog, you’ve probably already read one or two of them. The main goal of a class is to centralize related data and logic into a single unit, and to insulate the rest of the program from it. A class contains data describing what it is and what it does, and has methods that act on that data. The class keeps this data hidden as much as possible from the rest of the program. A printer class might need to keep a bunch of state data, but the rest of the program doesn’t need to know about that. All the rest of the program needs to know is if the printer class is ready to accept a job, and how to tell the printer class to print.

This is called separation of concerns, and it’s good because it prevents the user of a class from getting bogged down in the nitty-gritty of an operation.

Meanwhile, C has structs. A struct has no access control, and no methods. Anybody who has ever attempted to deal with something like termios know what a nightmare this can become.

I’m here to tell you that it doesn’t have to be this way.

## What Could Be

What should object-oriented programming look like in C? To answer that question, let’s really break down the idea of a class. At the core, a class has three parts: methods, data, and access control. Data is state that a class maintains, methods are functions that act upon a class, and access control is how a class decides if the outside world should be able to see data or a method. All three of these things can be accomplished in C.

#### Data

This is the easiest part. Data can be grouped in C using a `struct`, and this is how we will be doing it.

#### Methods

Now things are getting a bit trickier. While C has function pointers, and these can be stored in a struct, this is not how we will be doing it. In most object-oriented languages, you can access a `this` within the body of a method to access data within the class. You can think of this as an implicit extra argument to the function. Similarly, to approximate methods within C, we will be using functions. The first argument to any “Method” should be a pointer to the data struct.

#### Access Control

This is accomplished by way of an “opaque struct”. That is, a struct that is forward declared in the header, but without a definition. This struct can be passed around, but its members can’t be directly accessed because they haven’t been forwardly declared. In this manner, we approximate `private` data. If we want our class to have public fields, we can forwardly declare a transparent struct. This struct should have a pointer to a second opaque struct that will serve as its private data.

## A Contrived Example

This is all a lot clearer with an example. First let’s take a look at the header for class `contrived`:

``````typedef struct _contrived
{
int first;
struct c_priv * priv;
} contrived;

contrived * dmp_contrived_new(int first,
int second,
int third);

void dmp_contrived_free(contrived * to_free);

int dmp_contrived_sum(contrived * ths);

int dmp_contrived_get_second(contrived * ths);

void dmp_contrived_set_second(contrived * ths,
int to_set);``````

First, we have our class struct. Class contrived has 1 public field, `first`, and a pointer to an opaque private struct. Users of this class can directly access `first`, but they can’t access anything within the private area.

Next we have a constructor and a destructor. If a user of the class wants to create or delete a `contrived`, they would not use `malloc` and friends, they would use the constructor and destructor. This solves another problem of C, complicated manual memory management.

After that, we have three methods: `dmp_contrived_sum`, a method on `contrived`, and a getter and setter for `second`, a private field. Similar to any other object-oriented language, we are free to break our encapsulation by providing getters and setters.

Now, let’s take a look at our implementation:

``````struct c_priv
{
int second;
int thrid;
};``````

First we have the definition of the private area. Since this is only in the `.c` file, it is not visible to the rest of the program.

``````contrived * dmp_contrived_new(int first,
int second,
int third)
{
contrived * working = malloc(sizeof(contrived));
working->first = first;
working->priv = malloc(sizeof(struct c_priv));
working->priv->second = second;
working->priv->thrid = third;
return working;
}``````

Next we have our constructor. It takes care of calls to `malloc`, and data initialization. When it’s done, it returns the newly created pointer.

``````void dmp_contrived_free(contrived * to_free)
{
free(to_free->priv);
free(to_free);
}``````

The destructor ensures all memory is freed. This way, a user never needs to worry about freeing data. Since this pointer has a pointer in it, it would be very easy to forget the nested pointer and leak memory. This problem is solved by taking the responsibility away from the user.

``````int dmp_contrived_sum(contrived * ths)
{
return ths->first +
ths->priv->second +
ths->priv->thrid;
}

int dmp_contrived_get_second(contrived * ths)
{
return ths->priv->second;
}

void dmp_contrived_set_second(contrived * ths, int to_set)
{
ths->priv->second = to_set;
}``````

Finally, we have our contrived methods. They deal with the nitty-gritty of struct manipulation, much like traditional class members.

You may have noticed that I do not have any private methods. This is also very easy to implement; just create a static function in the same `.c` file. This function will not be visible outside the file it resides in, making it private.

This is also possible in C. Basically, you can just include a pointer to a base class object in a derived class object. There also frameworks such as GObject that can facilitate this in a more robust way.

However, if you find yourself making heavy use of inheritance, I cannot advocate the use of C over a traditional object-oriented language. “Inheritance” in C makes heavy use of void pointers, and this vastly degrades the type safety of your program. While it can be done, and even done safely if you try hard enough, I feel that it is no longer worth it. Object oriented languages with these features built into them will vastly improve your productivity at this point.

But if your program just makes use of a few of your own classes, and those provided by libraries, then there’s no reason you should feel obligated to use an object-oriented language. Indeed, for basic objects, C is more than enough for anybody.

# The Smallest Things…

For the last few weeks I’ve been banging my head against a problem. I need my Photo Booth application to actually take a photo. It seems like such a simple thing, but it has actually been one of the most difficult ones I’ve encountered. Like the Great PostScript Debacle and the Mystery of the GAsyncQueue Ref before it, I spent a good week banging my head against the wall. I even took a day off to write an entire Lua Camera Module just so I could shell out and call a command line utility to try to work around it.

The best part? If you’ve been following the blog, you know I’m kind of a crybaby about poor documentation. While libgphoto2 is certainly a repeat offender on this count, no amount of documentation could have prepared me for what was to come.

But first, let’s go over my now-working implementation.

## Taking A Picture With Libgphoto2

To take a picture, we need 3 functions:

• `gint dmp_cm_camera_init()`
• `gint dmp_cm_camera_finalize()`
• `gint dmp_cm_camera_capture(gchar * location)`

#### dmp_cm_camera_init

``````gint dmp_cm_camera_init()
{
context = gp_context_new();
(GPLogFunc) dmp_cm_log_func,
NULL);
if (gp_camera_new(&camera) != GP_OK)
{
//error handling
}
if (gp_camera_init(camera, context) != GP_OK)
{
//error handling
}
return DMP_PB_SUCCESS;
}``````

There are two main structs: `Camera` and `GPContext`. A `Camera` represents, shockingly, a camera attached to the system. A `GPContext` represents work to be done. Callback functions, data, and other things of that nature.

First we create a new context. Next we can add a log function to accept log messages from libgphoto2. In my experience, no matter what you do you will get a lot of useless garbage output from libgphoto2. For this reason, I recommend you don’t just let this spew to the console or some other user-facing output. At first, I was going to send this to the console queue, but I’ve since decided against using this feature. It is good to know about though in case you need it for troubleshooting.

After all of that is done, we need to create our camera object, and initialize libgphoto2.

#### dmp_cm_camera_finalize

``````gint dmp_cm_camera_finalize()
{
gp_camera_unref(camera);
gp_context_unref(context);
return DMP_PB_SUCCESS;
}``````

Nothing particularly tricky there. We need to ensure we free our memory when we’re done, so we unref our camera and context. Having seen these two functions, you may be wondering to yourself: “Are we dealing with GObjects here?” Luckily for us, there is a simple test for this:

``g_assert(G_IS_OBJECT(camera));``

I’ll spare you the effort of running this test: the assertion fails. Too bad really, but it is what it is. Libgphoto2 just uses function names similar to GObject.

#### dmp_cm_camera_capture

``````gint dmp_cm_camera_capture(gchar * location)
{
CameraFile * file;
CameraFilePath camera_file_path;
gint fd;
CameraEventType event_type;
void * event_data;

if (gp_camera_capture(camera,
GP_CAPTURE_IMAGE,
&camera_file_path,
context) != GP_OK)
{
//error handling
}

if ((fd = g_open(location, O_CREAT | O_WRONLY,
0644)) == -1)
{
//error handling
}

do
{
gp_camera_wait_for_event(camera,
1000,
&event_type,
&event_data,
context);
if (event_type ==
GP_EVENT_CAPTURE_COMPLETE) break;
}
while(event_type != GP_EVENT_TIMEOUT);

if (gp_file_new_from_fd(&file, fd) != GP_OK)
{
//error handling
}

do
{
gp_camera_wait_for_event(camera,
1000,
&event_type,
&event_data,
context);
}
while(event_type != GP_EVENT_TIMEOUT);

if (gp_camera_file_get(camera,
camera_file_path.folder,
camera_file_path.name,
GP_FILE_TYPE_NORMAL,
file,
context) != GP_OK)
{
//error handling
}

if (gp_camera_file_delete(camera,
camera_file_path.folder,
camera_file_path.name,
context) != GP_OK)
{
//error handling
}
gp_file_free(file);

do
{
gp_camera_wait_for_event(camera,
1000,
&event_type,
&event_data,
context);
}
while(event_type != GP_EVENT_TIMEOUT);

return DMP_PB_SUCCESS;
}``````

This function is where the meat of the process is. First we need to do some housekeeping. We create a `CameraFile` pointer to represent the actual image file, and a `CameraFilePath` struct to represent the path to the file. We also create an int for use as a file descriptor, a `CameraEventType` and void pointer for our calls to `gp_cmaera_wait_for_event`

Next we call `gp_camera_capture` which triggers the camera to take a picture. After that is done, we’ll open a file descriptor to save the image. You’ll notice that the call to `g_open` is enclosed in parentheses. THIS STEP IS 100% MANDATORY Don’t omit it, you’ll be sorry. More on this in a bit.

Next, we wait for the camera to finish working. The camera uses an event system; it will emit events when things happen. After releasing the shutter, the camera has other work to do before it is “done taking the picture”. If you try to do the next step before the camera is ready libgphoto2 will spew garbage to your STDOUT and you’ll have to ctrl+c to fix it. To avoid this, we call `gp_camera_wait_for_event` while ` event_type != GP_EVENT_TIMEOUT || GP_EVENT_CAPTURE_COMPLETE` Capture complete is obviously the event we care about, but it may have happened while we weren’t listening for it. In that case, we’ll settle for a timeout.

Next up is instantiating our CameraFile. We use our File descriptor that we just opened to call `gp_file_new_from_fd`. Unfortunately there is no `gp_file_new_from_file_pointer` which means that this call is POSIX only, and there’s no portable substitute.

After creating our `CameraFile` we download the image we just took by calling `gp_camera_file_get` and then delete the file from the camera using `gp_camera_file_delete`

Finally we make sure no events are pending, then return.

## Why Are You Yelling At Me?

Good question. The block in question of course is

``````if ((fd = g_open(location, O_CREAT | O_WRONLY,
0644)) == -1)
{
//error handling
}``````

Inside of that if block, I’m assigning a value and testing the result inside of the if statement. This operation is about a 2 out of 10 on the cleverness scale. Normally, you could omit the parentheses around `(fd = g_open(location, O_CREAT | O_WRONLY, 0644)`. However, if we do it here, things go off the rails. Not right away, of course, but a few function calls later we get to:

``````if (gp_camera_file_get(camera,
camera_file_path.folder,
camera_file_path.name,
GP_FILE_TYPE_NORMAL,
file,
context) != GP_OK)
{
//error handling
}``````

As soon as `gp_camera_file_get(...)` is evaluated, this is spewed to the console:

…and you have no choice but to kill the process.

Why does this happen? I have no idea. Why does enclosing the call to `g_open` in parenthesis fix it? Again, no idea. And it only happens here too. I just tried to modify the examples that come with libgphoto2 to reproduce the error and get that screenshot for this post, but it works fine there. Knowing my luck, if you download and build the program, it’ll work fine for you.

As long as it works, I guess…

# Last Train Out Of Cairo

After recovering from Christmas, and the terrible events of late 2013, it’s time to put my nose back to the grindstone with the printer module. My latest task: make the printer module not be terrible.

What’s so bad about the printer module, you ask? The short answer is all the things. All bad. Every single one of them. It’s slow. It doesn’t print right. It consumes way too much resources. It makes my cat sad.

## The Brotherhood Of The Printer Developer

It all started when trying to figure out this whole printing thing. It turns out that printer development is one of those secret development clubs. There are no tutorials, the API documentation leaves something to be desired, and printing in Linux is bad in general. In short, it’d be easier to join the Illuminati than to infiltrate the Dark Cabal of Printer Developers.

Just by reading the CUPS API documentation, it’s not difficult to hash out a simple hello world type printer application. However, as anybody who has ever printed something knows, printing has lots of knobs to fiddle. However, the CUPS API does not seem to have functions corresponding to things like paper size and DPI.

During my research, I managed to turn up all of one StackOverflow post on the topic. The gist of it being “you set that up yourself using PostScript and send that to CUPS.” It also provides a sample implementation using Cairo.

## Seems Reasonable

I decided to give it a shot. If nothing else, it would be a good introduction to the Cairo library for me. In my youth, I was fond of using Java’s Graphics2D library to make all sorts of fancy UI elements. In slightly oversimplified terms: Cairo is the GTK equivilent to Graphics2D. This isn’t entirely accurate: Cairo is a vector graphics library that GTK just happens to have adopted. Cairo is very usable outside the context of GTK; it can author a variety of file types including pdf and postscript.

I decided I’d use Cairo to author postscript within the printer module.

## The Implementation

``````cairo_surface_t * base = cairo_ps_surface_create(
"[temp_file].ps",
[WIDTH],
[HEIGHT]);
cairo_surface_t * image =
cairo_image_surface_create_from_png(
"[photo_strip_filename]");``````

First, I create 2 `cairo_surface_t` pointers. A Cairo surface is sort of like a canvas that you paint on. For those of you familiar with Java’s Graphics2D, you can think of it like your Graphics2D instance. `cairo_surface_t` is the base class of all Cairo surfaces, there are a variety of surface types for things like PostScript, PDF, PNG, X Windows, or whatever else. The first surface is an empty PostScript surface that represents our finished product. The second surface is created using our .png formatted photo strips.

``cairo_t * working = cairo_create(base);``

If a `cairo_surface_t` is your canvas, then `cairo_t` is your brush. Think of it like a Java Stroke object. Right here, we are creating a new `cairo_t` from our base Cairo surface.

``````cairo_set_operator(working,
CAIRO_OPERATOR_DEST_OVER);
cairo_set_source_surface(working,
image, 0, 0);
cairo_paint(working);``````

The basic idea is that you apply operations to a `cairo_t`, then you apply your `cairo_t` to a `cairo_surface_t`. Here, we are compositing our PNG surface over our PostScript surface. First we set the operator of our `cairo_t` to composite over the top. Next, we set the `cairo_t` to have our image Surface as its source surface. Finally, we call `cairo_paint` which will apply our `cairo_t` to the base surface.

``cairo_surface_show_page(base);``

This call saves our PostScript file.

``````cairo_surface_destroy(base);
cairo_surface_destroy(image);
cairo_destroy(working);``````

No C function is complete without a bunch of cleanup at the end. Here we call `cairo_surface_destroy` to free our `cairo_surface_t` pointers and then we call `cairo_destroy` to free our `cairo_t` pointer.

## PS: You’re Doing It Wrong

That all seemed pretty great right? I thought so too. Here’s the problem: go check out that PostScript file you just created. Notice how it is 200 MB? Yeah…

It turns out that enormous PostScript files is a common problem. While we could just make sure to delete this file when we’re done, we’re still creating this gigantic file, then shoving it down our printer’s throat. My printer is on WiFi, so it takes a good 2 minutes to print this file, and brings my computer to a crawl while it’s doing it. No user is going to want to wait 2 minutes for their photo strip to print.

The second problem is actually a “feature” of PostScript. PostScript is a document layout language, and due to this the printer will take your PostScript file’s word for what it wants done. This sounds nice, until you realize that Cairo isn’t actually a PostScript authoring library. Cairo’s ability to tune a PostScript file is pretty limited. Specifically, this is a problem for things like DPI. I’m trying to print high quality images at 600 DPI. However, Cairo can’t set this in the PostScript, so the printer ends up spitting out a massively blown up copy of the image. This will not do…

## The Solution

So, I’m back to square one. PostScript is a dead-end, and CUPS won’t let me customize my job. What to do…

I thought back to my hello world printer application. I was able to print a random image that was blown up to the size of my paper. What if I print an image that’s exactly the correct size for my paper? I gave it a shot, and sure enough there was no scaling issues!

I can set my printer to 600 DPI, then print my (600 * 4) x (600 * 6) image and it just works, just like Some Guy promised it would. All is once again well in the world.

Plus, I got some Cairo experience under my belt. Look forward to fancy curved lines and gradients in future versions of DMP Photo Booth! (Joking, I promise)