media_download_format.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "media_download_format_internal.h"
#include "ra8_attributes.h"
 
RA8_PRIV ra8_err_t priv_media_download_memory_write_at(media_download_memory_t* memory,
                                                       uint64_t                 offset,
                                                       const uint8_t*           source,
                                                       uint32_t                 requested,
                                                       uint32_t*                written)
{
  if (written == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *written = 0U;
  if (memory == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (source == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (offset > memory->capacity) {
    return k_ra8_err_invalid_size;
  }
  if (requested > ((uint64_t)memory->capacity - offset)) {
    return k_ra8_err_invalid_size;
  }
  if (requested != 0U) {
    (void)memcpy(&memory->bytes[(size_t)offset], source, requested);
  }
  const uint32_t end = (uint32_t)offset + requested;
  if (end > memory->length) {
    memory->length = end;
  }
  *written = requested;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_media_download_memory_read(void*     context,
                                                   uint32_t  offset,
                                                   uint8_t*  destination,
                                                   uint32_t  requested,
                                                   uint32_t* out_read)
{
  if (out_read == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *out_read = 0U;
  if (context == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (destination == nullptr) {
    return k_ra8_err_null_ptr;
  }
  const media_download_memory_t* memory = context;
  if (offset > memory->length) {
    return k_ra8_err_invalid_size;
  }
  if (requested > (memory->length - offset)) {
    return k_ra8_err_invalid_size;
  }
  if (requested != 0U) {
    (void)memcpy(destination, &memory->bytes[offset], requested);
  }
  *out_read = requested;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_image_write(void*          context,
                                                   uint32_t       offset,
                                                   const uint8_t* source,
                                                   uint32_t       requested,
                                                   uint32_t*      out_written)
{
  return priv_media_download_memory_write_at(context, offset, source, requested, out_written);
}

RA8_INTERNAL static ra8_err_t internal_flat_append(void*          context,
                                                   const uint8_t* source,
                                                   uint32_t       requested,
                                                   uint32_t*      out_written)
{
  if (context == nullptr) {
    return k_ra8_err_null_ptr;
  }
  media_download_memory_t* memory = context;
  return priv_media_download_memory_write_at(memory,
                                             memory->length,
                                             source,
                                             requested,
                                             out_written);
}

RA8_INTERNAL static ra8_err_t internal_packed_write(void*          context,
                                                    uint64_t       offset,
                                                    const uint8_t* source,
                                                    uint32_t       requested,
                                                    uint32_t*      out_written)
{
  return priv_media_download_memory_write_at(context, offset, source, requested, out_written);
}

RA8_INTERNAL static ra8_err_t
internal_validate_format_request(const uint8_t*                           source,
                                 size_t                                   source_size,
                                 const media_download_format_config_t*    config,
                                 const media_download_format_workspace_t* workspace,
                                 uint64_t*                                packed_size)
{
  if (packed_size == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *packed_size = 0U;
  if (source == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (config == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace->image == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace->flat == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace->packed == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (source_size == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (workspace->image_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (workspace->flat_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (workspace->packed_cap == 0U) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_media_download_format_rabook(const uint8_t* source,
                                                     size_t         source_size,
                                                     const media_download_format_config_t* config,
                                                     media_download_format_workspace_t* workspace,
                                                     uint64_t*                          packed_size)
{
  ra8_err_t result =
    internal_validate_format_request(source, source_size, config, workspace, packed_size);
  if (result != k_ra8_ok) {
    return result;
  }
  media_download_memory_t image  = {.bytes = workspace->image, .capacity = workspace->image_cap};
  media_download_memory_t flat   = {.bytes = workspace->flat, .capacity = workspace->flat_cap};
  media_download_memory_t packed = {.bytes = workspace->packed, .capacity = workspace->packed_cap};
  ra8_rabook_comic_t      comic  = {};
  result                         = ra8_rabook_comic_init(&comic,
                                                         &workspace->comic,
                                                         priv_media_download_memory_read,
                                                         internal_image_write,
                                                         &image,
                                                         config->max_image_edge,
                                                         config->pixel_format);
  if (result == k_ra8_ok) {
    result = ra8_rabook_comic_add_page(&comic, config->page_id, source, source_size);
  }
  uint32_t flat_size = 0U;
  if (result == k_ra8_ok) {
    result =
      ra8_rabook_comic_finish(&comic, &config->metadata, internal_flat_append, &flat, &flat_size);
  }
  if (result == k_ra8_ok) {
    if (flat_size != flat.length) {
      result = k_ra8_err_validation_failed;
    }
  }
  if (result == k_ra8_ok) {
    result = ra8_rabook_container_write(priv_media_download_memory_read,
                                        &flat,
                                        flat.length,
                                        config->chunk_bytes,
                                        internal_packed_write,
                                        &packed,
                                        &workspace->container,
                                        packed_size);
  }
  if (result == k_ra8_ok) {
    if (*packed_size != packed.length) {
      *packed_size = 0U;
      result       = k_ra8_err_validation_failed;
    }
  }
  return result;
}