Hallo Ingo,
die Anforderung ist nicht so ganz einfach, weil man hier leicht an die 16MB Grenze im RPG stößt. Deine Idee ist schon richtig mit der API apr_base64_encode_binary, denn die kann auch über Pointer anprogrammiert werden und da ist die Grenze viel größer. Ich habe eine Lösung gebaut, die für CLOB Daten funktioniert. BLOB geht genauso. Es ist zu beachten, dass die API die Daten im UTF8 Format = CCSID(*UTF8) verlangt.

Damit es mit dem Compilieren einfacher ist, habe ich ein CL gebaut, das ein BNDDIR für die BASE64 API's erstellt

Code:
/*********************************************************************/
/*                                                                   */
/* CREATE BASUTL BINDING-DIRECTORY - BASE64                          */
/*                                                                   */
/******************                                                  */
/* R.ROSS 03.2017 *                                                  */
/*********************************************************************/

   PGM

   DCL        VAR(&LIB) TYPE(*CHAR) LEN(10) VALUE(DEVO)

   MONMSG     MSGID(CPF0000)

/*********************************************************************/
/* VERARBEITUNG                                                      */
/*********************************************************************/

   DLTBNDDIR  BNDDIR(&LIB/BASUTL)
   CRTBNDDIR  BNDDIR(&LIB/BASUTL) TEXT('BASE64 Utilities')

   ADDBNDDIRE BNDDIR(&LIB/BASUTL) OBJ((QSYSDIR/QAXIS10HT *SRVPGM))

/*********************************************************************/
/* ENDE                                                              */
/*********************************************************************/
   ENDE:      ENDPGM
/*********************************************************************/
Anbei das RPG für das Erzeugen von BASE64-Daten aus CLOB oder BLOB

Code:
         ctl-opt main(main) alloc(*teraspace) bnddir('BASUTL');
      //------------------------------------------------------------------//
      //                                                                  //
      // Encode BASE64 with Pointer                                       //
      //                                                                  //
      //-----------------                                                 //
      // R.Ross 04.2020 *                                                 //
      //------------------------------------------------------------------//
      // BASE64 - Encode String - SRVPGM(QSYSDIR/QAXIS10HT)               //
      //------------------------------------------------------------------//

         dcl-pr encBase64Bin int(10) extproc('apr_base64_encode_binary');
                 PiEnc_p     pointer value;           // Encoded-Pointer
                 PiSrc_p     pointer value;           // Source-Pointer
                 PiSrclen    int(10) value;           // Source-Length
         end-pr;

      //------------------------------------------------------------------//
      // MemCopy                                                          //
      //------------------------------------------------------------------//

         dcl-pr memcpy       extproc(*dclcase);
                 mctarget    pointer value;
                 mcsource    pointer value;
                 mclength    uns(10) value;
         end-pr;

      //------------------------------------------------------------------//
      // Array BASE64 Ergebnis                                            //
      //------------------------------------------------------------------//

         dcl-ds  DsBase64    qualified;
                  String_p   pointer;
                  Length     int(10);
         end-ds;

      //------------------------------------------------------------------//
      // Main                                                             //
      //------------------------------------------------------------------//
         dcl-proc Main;

         dcl-s   LocClob     SQLType(CLOB:5000000) ccsid(*utf8); // 5 MB
         dcl-s   LocClob64   SQLType(CLOB:5000000) ccsid(*utf8); // 5 MB

           exec sql set :LocClob = 'test';

      // Daten in BASE64 codieren

           DsBase64 = encodeBase64(%addr(LocClob_data):LocClob_len);

      // BASE64-Daten aus Pointer in CLOB LocClob64 laden - test -> dGVzdA==

           memcpy(%addr(LocClob64_data):DsBase64.String_p:DsBase64.Length);
           LocClob64_len = DsBase64.Length;

         end-proc;
      //------------------------------------------------------------------//
      // Encode Data to BASE64                                            //
      //------------------------------------------------------------------//
         dcl-proc encodeBase64;
         dcl-pi *n           likeds(DsBase64);        // Encoded Data
                 PiString_p  pointer const;           // String Pointer
                 PiLength    int(10) const;           // String Length
         end-pi;

         dcl-ds  PsBase64    likeds(DsBase64) inz;

         dcl-s   LocEnclen   int(10);                 // Encoded Length

           if PiLength < 50;
              PsBase64.String_p = %alloc(PiLength * 10); // alloc Pointer
            else;
              PsBase64.String_p = %alloc(PiLength * 5);  // alloc Pointer
           endif;

           LocEnclen =
              encBase64Bin(PsBase64.String_p:PiString_p:PiLength);

           if LocEnclen > *zero;                       // Encoded Length
              PsBase64.Length = LocEnclen - 1;         // without last null
           endif;

           return PsBase64;

         end-proc;
      //------------------------------------------------------------------//
Bei Fragen kannst Du dich gern an mich wenden

Herzliche Grüße
Rainer