I'm guessing since you reference BITMAP and not ALLEGRO_BITMAP that you mean A4.

If so, then this should hopefully help: https://www.allegro.cc/manual/4/api/direct-access-to-video-memory/

Your original post said to put an allegro bitmap into char buffer.
Now you just want to know how to modify a char buffer?

strcpy_s(my_buffer, size of my buffer, new name);

Learn the difference between a pointer and an array. char[100] is an array. char* is a pointer. If you want to copy into a char buffer fine, declare an array of char large enough to hold + 1 for the null or allocate memory for it. Then use strncpy to copy it into your char buffer.

So you do want to save a bitmap to a char buffer. I am thoroughly confused.

It's not so easy.

The ALLEGRO_BITMAP pointer doesn't just point to the ALLEGRO_BITMAP struct. There are internal data pointers as well that point somewhere else.

It is doable.

Hardest part would be calculating the buffer size needed?

Take a look at the struct.

You could also look at the register save and load functions. Make your own that loads/saves to/from a char buffer.

After all that, I don't know why you would want to.

EDIT:
I'm still confused. Do you need to save the filename of the bitmap or the bitmap itself to a buffer?

Edgar and Daniel:
Sorry, I guess I am going at this the wrong way. I think I can clear
this up:
I am now in my file manager, I right click on an image, image shows on screen.
Everything is fine. I take the first argument argv[1] and strcpy into my char
name[100] buffer. I then save to "sample,png" file. I then open my file manager
and I see the file ONLY. Bear with me now. Code below:

                              if(lp == true);
                                 {             // saving DEFAULT image
                                     al_set_target_bitmap(temp_image);
                                     temp_image = al_load_bitmap(name);
                                     al_save_bitmap("sample.png", temp_image);
                                     al_destroy_bitmap(temp_image);
                                 }

Notice the (name) buffer called. Everything is still fine. I am happy!!!

Now I want to modify that image. Buffer called name[] is no longer valid,

Now I save the modified image. Code below:

                              if(rt == true || mr == true || dt == true)
                                 {             // saving ROTATED OR MIRROR images
                                    temp_image = al_create_bitmap(screen_width, working_screen_height);
                                    al_set_target_bitmap(temp_image);
                                    al_draw_bitmap(al_get_backbuffer(display), 0, 0, 0);
                                    al_set_target_backbuffer(display);
                                    al_save_bitmap("sample.png", temp_image);
                                    al_destroy_bitmap(temp_image);
                                 }
Sorry, the code ran over to the next line.

I go back to the file manager. I see the "sample.png" file but I also see the
complete backbuffer. I am NOT happy!!! The first thing you are going to say
is 'That is what you ask for'. Right, because if I had ask for image_width and
image_height, I would have gotten pure garbage. Now, if I had the name buffer
updated I could have used the first code I posted and I would be happy again!
Either the name[] buffer needs to be updated or my second code needs to change.

I hope it is clear now. Thanks again for your time.

Hi Daniel:
I want you to do me a favor. Go back and read the very first line of your
last post. That is exactly my problem. If I bring up image representing argv[1]
and I modify that image, argv[1] does NOT exist any longer at this sitting. So,
what I want is name[] buffer updated to reflect the changes to argv[1]. Then
and only then can I use the first code to save the image and get only the image
without the complete backbuffer. If I try to save argv[1] after the modification
I will receive the original argv[1], NOT what I want. I hope this helps.

It's a matter of shallow vs deep copy. If you just point to argv[1], any changes to it will change argv[1]. Just make a char buffer and copy the new name into it.

Hi Daniel and Edgar:
Well it looks like I am stuck with what I have. Any changes I make I get
kick right back to codeblocks. I ran your program Daniel and it ran fine with
some minor changes. I also investigated what Edgar posted. I am a little concerned about what happened. He talked like the argv[1] would be alive for the
complete sitting. I found that not to be the case. I rotated the bitmap
and all went well except when I tried to copy argv[1] to another buffer. Back
to codeblocks I went in a flash. I hope Edgar is not upset with what I said. I
would not question him at all. Both of you know more about this than I do. I
am just saying what I found on my machine. My program runs fine I already have
it in my Linux system. I click on an image and the image is on the screen. I might look into what you just posted about loading a new file from the disk.
Thanks to both of you for your help!

Hi Daniel:
I am sure the problem in losing argv[1] is because I leave main(). The best I
can do to get what I want is a complete rewrite of the program. It was a very
expensive lesson to learn. I go back and forth out of main() all the time. The
main problem is having to save the complete backbuffer after changing argv[1].
It is too big of a problem to try to change what I have now! I hate to give it up
because it is the only image viewer I have. I will start Monday to rewrite what
I have now keeping in mind saving argv[1] all through the program.

Once again, why and huh?

Reenter function?

They are already static because they will only ever be alive while your program is running. Which is the entire time. Just because you jump to other code and back doesn't change that.

Don't give up.

Are you not updating the name buffer? It won't magically change unless you change it.

Did you create a name buffer or are you only using argv[1]?

I'm still confused on what you are doing or not doing or what you are trying to accomplish.