One Level Up Top Level

src/http/modules/ngx_http_image_filter_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>

  12. #include <gd.h>


  15. ‌#define NGX_HTTP_IMAGE_OFF       0
  16. ‌#define NGX_HTTP_IMAGE_TEST      1
  17. ‌#define NGX_HTTP_IMAGE_SIZE      2
  18. ‌#define NGX_HTTP_IMAGE_RESIZE    3
  19. ‌#define NGX_HTTP_IMAGE_CROP      4
  20. ‌#define NGX_HTTP_IMAGE_ROTATE    5


  23. ‌#define NGX_HTTP_IMAGE_START     0
  24. ‌#define NGX_HTTP_IMAGE_READ      1
  25. ‌#define NGX_HTTP_IMAGE_PROCESS   2
  26. ‌#define NGX_HTTP_IMAGE_PASS      3
  27. ‌#define NGX_HTTP_IMAGE_DONE      4


  30. ‌#define NGX_HTTP_IMAGE_NONE      0
  31. ‌#define NGX_HTTP_IMAGE_JPEG      1
  32. ‌#define NGX_HTTP_IMAGE_GIF       2
  33. ‌#define NGX_HTTP_IMAGE_PNG       3


  36. ‌#define NGX_HTTP_IMAGE_BUFFERED  0x08


  39. typedef struct {
  40.     ngx_uint_t                   filter;
  41.     ngx_uint_t                   width;
  42.     ngx_uint_t                   height;
  43.     ngx_uint_t                   angle;
  44.     ngx_uint_t                   jpeg_quality;
  45.     ngx_uint_t                   sharpen;

  47.     ngx_flag_t                   transparency;
  48.     ngx_flag_t                   interlace;

  50.     ngx_http_complex_value_t    *wcv;
  51.     ngx_http_complex_value_t    *hcv;
  52.     ngx_http_complex_value_t    *acv;
  53.     ngx_http_complex_value_t    *jqcv;
  54.     ngx_http_complex_value_t    *shcv;

  56.     size_t                       buffer_size;
  57. ‌} ngx_http_image_filter_conf_t;


  60. typedef struct {
  61.     u_char                      *image;
  62.     u_char                      *last;

  64.     size_t                       length;

  66.     ngx_uint_t                   width;
  67.     ngx_uint_t                   height;
  68.     ngx_uint_t                   max_width;
  69.     ngx_uint_t                   max_height;
  70.     ngx_uint_t                   angle;

  72.     ngx_uint_t                   phase;
  73.     ngx_uint_t                   type;
  74.     ngx_uint_t                   force;
  75. ‌} ngx_http_image_filter_ctx_t;


  78. static ngx_int_t ngx_http_image_send(ngx_http_request_t *r,
  79.     ngx_http_image_filter_ctx_t *ctx, ngx_chain_t *in);
  80. static ngx_uint_t ngx_http_image_test(ngx_http_request_t *r, ngx_chain_t *in);
  81. static ngx_int_t ngx_http_image_read(ngx_http_request_t *r, ngx_chain_t *in);
  82. static ngx_buf_t *ngx_http_image_process(ngx_http_request_t *r);
  83. static ngx_buf_t *ngx_http_image_json(ngx_http_request_t *r,
  84.     ngx_http_image_filter_ctx_t *ctx);
  85. static ngx_buf_t *ngx_http_image_asis(ngx_http_request_t *r,
  86.     ngx_http_image_filter_ctx_t *ctx);
  87. static void ngx_http_image_length(ngx_http_request_t *r, ngx_buf_t *b);
  88. static ngx_int_t ngx_http_image_size(ngx_http_request_t *r,
  89.     ngx_http_image_filter_ctx_t *ctx);

  91. static ngx_buf_t *ngx_http_image_resize(ngx_http_request_t *r,
  92.     ngx_http_image_filter_ctx_t *ctx);
  93. static gdImagePtr ngx_http_image_source(ngx_http_request_t *r,
  94.     ngx_http_image_filter_ctx_t *ctx);
  95. static gdImagePtr ngx_http_image_new(ngx_http_request_t *r, int w, int h,
  96.     int colors);
  97. static u_char *ngx_http_image_out(ngx_http_request_t *r, ngx_uint_t type,
  98.     gdImagePtr img, int *size);
  99. static void ngx_http_image_cleanup(void *data);
  100. static ngx_uint_t ngx_http_image_filter_get_value(ngx_http_request_t *r,
  101.     ngx_http_complex_value_t *cv, ngx_uint_t v);
  102. static ngx_uint_t ngx_http_image_filter_value(ngx_str_t *value);


  105. static void *ngx_http_image_filter_create_conf(ngx_conf_t *cf);
  106. static char *ngx_http_image_filter_merge_conf(ngx_conf_t *cf, void *parent,
  107.     void *child);
  108. static char *ngx_http_image_filter(ngx_conf_t *cf, ngx_command_t *cmd,
  109.     void *conf);
  110. static char *ngx_http_image_filter_jpeg_quality(ngx_conf_t *cf,
  111.     ngx_command_t *cmd, void *conf);
  112. static char *ngx_http_image_filter_sharpen(ngx_conf_t *cf, ngx_command_t *cmd,
  113.     void *conf);
  114. static ngx_int_t ngx_http_image_filter_init(ngx_conf_t *cf);


  117. ‌static ngx_command_t  ngx_http_image_filter_commands[] = {

  119.     { ngx_string("image_filter"),
  120.       NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  121.       ngx_http_image_filter,
  122.       NGX_HTTP_LOC_CONF_OFFSET,
  123.       0,
  124.       NULL },

  126.     { ngx_string("image_filter_jpeg_quality"),
  127.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  128.       ngx_http_image_filter_jpeg_quality,
  129.       NGX_HTTP_LOC_CONF_OFFSET,
  130.       0,
  131.       NULL },

  133.     { ngx_string("image_filter_sharpen"),
  134.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  135.       ngx_http_image_filter_sharpen,
  136.       NGX_HTTP_LOC_CONF_OFFSET,
  137.       0,
  138.       NULL },

  140.     { ngx_string("image_filter_transparency"),
  141.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  142.       ngx_conf_set_flag_slot,
  143.       NGX_HTTP_LOC_CONF_OFFSET,
  144.       offsetof(ngx_http_image_filter_conf_t, transparency),
  145.       NULL },

  147.    { ngx_string("image_filter_interlace"),
  148.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  149.       ngx_conf_set_flag_slot,
  150.       NGX_HTTP_LOC_CONF_OFFSET,
  151.       offsetof(ngx_http_image_filter_conf_t, interlace),
  152.       NULL },

  154.     { ngx_string("image_filter_buffer"),
  155.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  156.       ngx_conf_set_size_slot,
  157.       NGX_HTTP_LOC_CONF_OFFSET,
  158.       offsetof(ngx_http_image_filter_conf_t, buffer_size),
  159.       NULL },

  161.       ngx_null_command
  162. };


  165. ‌static ngx_http_module_t  ngx_http_image_filter_module_ctx = {
  166.     NULL,                                  /* preconfiguration */
  167.     ngx_http_image_filter_init,            /* postconfiguration */

  169.     NULL,                                  /* create main configuration */
  170.     NULL,                                  /* init main configuration */

  172.     NULL,                                  /* create server configuration */
  173.     NULL,                                  /* merge server configuration */

  175.     ngx_http_image_filter_create_conf,     /* create location configuration */
  176.     ngx_http_image_filter_merge_conf       /* merge location configuration */
  177. };


  180. ‌ngx_module_t  ngx_http_image_filter_module = {
  181.     NGX_MODULE_V1,
  182.     &ngx_http_image_filter_module_ctx,     /* module context */
  183.     ngx_http_image_filter_commands,        /* module directives */
  184.     NGX_HTTP_MODULE,                       /* module type */
  185.     NULL,                                  /* init master */
  186.     NULL,                                  /* init module */
  187.     NULL,                                  /* init process */
  188.     NULL,                                  /* init thread */
  189.     NULL,                                  /* exit thread */
  190.     NULL,                                  /* exit process */
  191.     NULL,                                  /* exit master */
  192.     NGX_MODULE_V1_PADDING
  193. };


  196. ‌static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;
  197. ‌static ngx_http_output_body_filter_pt    ngx_http_next_body_filter;


  200. ‌static ngx_str_t  ngx_http_image_types[] = {
  201.     ngx_string("image/jpeg"),
  202.     ngx_string("image/gif"),
  203.     ngx_string("image/png")
  204. };


  207. static ngx_int_t
  208. ‌ngx_http_image_header_filter(ngx_http_request_t *r)
  209. {
  210.     off_t                          len;
  211.     ngx_http_image_filter_ctx_t   *ctx;
  212.     ngx_http_image_filter_conf_t  *conf;

  214.     if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED) {
  215.         return ngx_http_next_header_filter(r);
  216.     }

  218.     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);

  220.     if (ctx) {
  221.         ngx_http_set_ctx(r, NULL, ngx_http_image_filter_module);
  222.         return ngx_http_next_header_filter(r);
  223.     }

  225.     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);

  227.     if (conf->filter == NGX_HTTP_IMAGE_OFF) {
  228.         return ngx_http_next_header_filter(r);
  229.     }

  231.     if (r->headers_out.content_type.len
  232.             >= sizeof("multipart/x-mixed-replace") - 1
  233.         && ngx_strncasecmp(r->headers_out.content_type.data,
  234.                            (u_char *) "multipart/x-mixed-replace",
  235.                            sizeof("multipart/x-mixed-replace") - 1)
  236.            == 0)
  237.     {
  238.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  239.                       "image filter: multipart/x-mixed-replace response");

  241.         return NGX_ERROR;
  242.     }

  244.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_image_filter_ctx_t));
  245.     if (ctx == NULL) {
  246.         return NGX_ERROR;
  247.     }

  249.     ngx_http_set_ctx(r, ctx, ngx_http_image_filter_module);

  251.     len = r->headers_out.content_length_n;

  253.     if (len != -1 && len > (off_t) conf->buffer_size) {
  254.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  255.                       "image filter: too big response: %O", len);

  257.         return NGX_HTTP_UNSUPPORTED_MEDIA_TYPE;
  258.     }

  260.     if (len == -1) {
  261.         ctx->length = conf->buffer_size;

  263.     } else {
  264.         ctx->length = (size_t) len;
  265.     }

  267.     if (r->headers_out.refresh) {
  268.         r->headers_out.refresh->hash = 0;
  269.     }

  271.     r->main_filter_need_in_memory = 1;
  272.     r->allow_ranges = 0;

  274.     return NGX_OK;
  275. }


  278. static ngx_int_t
  279. ‌ngx_http_image_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  280. {
  281.     ngx_int_t                      rc;
  282.     ngx_str_t                     *ct;
  283.     ngx_chain_t                    out;
  284.     ngx_http_image_filter_ctx_t   *ctx;
  285.     ngx_http_image_filter_conf_t  *conf;

  287.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "image filter");

  289.     if (in == NULL) {
  290.         return ngx_http_next_body_filter(r, in);
  291.     }

  293.     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);

  295.     if (ctx == NULL) {
  296.         return ngx_http_next_body_filter(r, in);
  297.     }

  299.     switch (ctx->phase) {

  301.     case NGX_HTTP_IMAGE_START:

  303.         ctx->type = ngx_http_image_test(r, in);

  305.         conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);

  307.         if (ctx->type == NGX_HTTP_IMAGE_NONE) {

  309.             if (conf->filter == NGX_HTTP_IMAGE_SIZE) {
  310.                 out.buf = ngx_http_image_json(r, NULL);

  312.                 if (out.buf) {
  313.                     out.next = NULL;
  314.                     ctx->phase = NGX_HTTP_IMAGE_DONE;

  316.                     return ngx_http_image_send(r, ctx, &out);
  317.                 }
  318.             }

  320.             return ngx_http_filter_finalize_request(r,
  321.                                               &ngx_http_image_filter_module,
  322.                                               NGX_HTTP_UNSUPPORTED_MEDIA_TYPE);
  323.         }

  325.         /* override content type */

  327.         ct = &ngx_http_image_types[ctx->type - 1];
  328.         r->headers_out.content_type_len = ct->len;
  329.         r->headers_out.content_type = *ct;
  330.         r->headers_out.content_type_lowcase = NULL;

  332.         if (conf->filter == NGX_HTTP_IMAGE_TEST) {
  333.             ctx->phase = NGX_HTTP_IMAGE_PASS;

  335.             return ngx_http_image_send(r, ctx, in);
  336.         }

  338.         ctx->phase = NGX_HTTP_IMAGE_READ;

  340.         /* fall through */

  342.     case NGX_HTTP_IMAGE_READ:

  344.         rc = ngx_http_image_read(r, in);

  346.         if (rc == NGX_AGAIN) {
  347.             return NGX_OK;
  348.         }

  350.         if (rc == NGX_ERROR) {
  351.             return ngx_http_filter_finalize_request(r,
  352.                                               &ngx_http_image_filter_module,
  353.                                               NGX_HTTP_UNSUPPORTED_MEDIA_TYPE);
  354.         }

  356.         /* fall through */

  358.     case NGX_HTTP_IMAGE_PROCESS:

  360.         out.buf = ngx_http_image_process(r);

  362.         if (out.buf == NULL) {
  363.             return ngx_http_filter_finalize_request(r,
  364.                                               &ngx_http_image_filter_module,
  365.                                               NGX_HTTP_UNSUPPORTED_MEDIA_TYPE);
  366.         }

  368.         out.next = NULL;
  369.         ctx->phase = NGX_HTTP_IMAGE_PASS;

  371.         return ngx_http_image_send(r, ctx, &out);

  373.     case NGX_HTTP_IMAGE_PASS:

  375.         return ngx_http_next_body_filter(r, in);

  377.     default: /* NGX_HTTP_IMAGE_DONE */

  379.         rc = ngx_http_next_body_filter(r, NULL);

  381.         /* NGX_ERROR resets any pending data */
  382.         return (rc == NGX_OK) ? NGX_ERROR : rc;
  383.     }
  384. }


  387. static ngx_int_t
  388. ‌ngx_http_image_send(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx,
  389.     ngx_chain_t *in)
  390. {
  391.     ngx_int_t  rc;

  393.     rc = ngx_http_next_header_filter(r);

  395.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  396.         return NGX_ERROR;
  397.     }

  399.     rc = ngx_http_next_body_filter(r, in);

  401.     if (ctx->phase == NGX_HTTP_IMAGE_DONE) {
  402.         /* NGX_ERROR resets any pending data */
  403.         return (rc == NGX_OK) ? NGX_ERROR : rc;
  404.     }

  406.     return rc;
  407. }


  410. static ngx_uint_t
  411. ‌ngx_http_image_test(ngx_http_request_t *r, ngx_chain_t *in)
  412. {
  413.     u_char  *p;

  415.     p = in->buf->pos;

  417.     if (in->buf->last - p < 16) {
  418.         return NGX_HTTP_IMAGE_NONE;
  419.     }

  421.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  422.                    "image filter: \"%c%c\"", p[0], p[1]);

  424.     if (p[0] == 0xff && p[1] == 0xd8) {

  426.         /* JPEG */

  428.         return NGX_HTTP_IMAGE_JPEG;

  430.     } else if (p[0] == 'G' && p[1] == 'I' && p[2] == 'F' && p[3] == '8'
  431.                && p[5] == 'a')
  432.     {
  433.         if (p[4] == '9' || p[4] == '7') {
  434.             /* GIF */
  435.             return NGX_HTTP_IMAGE_GIF;
  436.         }

  438.     } else if (p[0] == 0x89 && p[1] == 'P' && p[2] == 'N' && p[3] == 'G'
  439.                && p[4] == 0x0d && p[5] == 0x0a && p[6] == 0x1a && p[7] == 0x0a)
  440.     {
  441.         /* PNG */

  443.         return NGX_HTTP_IMAGE_PNG;
  444.     }

  446.     return NGX_HTTP_IMAGE_NONE;
  447. }


  450. static ngx_int_t
  451. ‌ngx_http_image_read(ngx_http_request_t *r, ngx_chain_t *in)
  452. {
  453.     u_char                       *p;
  454.     size_t                        size, rest;
  455.     ngx_buf_t                    *b;
  456.     ngx_chain_t                  *cl;
  457.     ngx_http_image_filter_ctx_t  *ctx;

  459.     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);

  461.     if (ctx->image == NULL) {
  462.         ctx->image = ngx_palloc(r->pool, ctx->length);
  463.         if (ctx->image == NULL) {
  464.             return NGX_ERROR;
  465.         }

  467.         ctx->last = ctx->image;
  468.     }

  470.     p = ctx->last;

  472.     for (cl = in; cl; cl = cl->next) {

  474.         b = cl->buf;
  475.         size = b->last - b->pos;

  477.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  478.                        "image buf: %uz", size);

  480.         rest = ctx->image + ctx->length - p;

  482.         if (size > rest) {
  483.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  484.                           "image filter: too big response");
  485.             return NGX_ERROR;
  486.         }

  488.         p = ngx_cpymem(p, b->pos, size);
  489.         b->pos += size;

  491.         if (b->last_buf) {
  492.             ctx->last = p;
  493.             return NGX_OK;
  494.         }
  495.     }

  497.     ctx->last = p;
  498.     r->connection->buffered |= NGX_HTTP_IMAGE_BUFFERED;

  500.     return NGX_AGAIN;
  501. }


  504. static ngx_buf_t *
  505. ‌ngx_http_image_process(ngx_http_request_t *r)
  506. {
  507.     ngx_int_t                      rc;
  508.     ngx_http_image_filter_ctx_t   *ctx;
  509.     ngx_http_image_filter_conf_t  *conf;

  511.     r->connection->buffered &= ~NGX_HTTP_IMAGE_BUFFERED;

  513.     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);

  515.     rc = ngx_http_image_size(r, ctx);

  517.     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);

  519.     if (conf->filter == NGX_HTTP_IMAGE_SIZE) {
  520.         return ngx_http_image_json(r, rc == NGX_OK ? ctx : NULL);
  521.     }

  523.     ctx->angle = ngx_http_image_filter_get_value(r, conf->acv, conf->angle);

  525.     if (conf->filter == NGX_HTTP_IMAGE_ROTATE) {

  527.         if (ctx->angle != 90 && ctx->angle != 180 && ctx->angle != 270) {
  528.             return NULL;
  529.         }

  531.         return ngx_http_image_resize(r, ctx);
  532.     }

  534.     ctx->max_width = ngx_http_image_filter_get_value(r, conf->wcv, conf->width);
  535.     if (ctx->max_width == 0) {
  536.         return NULL;
  537.     }

  539.     ctx->max_height = ngx_http_image_filter_get_value(r, conf->hcv,
  540.                                                       conf->height);
  541.     if (ctx->max_height == 0) {
  542.         return NULL;
  543.     }

  545.     if (rc == NGX_OK
  546.         && ctx->width <= ctx->max_width
  547.         && ctx->height <= ctx->max_height
  548.         && ctx->angle == 0
  549.         && !ctx->force)
  550.     {
  551.         return ngx_http_image_asis(r, ctx);
  552.     }

  554.     return ngx_http_image_resize(r, ctx);
  555. }


  558. static ngx_buf_t *
  559. ‌ngx_http_image_json(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
  560. {
  561.     size_t      len;
  562.     ngx_buf_t  *b;

  564.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  565.     if (b == NULL) {
  566.         return NULL;
  567.     }

  569.     b->memory = 1;
  570.     b->last_buf = 1;

  572.     ngx_http_clean_header(r);

  574.     r->headers_out.status = NGX_HTTP_OK;
  575.     r->headers_out.content_type_len = sizeof("application/json") - 1;
  576.     ngx_str_set(&r->headers_out.content_type, "application/json");
  577.     r->headers_out.content_type_lowcase = NULL;

  579.     if (ctx == NULL) {
  580.         b->pos = (u_char *) "{}" CRLF;
  581.         b->last = b->pos + sizeof("{}" CRLF) - 1;

  583.         ngx_http_image_length(r, b);

  585.         return b;
  586.     }

  588.     len = sizeof("{ \"img\" : "
  589.                  "{ \"width\": , \"height\": , \"type\": \"jpeg\" } }" CRLF) - 1
  590.           + 2 * NGX_SIZE_T_LEN;

  592.     b->pos = ngx_pnalloc(r->pool, len);
  593.     if (b->pos == NULL) {
  594.         return NULL;
  595.     }

  597.     b->last = ngx_sprintf(b->pos,
  598.                           "{ \"img\" : "
  599.                                        "{ \"width\": %uz,"
  600.                                         " \"height\": %uz,"
  601.                                         " \"type\": \"%s\" } }" CRLF,
  602.                           ctx->width, ctx->height,
  603.                           ngx_http_image_types[ctx->type - 1].data + 6);

  605.     ngx_http_image_length(r, b);

  607.     return b;
  608. }


  611. static ngx_buf_t *
  612. ‌ngx_http_image_asis(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
  613. {
  614.     ngx_buf_t  *b;

  616.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  617.     if (b == NULL) {
  618.         return NULL;
  619.     }

  621.     b->pos = ctx->image;
  622.     b->last = ctx->last;
  623.     b->memory = 1;
  624.     b->last_buf = 1;

  626.     ngx_http_image_length(r, b);

  628.     return b;
  629. }


  632. static void
  633. ‌ngx_http_image_length(ngx_http_request_t *r, ngx_buf_t *b)
  634. {
  635.     r->headers_out.content_length_n = b->last - b->pos;

  637.     if (r->headers_out.content_length) {
  638.         r->headers_out.content_length->hash = 0;
  639.     }

  641.     r->headers_out.content_length = NULL;
  642. }


  645. static ngx_int_t
  646. ‌ngx_http_image_size(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
  647. {
  648.     u_char      *p, *last;
  649.     size_t       len, app;
  650.     ngx_uint_t   width, height;

  652.     p = ctx->image;

  654.     switch (ctx->type) {

  656.     case NGX_HTTP_IMAGE_JPEG:

  658.         p += 2;
  659.         last = ctx->image + ctx->length - 10;
  660.         width = 0;
  661.         height = 0;
  662.         app = 0;

  664.         while (p < last) {

  666.             if (p[0] == 0xff && p[1] != 0xff) {

  668.                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  669.                                "JPEG: %02xd %02xd", p[0], p[1]);

  671.                 p++;

  673.                 if ((*p == 0xc0 || *p == 0xc1 || *p == 0xc2 || *p == 0xc3
  674.                      || *p == 0xc9 || *p == 0xca || *p == 0xcb)
  675.                     && (width == 0 || height == 0))
  676.                 {
  677.                     width = p[6] * 256 + p[7];
  678.                     height = p[4] * 256 + p[5];
  679.                 }

  681.                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  682.                                "JPEG: %02xd %02xd", p[1], p[2]);

  684.                 len = p[1] * 256 + p[2];

  686.                 if (*p >= 0xe1 && *p <= 0xef) {
  687.                     /* application data, e.g., EXIF, Adobe XMP, etc. */
  688.                     app += len;
  689.                 }

  691.                 p += len;

  693.                 continue;
  694.             }

  696.             p++;
  697.         }

  699.         if (width == 0 || height == 0) {
  700.             return NGX_DECLINED;
  701.         }

  703.         if (ctx->length / 20 < app) {
  704.             /* force conversion if application data consume more than 5% */
  705.             ctx->force = 1;
  706.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  707.                            "app data size: %uz", app);
  708.         }

  710.         break;

  712.     case NGX_HTTP_IMAGE_GIF:

  714.         if (ctx->length < 10) {
  715.             return NGX_DECLINED;
  716.         }

  718.         width = p[7] * 256 + p[6];
  719.         height = p[9] * 256 + p[8];

  721.         break;

  723.     case NGX_HTTP_IMAGE_PNG:

  725.         if (ctx->length < 24) {
  726.             return NGX_DECLINED;
  727.         }

  729.         width = p[18] * 256 + p[19];
  730.         height = p[22] * 256 + p[23];

  732.         break;

  734.     default:

  736.         return NGX_DECLINED;
  737.     }

  739.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  740.                    "image size: %d x %d", width, height);

  742.     ctx->width = width;
  743.     ctx->height = height;

  745.     return NGX_OK;
  746. }


  749. static ngx_buf_t *
  750. ‌ngx_http_image_resize(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
  751. {
  752.     int                            sx, sy, dx, dy, ox, oy, ax, ay, size,
  753.                                    colors, palette, transparent, sharpen,
  754.                                    red, green, blue, t;
  755.     u_char                        *out;
  756.     ngx_buf_t                     *b;
  757.     ngx_uint_t                     resize;
  758.     gdImagePtr                     src, dst;
  759.     ngx_pool_cleanup_t            *cln;
  760.     ngx_http_image_filter_conf_t  *conf;

  762.     src = ngx_http_image_source(r, ctx);

  764.     if (src == NULL) {
  765.         return NULL;
  766.     }

  768.     sx = gdImageSX(src);
  769.     sy = gdImageSY(src);

  771.     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);

  773.     if (!ctx->force
  774.         && ctx->angle == 0
  775.         && (ngx_uint_t) sx <= ctx->max_width
  776.         && (ngx_uint_t) sy <= ctx->max_height)
  777.     {
  778.         gdImageDestroy(src);
  779.         return ngx_http_image_asis(r, ctx);
  780.     }

  782.     colors = gdImageColorsTotal(src);

  784.     if (colors && conf->transparency) {
  785.         transparent = gdImageGetTransparent(src);

  787.         if (transparent != -1) {
  788.             palette = colors;
  789.             red = gdImageRed(src, transparent);
  790.             green = gdImageGreen(src, transparent);
  791.             blue = gdImageBlue(src, transparent);

  793.             goto transparent;
  794.         }
  795.     }

  797.     palette = 0;
  798.     transparent = -1;
  799.     red = 0;
  800.     green = 0;
  801.     blue = 0;

  803. transparent:

  805.     gdImageColorTransparent(src, -1);

  807.     dx = sx;
  808.     dy = sy;

  810.     if (conf->filter == NGX_HTTP_IMAGE_RESIZE) {

  812.         if ((ngx_uint_t) dx > ctx->max_width) {
  813.             dy = dy * ctx->max_width / dx;
  814.             dy = dy ? dy : 1;
  815.             dx = ctx->max_width;
  816.         }

  818.         if ((ngx_uint_t) dy > ctx->max_height) {
  819.             dx = dx * ctx->max_height / dy;
  820.             dx = dx ? dx : 1;
  821.             dy = ctx->max_height;
  822.         }

  824.         resize = 1;

  826.     } else if (conf->filter == NGX_HTTP_IMAGE_ROTATE) {

  828.         resize = 0;

  830.     } else { /* NGX_HTTP_IMAGE_CROP */

  832.         resize = 0;

  834.         if ((double) dx / dy < (double) ctx->max_width / ctx->max_height) {
  835.             if ((ngx_uint_t) dx > ctx->max_width) {
  836.                 dy = dy * ctx->max_width / dx;
  837.                 dy = dy ? dy : 1;
  838.                 dx = ctx->max_width;
  839.                 resize = 1;
  840.             }

  842.         } else {
  843.             if ((ngx_uint_t) dy > ctx->max_height) {
  844.                 dx = dx * ctx->max_height / dy;
  845.                 dx = dx ? dx : 1;
  846.                 dy = ctx->max_height;
  847.                 resize = 1;
  848.             }
  849.         }
  850.     }

  852.     if (resize) {
  853.         dst = ngx_http_image_new(r, dx, dy, palette);
  854.         if (dst == NULL) {
  855.             gdImageDestroy(src);
  856.             return NULL;
  857.         }

  859.         if (colors == 0) {
  860.             gdImageSaveAlpha(dst, 1);
  861.             gdImageAlphaBlending(dst, 0);
  862.         }

  864.         gdImageCopyResampled(dst, src, 0, 0, 0, 0, dx, dy, sx, sy);

  866.         if (colors) {
  867.             gdImageTrueColorToPalette(dst, 1, 256);
  868.         }

  870.         gdImageDestroy(src);

  872.     } else {
  873.         dst = src;
  874.     }

  876.     if (ctx->angle) {
  877.         src = dst;

  879.         ax = (dx % 2 == 0) ? 1 : 0;
  880.         ay = (dy % 2 == 0) ? 1 : 0;

  882.         switch (ctx->angle) {

  884.         case 90:
  885.         case 270:
  886.             dst = ngx_http_image_new(r, dy, dx, palette);
  887.             if (dst == NULL) {
  888.                 gdImageDestroy(src);
  889.                 return NULL;
  890.             }
  891.             if (ctx->angle == 90) {
  892.                 ox = dy / 2 + ay;
  893.                 oy = dx / 2 - ax;

  895.             } else {
  896.                 ox = dy / 2 - ay;
  897.                 oy = dx / 2 + ax;
  898.             }

  900.             gdImageCopyRotated(dst, src, ox, oy, 0, 0,
  901.                                dx + ax, dy + ay, ctx->angle);
  902.             gdImageDestroy(src);

  904.             t = dx;
  905.             dx = dy;
  906.             dy = t;
  907.             break;

  909.         case 180:
  910.             dst = ngx_http_image_new(r, dx, dy, palette);
  911.             if (dst == NULL) {
  912.                 gdImageDestroy(src);
  913.                 return NULL;
  914.             }
  915.             gdImageCopyRotated(dst, src, dx / 2 - ax, dy / 2 - ay, 0, 0,
  916.                                dx + ax, dy + ay, ctx->angle);
  917.             gdImageDestroy(src);
  918.             break;
  919.         }
  920.     }

  922.     if (conf->filter == NGX_HTTP_IMAGE_CROP) {

  924.         src = dst;

  926.         if ((ngx_uint_t) dx > ctx->max_width) {
  927.             ox = dx - ctx->max_width;

  929.         } else {
  930.             ox = 0;
  931.         }

  933.         if ((ngx_uint_t) dy > ctx->max_height) {
  934.             oy = dy - ctx->max_height;

  936.         } else {
  937.             oy = 0;
  938.         }

  940.         if (ox || oy) {

  942.             dst = ngx_http_image_new(r, dx - ox, dy - oy, colors);

  944.             if (dst == NULL) {
  945.                 gdImageDestroy(src);
  946.                 return NULL;
  947.             }

  949.             ox /= 2;
  950.             oy /= 2;

  952.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  953.                            "image crop: %d x %d @ %d x %d",
  954.                            dx, dy, ox, oy);

  956.             if (colors == 0) {
  957.                 gdImageSaveAlpha(dst, 1);
  958.                 gdImageAlphaBlending(dst, 0);
  959.             }

  961.             gdImageCopy(dst, src, 0, 0, ox, oy, dx - ox, dy - oy);

  963.             if (colors) {
  964.                 gdImageTrueColorToPalette(dst, 1, 256);
  965.             }

  967.             gdImageDestroy(src);
  968.         }
  969.     }

  971.     if (transparent != -1 && colors) {
  972.         gdImageColorTransparent(dst, gdImageColorExact(dst, red, green, blue));
  973.     }

  975.     sharpen = ngx_http_image_filter_get_value(r, conf->shcv, conf->sharpen);
  976.     if (sharpen > 0) {
  977.         gdImageSharpen(dst, sharpen);
  978.     }

  980.     gdImageInterlace(dst, (int) conf->interlace);

  982.     out = ngx_http_image_out(r, ctx->type, dst, &size);

  984.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  985.                    "image: %d x %d %d", sx, sy, colors);

  987.     gdImageDestroy(dst);
  988.     ngx_pfree(r->pool, ctx->image);

  990.     if (out == NULL) {
  991.         return NULL;
  992.     }

  994.     cln = ngx_pool_cleanup_add(r->pool, 0);
  995.     if (cln == NULL) {
  996.         gdFree(out);
  997.         return NULL;
  998.     }

  1000.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  1001.     if (b == NULL) {
  1002.         gdFree(out);
  1003.         return NULL;
  1004.     }

  1006.     cln->handler = ngx_http_image_cleanup;
  1007.     cln->data = out;

  1009.     b->pos = out;
  1010.     b->last = out + size;
  1011.     b->memory = 1;
  1012.     b->last_buf = 1;

  1014.     ngx_http_image_length(r, b);
  1015.     ngx_http_weak_etag(r);

  1017.     return b;
  1018. }


  1021. static gdImagePtr
  1022. ‌ngx_http_image_source(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
  1023. {
  1024.     char        *failed;
  1025.     gdImagePtr   img;

  1027.     img = NULL;

  1029.     switch (ctx->type) {

  1031.     case NGX_HTTP_IMAGE_JPEG:
  1032.         img = gdImageCreateFromJpegPtr(ctx->length, ctx->image);
  1033.         failed = "gdImageCreateFromJpegPtr() failed";
  1034.         break;

  1036.     case NGX_HTTP_IMAGE_GIF:
  1037.         img = gdImageCreateFromGifPtr(ctx->length, ctx->image);
  1038.         failed = "gdImageCreateFromGifPtr() failed";
  1039.         break;

  1041.     case NGX_HTTP_IMAGE_PNG:
  1042.         img = gdImageCreateFromPngPtr(ctx->length, ctx->image);
  1043.         failed = "gdImageCreateFromPngPtr() failed";
  1044.         break;

  1046.     default:
  1047.         failed = "unknown image type";
  1048.         break;
  1049.     }

  1051.     if (img == NULL) {
  1052.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
  1053.     }

  1055.     return img;
  1056. }


  1059. static gdImagePtr
  1060. ‌ngx_http_image_new(ngx_http_request_t *r, int w, int h, int colors)
  1061. {
  1062.     gdImagePtr  img;

  1064.     if (colors == 0) {
  1065.         img = gdImageCreateTrueColor(w, h);

  1067.         if (img == NULL) {
  1068.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1069.                           "gdImageCreateTrueColor() failed");
  1070.             return NULL;
  1071.         }

  1073.     } else {
  1074.         img = gdImageCreate(w, h);

  1076.         if (img == NULL) {
  1077.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1078.                           "gdImageCreate() failed");
  1079.             return NULL;
  1080.         }
  1081.     }

  1083.     return img;
  1084. }


  1087. static u_char *
  1088. ‌ngx_http_image_out(ngx_http_request_t *r, ngx_uint_t type, gdImagePtr img,
  1089.     int *size)
  1090. {
  1091.     char                          *failed;
  1092.     u_char                        *out;
  1093.     ngx_int_t                      jq;
  1094.     ngx_http_image_filter_conf_t  *conf;

  1096.     out = NULL;

  1098.     switch (type) {

  1100.     case NGX_HTTP_IMAGE_JPEG:
  1101.         conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);

  1103.         jq = ngx_http_image_filter_get_value(r, conf->jqcv, conf->jpeg_quality);
  1104.         if (jq <= 0) {
  1105.             return NULL;
  1106.         }

  1108.         out = gdImageJpegPtr(img, size, jq);
  1109.         failed = "gdImageJpegPtr() failed";
  1110.         break;

  1112.     case NGX_HTTP_IMAGE_GIF:
  1113.         out = gdImageGifPtr(img, size);
  1114.         failed = "gdImageGifPtr() failed";
  1115.         break;

  1117.     case NGX_HTTP_IMAGE_PNG:
  1118.         out = gdImagePngPtr(img, size);
  1119.         failed = "gdImagePngPtr() failed";
  1120.         break;

  1122.     default:
  1123.         failed = "unknown image type";
  1124.         break;
  1125.     }

  1127.     if (out == NULL) {
  1128.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
  1129.     }

  1131.     return out;
  1132. }


  1135. static void
  1136. ‌ngx_http_image_cleanup(void *data)
  1137. {
  1138.     gdFree(data);
  1139. }


  1142. static ngx_uint_t
  1143. ‌ngx_http_image_filter_get_value(ngx_http_request_t *r,
  1144.     ngx_http_complex_value_t *cv, ngx_uint_t v)
  1145. {
  1146.     ngx_str_t  val;

  1148.     if (cv == NULL) {
  1149.         return v;
  1150.     }

  1152.     if (ngx_http_complex_value(r, cv, &val) != NGX_OK) {
  1153.         return 0;
  1154.     }

  1156.     return ngx_http_image_filter_value(&val);
  1157. }


  1160. static ngx_uint_t
  1161. ‌ngx_http_image_filter_value(ngx_str_t *value)
  1162. {
  1163.     ngx_int_t  n;

  1165.     if (value->len == 1 && value->data[0] == '-') {
  1166.         return (ngx_uint_t) -1;
  1167.     }

  1169.     n = ngx_atoi(value->data, value->len);

  1171.     if (n > 0) {
  1172.         return (ngx_uint_t) n;
  1173.     }

  1175.     return 0;
  1176. }


  1179. static void *
  1180. ‌ngx_http_image_filter_create_conf(ngx_conf_t *cf)
  1181. {
  1182.     ngx_http_image_filter_conf_t  *conf;

  1184.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_image_filter_conf_t));
  1185.     if (conf == NULL) {
  1186.         return NULL;
  1187.     }

  1189.     /*
  1190.      * set by ngx_pcalloc():
  1191.      *
  1192.      *     conf->width = 0;
  1193.      *     conf->height = 0;
  1194.      *     conf->angle = 0;
  1195.      *     conf->wcv = NULL;
  1196.      *     conf->hcv = NULL;
  1197.      *     conf->acv = NULL;
  1198.      *     conf->jqcv = NULL;
  1199.      *     conf->shcv = NULL;
  1200.      */

  1202.     conf->filter = NGX_CONF_UNSET_UINT;
  1203.     conf->jpeg_quality = NGX_CONF_UNSET_UINT;
  1204.     conf->sharpen = NGX_CONF_UNSET_UINT;
  1205.     conf->transparency = NGX_CONF_UNSET;
  1206.     conf->interlace = NGX_CONF_UNSET;
  1207.     conf->buffer_size = NGX_CONF_UNSET_SIZE;

  1209.     return conf;
  1210. }


  1213. static char *
  1214. ‌ngx_http_image_filter_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1215. {
  1216.     ngx_http_image_filter_conf_t *prev = parent;
  1217.     ngx_http_image_filter_conf_t *conf = child;

  1219.     if (conf->filter == NGX_CONF_UNSET_UINT) {

  1221.         if (prev->filter == NGX_CONF_UNSET_UINT) {
  1222.             conf->filter = NGX_HTTP_IMAGE_OFF;

  1224.         } else {
  1225.             conf->filter = prev->filter;
  1226.             conf->width = prev->width;
  1227.             conf->height = prev->height;
  1228.             conf->angle = prev->angle;
  1229.             conf->wcv = prev->wcv;
  1230.             conf->hcv = prev->hcv;
  1231.             conf->acv = prev->acv;
  1232.         }
  1233.     }

  1235.     if (conf->jpeg_quality == NGX_CONF_UNSET_UINT) {

  1237.         /* 75 is libjpeg default quality */
  1238.         ngx_conf_merge_uint_value(conf->jpeg_quality, prev->jpeg_quality, 75);

  1240.         if (conf->jqcv == NULL) {
  1241.             conf->jqcv = prev->jqcv;
  1242.         }
  1243.     }

  1245.     if (conf->sharpen == NGX_CONF_UNSET_UINT) {
  1246.         ngx_conf_merge_uint_value(conf->sharpen, prev->sharpen, 0);

  1248.         if (conf->shcv == NULL) {
  1249.             conf->shcv = prev->shcv;
  1250.         }
  1251.     }

  1253.     ngx_conf_merge_value(conf->transparency, prev->transparency, 1);

  1255.     ngx_conf_merge_value(conf->interlace, prev->interlace, 0);

  1257.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
  1258.                               1 * 1024 * 1024);

  1260.     return NGX_CONF_OK;
  1261. }


  1264. static char *
  1265. ‌ngx_http_image_filter(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1266. {
  1267.     ngx_http_image_filter_conf_t *imcf = conf;

  1269.     ngx_str_t                         *value;
  1270.     ngx_int_t                          n;
  1271.     ngx_uint_t                         i;
  1272.     ngx_http_complex_value_t           cv;
  1273.     ngx_http_compile_complex_value_t   ccv;

  1275.     value = cf->args->elts;

  1277.     i = 1;

  1279.     if (cf->args->nelts == 2) {
  1280.         if (ngx_strcmp(value[i].data, "off") == 0) {
  1281.             imcf->filter = NGX_HTTP_IMAGE_OFF;

  1283.         } else if (ngx_strcmp(value[i].data, "test") == 0) {
  1284.             imcf->filter = NGX_HTTP_IMAGE_TEST;

  1286.         } else if (ngx_strcmp(value[i].data, "size") == 0) {
  1287.             imcf->filter = NGX_HTTP_IMAGE_SIZE;

  1289.         } else {
  1290.             goto failed;
  1291.         }

  1293.         return NGX_CONF_OK;

  1295.     } else if (cf->args->nelts == 3) {

  1297.         if (ngx_strcmp(value[i].data, "rotate") == 0) {
  1298.             if (imcf->filter != NGX_HTTP_IMAGE_RESIZE
  1299.                 && imcf->filter != NGX_HTTP_IMAGE_CROP)
  1300.             {
  1301.                 imcf->filter = NGX_HTTP_IMAGE_ROTATE;
  1302.             }

  1304.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1306.             ccv.cf = cf;
  1307.             ccv.value = &value[++i];
  1308.             ccv.complex_value = &cv;

  1310.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1311.                 return NGX_CONF_ERROR;
  1312.             }

  1314.             if (cv.lengths == NULL) {
  1315.                 n = ngx_http_image_filter_value(&value[i]);

  1317.                 if (n != 90 && n != 180 && n != 270) {
  1318.                     goto failed;
  1319.                 }

  1321.                 imcf->angle = (ngx_uint_t) n;

  1323.             } else {
  1324.                 imcf->acv = ngx_palloc(cf->pool,
  1325.                                        sizeof(ngx_http_complex_value_t));
  1326.                 if (imcf->acv == NULL) {
  1327.                     return NGX_CONF_ERROR;
  1328.                 }

  1330.                 *imcf->acv = cv;
  1331.             }

  1333.             return NGX_CONF_OK;

  1335.         } else {
  1336.             goto failed;
  1337.         }
  1338.     }

  1340.     if (ngx_strcmp(value[i].data, "resize") == 0) {
  1341.         imcf->filter = NGX_HTTP_IMAGE_RESIZE;

  1343.     } else if (ngx_strcmp(value[i].data, "crop") == 0) {
  1344.         imcf->filter = NGX_HTTP_IMAGE_CROP;

  1346.     } else {
  1347.         goto failed;
  1348.     }

  1350.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1352.     ccv.cf = cf;
  1353.     ccv.value = &value[++i];
  1354.     ccv.complex_value = &cv;

  1356.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1357.         return NGX_CONF_ERROR;
  1358.     }

  1360.     if (cv.lengths == NULL) {
  1361.         n = ngx_http_image_filter_value(&value[i]);

  1363.         if (n == 0) {
  1364.             goto failed;
  1365.         }

  1367.         imcf->width = (ngx_uint_t) n;

  1369.     } else {
  1370.         imcf->wcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  1371.         if (imcf->wcv == NULL) {
  1372.             return NGX_CONF_ERROR;
  1373.         }

  1375.         *imcf->wcv = cv;
  1376.     }

  1378.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1380.     ccv.cf = cf;
  1381.     ccv.value = &value[++i];
  1382.     ccv.complex_value = &cv;

  1384.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1385.         return NGX_CONF_ERROR;
  1386.     }

  1388.     if (cv.lengths == NULL) {
  1389.         n = ngx_http_image_filter_value(&value[i]);

  1391.         if (n == 0) {
  1392.             goto failed;
  1393.         }

  1395.         imcf->height = (ngx_uint_t) n;

  1397.     } else {
  1398.         imcf->hcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  1399.         if (imcf->hcv == NULL) {
  1400.             return NGX_CONF_ERROR;
  1401.         }

  1403.         *imcf->hcv = cv;
  1404.     }

  1406.     return NGX_CONF_OK;

  1408. failed:

  1410.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"",
  1411.                        &value[i]);

  1413.     return NGX_CONF_ERROR;
  1414. }


  1417. static char *
  1418. ‌ngx_http_image_filter_jpeg_quality(ngx_conf_t *cf, ngx_command_t *cmd,
  1419.     void *conf)
  1420. {
  1421.     ngx_http_image_filter_conf_t *imcf = conf;

  1423.     ngx_str_t                         *value;
  1424.     ngx_int_t                          n;
  1425.     ngx_http_complex_value_t           cv;
  1426.     ngx_http_compile_complex_value_t   ccv;

  1428.     value = cf->args->elts;

  1430.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1432.     ccv.cf = cf;
  1433.     ccv.value = &value[1];
  1434.     ccv.complex_value = &cv;

  1436.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1437.         return NGX_CONF_ERROR;
  1438.     }

  1440.     if (cv.lengths == NULL) {
  1441.         n = ngx_http_image_filter_value(&value[1]);

  1443.         if (n <= 0) {
  1444.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1445.                                "invalid value \"%V\"", &value[1]);
  1446.             return NGX_CONF_ERROR;
  1447.         }

  1449.         imcf->jpeg_quality = (ngx_uint_t) n;

  1451.     } else {
  1452.         imcf->jqcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  1453.         if (imcf->jqcv == NULL) {
  1454.             return NGX_CONF_ERROR;
  1455.         }

  1457.         *imcf->jqcv = cv;
  1458.     }

  1460.     return NGX_CONF_OK;
  1461. }


  1464. static char *
  1465. ‌ngx_http_image_filter_sharpen(ngx_conf_t *cf, ngx_command_t *cmd,
  1466.     void *conf)
  1467. {
  1468.     ngx_http_image_filter_conf_t *imcf = conf;

  1470.     ngx_str_t                         *value;
  1471.     ngx_int_t                          n;
  1472.     ngx_http_complex_value_t           cv;
  1473.     ngx_http_compile_complex_value_t   ccv;

  1475.     value = cf->args->elts;

  1477.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1479.     ccv.cf = cf;
  1480.     ccv.value = &value[1];
  1481.     ccv.complex_value = &cv;

  1483.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1484.         return NGX_CONF_ERROR;
  1485.     }

  1487.     if (cv.lengths == NULL) {
  1488.         n = ngx_http_image_filter_value(&value[1]);

  1490.         if (n < 0) {
  1491.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1492.                                "invalid value \"%V\"", &value[1]);
  1493.             return NGX_CONF_ERROR;
  1494.         }

  1496.         imcf->sharpen = (ngx_uint_t) n;

  1498.     } else {
  1499.         imcf->shcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  1500.         if (imcf->shcv == NULL) {
  1501.             return NGX_CONF_ERROR;
  1502.         }

  1504.         *imcf->shcv = cv;
  1505.     }

  1507.     return NGX_CONF_OK;
  1508. }


  1511. static ngx_int_t
  1512. ‌ngx_http_image_filter_init(ngx_conf_t *cf)
  1513. {
  1514.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  1515.     ngx_http_top_header_filter = ngx_http_image_header_filter;

  1517.     ngx_http_next_body_filter = ngx_http_top_body_filter;
  1518.     ngx_http_top_body_filter = ngx_http_image_body_filter;

  1520.     return NGX_OK;
  1521. }

One Level Up Top Level