在MCU上移植使用libjpeg

src|-- jaricom.c|-- jcapimin.c|-- jcapistd.c|-- jcarith.c|-- jccoefct.c|-- jccolor.c|-- jcdctmgr.c|-- jchuff.c|-- jcinit.c|-- jcmainct.c|-- jcmarker.c|-- jcmaster.c|-- jcomapi.c|-- jcparam.c|-- jcprepct.c|-- jcsample.c|-- jctrans.c|-- jdapimin.c|-- jdapistd.c|-- jdarith.c|-- jdatadst.c|-- jdatasrc.c|-- jdcoefct.c|-- jdcolor.c|-- jddctmgr.c|-- jdhuff.c|-- jdinput.c|-- jdmainct.c|-- jdmarker.c|-- jdmaster.c|-- jdmerge.c|-- jdpostct.c|-- jdsample.c|-- jdtrans.c|-- jerror.c|-- jfdctflt.c|-- jfdctfst.c|-- jfdctint.c|-- jidctflt.c|-- jidctfst.c|-- jidctint.c|-- jmemmgr.c|-- jquant1.c|-- jquant2.c`-- jutils.c
0 directories, 45 files
inc/|-- jdct.h|-- jerror.h|-- jinclude.h|-- jioport.h|-- jmemsys.h|-- jmorecfg.h|-- jpegint.h|-- jpeglib.h`-- jversion.h
0 directories, 9 files
port/|-- jioport.c|-- jmemansi.c|-- jmemdos.c|-- jmemmac.c|-- jmemname.c|-- jmemnobs.c`-- jmemport.c
0 directories, 7 files

#include "FreeRTOS.h"//#ifndef HAVE_STDLIB_H   /*  should declare malloc(),free() *///extern void * malloc JPP((size_t size));//extern void free JPP((void *ptr));//#endif

/* * jmemport.c * * Copyright (C) 1992-1996, Thomas G. Lane. * Modified 2019 by Guido Vollbeding. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides a really simple implementation of the system- * dependent portion of the JPEG memory manager.  This implementation * assumes that no backing-store files are needed: all required space * can be obtained from malloc(). * This is very portable in the sense that it'll compile on almost anything, * but you'd better have lots of main memory (or virtual memory) if you want * to process big images. * Note that the max_memory_to_use option is respected by this implementation. */
#define JPEG_INTERNALS#include "jinclude.h"#include "jpeglib.h"#include "jmemsys.h"    /* import the system-dependent declarations */#include "FreeRTOS.h"//#ifndef HAVE_STDLIB_H    /*  should declare malloc(),free() *///extern void * malloc JPP((size_t size));//extern void free JPP((void *ptr));//#endif

/* * Memory allocation and freeing are controlled by the regular library * routines malloc() and free(). */
GLOBAL(void *)jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject){  void* ret;  ret = (void *) pvPortMalloc(sizeofobject);  #if JPEG_LOG  jprintf("jpeg_get_small %p size:%ld r\n",ret, sizeofobject);  #endif  return ret;}
GLOBAL(void)jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject){  #if JPEG_LOG  jprintf("jpeg_free_small %p \r\n",object);  #endif  vPortFree(object);}

/* * "Large" objects are treated the same as "small" ones. * NB: although we include FAR keywords in the routine declarations, * this file won't actually work in 80x86 small/medium model; at least, * you probably won't be able to process useful-size images in only 64KB. */
GLOBAL(void FAR *)jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject){  void* ret;  ret = (void FAR *) pvPortMalloc(sizeofobject);  #if JPEG_LOG  jprintf("jpeg_get_small %p size:%ld r\n",ret, sizeofobject);  #endif  return ret;}
GLOBAL(void)jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject){  #if JPEG_LOG  jprintf("jpeg_free_large %p \r\n",object);  #endif  vPortFree(object);}

/* * This routine computes the total memory space available for allocation. */
GLOBAL(long)jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,        long max_bytes_needed, long already_allocated){  if (cinfo->mem->max_memory_to_use)    return cinfo->mem->max_memory_to_use - already_allocated;
  /* Here we say, "we got all you want bud!" */  return max_bytes_needed;}

/* * Backing store (temporary file) management. * Since jpeg_mem_available always promised the moon, * this should never be called and we can just error out. */
GLOBAL(void)jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,       long total_bytes_needed){  ERREXIT(cinfo, JERR_NO_BACKING_STORE);}

/* * These routines take care of any system-dependent initialization and * cleanup required.  Here, there isn't any. */
GLOBAL(long)jpeg_mem_init (j_common_ptr cinfo){  return 0;      /* just set max_memory_to_use to 0 */}
GLOBAL(void)jpeg_mem_term (j_common_ptr cinfo){  /* no work */}

#ifndef HAVE_STDLIB_H   /*  should declare malloc(),free() */extern void * malloc JPP((size_t size));extern void free JPP((void *ptr));#endif

//#ifndef HAVE_STDLIB_H   /*  should declare malloc(),free() *///extern void * malloc JPP((size_t size));//extern void free JPP((void *ptr));//#endif

#ifndef NO_GETENV#ifndef HAVE_STDLIB_H   /*  should declare getenv() */extern char * getenv JPP((const char * name));#endif#endif

extern size_t jfread(void * __ptr, size_t __size, size_t __n, FILE * __stream);extern size_t jfwrite(const void * __ptr, size_t __size, size_t __n, FILE * __stream);extern int    jfflush(FILE * __stream);extern int    jferror(FILE * __fp);
改为extern size_t jfread(void * __ptr, size_t __size, size_t __n, void * __stream);extern size_t jfwrite(const void * __ptr, size_t __size, size_t __n, void * __stream);extern int    jfflush(void * __stream);extern int    jferror(void * __fp);

#ifndef JPEG_IOPORT_H#define JPEG_IOPORT_H
#ifdef __cplusplus extern "C" {#endif
#include #include 
typedef struct{  size_t (*read)(void * __ptr, size_t __size, size_t __n, void * __stream);  size_t (*write)(const void * __ptr, size_t __size, size_t __n, void * __stream);  int    (*flush)(void * __stream);  int    (*error)(void * __fp);  size_t infile_len;} jioport_st;
size_t jfread(void * __ptr, size_t __size, size_t __n, void * __stream);size_t jfwrite(const void * __ptr, size_t __size, size_t __n, void * __stream);int    jfflush(void * __stream);int    jferror(void * __fp);
void jioport_set(jioport_st* port);
#ifdef __cplusplus}#endif
#endif

#include "jconfig.h"#include "jioport.h"
jioport_st* s_jioport = (jioport_st*)0;
size_t jfread(void * __ptr, size_t __size, size_t __n, void * __stream){  #if JPEG_LOG  jprintf("jfread ptr:%p size:%ld n:%ld stream:%p\r\n",__ptr,__size,__n,__stream);  #endif  if((s_jioport != (jioport_st*)0) && (s_jioport->read != 0))  {    return s_jioport->read(__ptr, __size, __n, __stream);  }  return 0;}
size_t jfwrite(const void * __ptr, size_t __size, size_t __n, void * __stream){  #if JPEG_LOG  jprintf("jfwrite ptr:%p size:%ld n:%ld stream:%p\r\n",__ptr,__size,__n,__stream);  #endif  if((s_jioport != (jioport_st*)0) && (s_jioport->write != 0))  {    return s_jioport->write(__ptr, __size, __n, __stream);  }  return 0;}
int    jfflush(void * __stream){  #if JPEG_LOG  jprintf("jfflush stream:%p\r\n",__stream);  #endif  if((s_jioport != (jioport_st*)0) && (s_jioport->flush != 0))  {    return s_jioport->flush(__stream);  }  return 0;}
int    jferror(void * __fp){  #if JPEG_LOG  jprintf("jferror fp:%p\r\n",__fp);  #endif  if((s_jioport != (jioport_st*)0) && (s_jioport->error != 0))  {    return s_jioport->flush(__fp);  }  return 0;}
void jioport_set(jioport_st* port){  s_jioport = port;}

#include 
#define jprintf(fmt, arg...) printf(fmt, ##arg)