I'm working on a project that is using Delphi 7 to consume RESTful services. We are creating and decoding JSON with the ulkJSON library. Up to this point I've been able to successfully build and send JSON containing a base64 string that exceed 5,160kb. I can verify that the base64 is being received by the services and verify the integrity of the base64 once its there. In addition to sending, I can also receive and successfully decode JSON with a smaller (~ 256KB or less) base64.

However I am experiencing some issues on the return trip when larger (~1,024KB+) base64 is involved for some reason. Specifically when attempting to use the following JSON format and function combination:

JSON:

{ 
    "message" : "/9j/4AAQSkZJRgABAQEAYABgAAD...." 
}

Function:

function checkResults(JSONFormattedString: String): String;
var
  jsonObject          : TlkJSONObject;
  iteration           : Integer;
  i                   : Integer;
  x                   : Integer;
begin
  jsonObject := TlkJSONobject.Create;

  // Validate that the JSONFormatted string is not empty.
  // If it is empty, inform the user/programmer, and exit from this routine.
  if JSONFormattedString = '' then
    begin
        result := 'Error: JSON returned is Null';
        jsonObject.Free;
        exit;
    end;

  // Now that we can validate that this string is not empty, we are going to
  // assume that the string is a JSONFormatted string and attempt to parse it.
  //
  // If the string is not a valid JSON object (such as an http status code)
  // throw an exception informing the user/programmer that an unexpected value
  // has been passed. And exit from this routine.
  try
    jsonObject := TlkJSON.ParseText(JSONFormattedString) as TlkJSONobject;
  except
    on e:Exception do
    begin
        result := 'Error: No JSON was received from web services';
        jsonObject.Free;
        exit;
    end;
  end;

  // Now that the object has been parsed, lets check the contents.
  try
      result := jsonObject.Field['message'].value;
      jsonObject.Free;
      exit;
  except
    on e:Exception do
    begin
      result := 'Error: No Message received from Web Services '+e.message;
      jsonObject.Free;
      exit;
    end;
  end;

end;

As mentioned above when using the above function, I am able to get small (256KB and less) base64 strings out of the 'message' field of a JSON object. But for some reason if the received JSON is larger than say 1,024kb the following line seems to just stop in its tracks:

    jsonObject := TlkJSON.ParseText(JSONFormattedString) as TlkJSONobject;

No errors, no results. Following the debugger, I can go into the library, and see that the JSON string being passed is not considered to be JSON despite being in the format listed above. The only difference I can find between calls that work as expected and calls that do not work as expect appears to be the size of base64 being transmitted.

Am I missing something completely obvious and should be shot for my code implementation (very possible)? Have I missed some notation regarding the limitations of the ulkJSON library? Any input would be extremely helpful. Thanks in advance stack!