For what is worth... :|

EDIT: I might have misunderstood your post when I originally posted - If you are only looking at setting up a 'window' within your display then possibly https://www.allegro.cc/manual/5/al_build_transform will help you out.

Original post:
I should likely need to google&read about this more though I have a feeling that you are confusing vanishing points (which can be many on a 2d screen presenting a 3d world) and perspective projection.
Googling says this: "A vanishing point is a point on the image plane of a perspective drawing where the two-dimensional perspective projections (or drawings) of mutually parallel lines in three-dimensional space appear to converge."
So basically it is the paralel lines of your 3d objects that, when projected on 2d view, will appear to have a common vanishing point.
So, unless I am very much mistaken, I think the vanishing points on your 2d view will depend more on the geometry and position of your 3d objects than on the projection used itself.
Likely the vanishing points can be accentuaded by changing the field of view of the camera though that is the most one could do, I think.

Then again, I can only see the center of the view be offset using vertex shaders - though this I do not believe will have any effect on the vanishing points - only effect of this would be that the further away the objects are in the 3d world the smaller and closer to the offset point they will be on your 2d view.

I see now what you mean. I haven't done this before so I can only suggest what to try - if you do no succeed let me know and I will do it for you though you sound like you will be able to figure this out on your own.
I believe what you are looking for is a combination of https://www.allegro.cc/manual/5/al_set_clipping_rectangle and the al_build_transform. In my understanding the al_set_clipping_rectangle will set the viewport where Allegro5 will draw (so your 0,0 to 320,240 area) and the al_build_tranform will offset the drawing so that the distance vanishing point is placed an the center of that area (at 160,120). Could you just confirm which Allegro5 commands you are using to draw or are you using OpenGl calls directly?.

EDIT: You could also (likely in the easiest way) achieve this effect by drawing your 3d scene directly to Allegro5 bitmap and then drawing that bitmap directly on the screen at screen position that you wish. To make this work like this you would need to look into https://www.allegro.cc/manual/5/al_set_target_bitmap

I mentioned glViewport(). I tried using it in combination with Allegro functions, but the scene would not adjust to the new viewport.

Here's the code I'm using to set everything up (borrowed from ex_camera):

static void setup_3d_projection(void)
{
   ALLEGRO_TRANSFORM projection;
   ALLEGRO_DISPLAY *display = al_get_current_display();
   double dw = al_get_display_width(display);
   double dh = al_get_display_height(display);
   double f;
   al_identity_transform(&projection);
   al_translate_transform_3d(&projection, 0, 0, -1);
   f = tan(ex.camera.vertical_field_of_view / 2);
   al_perspective_transform(&projection, -1 * dw / dh * f, f,
      1,
      f * dw / dh, -f, 1000);
   glViewport(0, 0, dw / 2, dh / 2);
   al_use_projection_transform(&projection);
}

With this code, I would expect the entire contents of the scene to be rendered at (0, dh / 2) and fill up the bottom left corner of the screen. Instead, it just renders exactly the same thing as before.

I tried that and got the same result.

Edit: I think I found a good solution to my problem. If I create a sub-bitmap of the backbuffer the size and position of my desired viewport and set that bitmap as the target, the rendering works as expected.

For example, if I wanted to make a four way split screen for a game, I can do something like this:

When it's time to render:

int i;

for(i = 0; i < 4; i++)
{
  al_set_target_bitmap(viewport[i]);
  render_scene();
}

I think this method will integrate nicely with my framework.