~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Linux Cross Reference
Nginx/http/modules/ngx_http_image_filter_module.c

Version: ~ [ nginx-1.4.1 ] ~ [ nginx-1.5.0 ] ~

  1 
  2 /*
  3  * Copyright (C) Igor Sysoev
  4  * Copyright (C) Nginx, Inc.
  5  */
  6 
  7 
  8 #include <ngx_config.h>
  9 #include <ngx_core.h>
 10 #include <ngx_http.h>
 11 
 12 #include <gd.h>
 13 
 14 
 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
 21 
 22 
 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
 28 
 29 
 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
 34 
 35 
 36 #define NGX_HTTP_IMAGE_BUFFERED  0x08
 37 
 38 
 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;
 46 
 47     ngx_flag_t                   transparency;
 48     ngx_flag_t                   interlace;
 49 
 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;
 55 
 56     size_t                       buffer_size;
 57 } ngx_http_image_filter_conf_t;
 58 
 59 
 60 typedef struct {
 61     u_char                      *image;
 62     u_char                      *last;
 63 
 64     size_t                       length;
 65 
 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;
 71 
 72     ngx_uint_t                   phase;
 73     ngx_uint_t                   type;
 74     ngx_uint_t                   force;
 75 } ngx_http_image_filter_ctx_t;
 76 
 77 
 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);
 90 
 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);
103 
104 
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);
115 
116 
117 static ngx_command_t  ngx_http_image_filter_commands[] = {
118 
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 },
125 
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 },
132 
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 },
139 
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 },
146 
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 },
153 
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 },
160 
161       ngx_null_command
162 };
163 
164 
165 static ngx_http_module_t  ngx_http_image_filter_module_ctx = {
166     NULL,                                  /* preconfiguration */
167     ngx_http_image_filter_init,            /* postconfiguration */
168 
169     NULL,                                  /* create main configuration */
170     NULL,                                  /* init main configuration */
171 
172     NULL,                                  /* create server configuration */
173     NULL,                                  /* merge server configuration */
174 
175     ngx_http_image_filter_create_conf,     /* create location configuration */
176     ngx_http_image_filter_merge_conf       /* merge location configuration */
177 };
178 
179 
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 };
194 
195 
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;
198 
199 
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 };
205 
206 
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;
213 
214     if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED) {
215         return ngx_http_next_header_filter(r);
216     }
217 
218     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);
219 
220     if (ctx) {
221         ngx_http_set_ctx(r, NULL, ngx_http_image_filter_module);
222         return ngx_http_next_header_filter(r);
223     }
224 
225     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
226 
227     if (conf->filter == NGX_HTTP_IMAGE_OFF) {
228         return ngx_http_next_header_filter(r);
229     }
230 
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");
240 
241         return NGX_ERROR;
242     }
243 
244     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_image_filter_ctx_t));
245     if (ctx == NULL) {
246         return NGX_ERROR;
247     }
248 
249     ngx_http_set_ctx(r, ctx, ngx_http_image_filter_module);
250 
251     len = r->headers_out.content_length_n;
252 
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);
256 
257         return NGX_HTTP_UNSUPPORTED_MEDIA_TYPE;
258     }
259 
260     if (len == -1) {
261         ctx->length = conf->buffer_size;
262 
263     } else {
264         ctx->length = (size_t) len;
265     }
266 
267     if (r->headers_out.refresh) {
268         r->headers_out.refresh->hash = 0;
269     }
270 
271     r->main_filter_need_in_memory = 1;
272     r->allow_ranges = 0;
273 
274     return NGX_OK;
275 }
276 
277 
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;
286 
287     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "image filter");
288 
289     if (in == NULL) {
290         return ngx_http_next_body_filter(r, in);
291     }
292 
293     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);
294 
295     if (ctx == NULL) {
296         return ngx_http_next_body_filter(r, in);
297     }
298 
299     switch (ctx->phase) {
300 
301     case NGX_HTTP_IMAGE_START:
302 
303         ctx->type = ngx_http_image_test(r, in);
304 
305         conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
306 
307         if (ctx->type == NGX_HTTP_IMAGE_NONE) {
308 
309             if (conf->filter == NGX_HTTP_IMAGE_SIZE) {
310                 out.buf = ngx_http_image_json(r, NULL);
311 
312                 if (out.buf) {
313                     out.next = NULL;
314                     ctx->phase = NGX_HTTP_IMAGE_DONE;
315 
316                     return ngx_http_image_send(r, ctx, &out);
317                 }
318             }
319 
320             return ngx_http_filter_finalize_request(r,
321                                               &ngx_http_image_filter_module,
322                                               NGX_HTTP_UNSUPPORTED_MEDIA_TYPE);
323         }
324 
325         /* override content type */
326 
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;
331 
332         if (conf->filter == NGX_HTTP_IMAGE_TEST) {
333             ctx->phase = NGX_HTTP_IMAGE_PASS;
334 
335             return ngx_http_image_send(r, ctx, in);
336         }
337 
338         ctx->phase = NGX_HTTP_IMAGE_READ;
339 
340         /* fall through */
341 
342     case NGX_HTTP_IMAGE_READ:
343 
344         rc = ngx_http_image_read(r, in);
345 
346         if (rc == NGX_AGAIN) {
347             return NGX_OK;
348         }
349 
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         }
355 
356         /* fall through */
357 
358     case NGX_HTTP_IMAGE_PROCESS:
359 
360         out.buf = ngx_http_image_process(r);
361 
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         }
367 
368         out.next = NULL;
369         ctx->phase = NGX_HTTP_IMAGE_PASS;
370 
371         return ngx_http_image_send(r, ctx, &out);
372 
373     case NGX_HTTP_IMAGE_PASS:
374 
375         return ngx_http_next_body_filter(r, in);
376 
377     default: /* NGX_HTTP_IMAGE_DONE */
378 
379         rc = ngx_http_next_body_filter(r, NULL);
380 
381         /* NGX_ERROR resets any pending data */
382         return (rc == NGX_OK) ? NGX_ERROR : rc;
383     }
384 }
385 
386 
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;
392 
393     rc = ngx_http_next_header_filter(r);
394 
395     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
396         return NGX_ERROR;
397     }
398 
399     rc = ngx_http_next_body_filter(r, in);
400 
401     if (ctx->phase == NGX_HTTP_IMAGE_DONE) {
402         /* NGX_ERROR resets any pending data */
403         return (rc == NGX_OK) ? NGX_ERROR : rc;
404     }
405 
406     return rc;
407 }
408 
409 
410 static ngx_uint_t
411 ngx_http_image_test(ngx_http_request_t *r, ngx_chain_t *in)
412 {
413     u_char  *p;
414 
415     p = in->buf->pos;
416 
417     if (in->buf->last - p < 16) {
418         return NGX_HTTP_IMAGE_NONE;
419     }
420 
421     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
422                    "image filter: \"%c%c\"", p[0], p[1]);
423 
424     if (p[0] == 0xff && p[1] == 0xd8) {
425 
426         /* JPEG */
427 
428         return NGX_HTTP_IMAGE_JPEG;
429 
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         }
437 
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 */
442 
443         return NGX_HTTP_IMAGE_PNG;
444     }
445 
446     return NGX_HTTP_IMAGE_NONE;
447 }
448 
449 
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;
458 
459     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);
460 
461     if (ctx->image == NULL) {
462         ctx->image = ngx_palloc(r->pool, ctx->length);
463         if (ctx->image == NULL) {
464             return NGX_ERROR;
465         }
466 
467         ctx->last = ctx->image;
468     }
469 
470     p = ctx->last;
471 
472     for (cl = in; cl; cl = cl->next) {
473 
474         b = cl->buf;
475         size = b->last - b->pos;
476 
477         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
478                        "image buf: %uz", size);
479 
480         rest = ctx->image + ctx->length - p;
481         size = (rest < size) ? rest : size;
482 
483         p = ngx_cpymem(p, b->pos, size);
484         b->pos += size;
485 
486         if (b->last_buf) {
487             ctx->last = p;
488             return NGX_OK;
489         }
490     }
491 
492     ctx->last = p;
493     r->connection->buffered |= NGX_HTTP_IMAGE_BUFFERED;
494 
495     return NGX_AGAIN;
496 }
497 
498 
499 static ngx_buf_t *
500 ngx_http_image_process(ngx_http_request_t *r)
501 {
502     ngx_int_t                      rc;
503     ngx_http_image_filter_ctx_t   *ctx;
504     ngx_http_image_filter_conf_t  *conf;
505 
506     r->connection->buffered &= ~NGX_HTTP_IMAGE_BUFFERED;
507 
508     ctx = ngx_http_get_module_ctx(r, ngx_http_image_filter_module);
509 
510     rc = ngx_http_image_size(r, ctx);
511 
512     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
513 
514     if (conf->filter == NGX_HTTP_IMAGE_SIZE) {
515         return ngx_http_image_json(r, rc == NGX_OK ? ctx : NULL);
516     }
517 
518     ctx->angle = ngx_http_image_filter_get_value(r, conf->acv, conf->angle);
519 
520     if (conf->filter == NGX_HTTP_IMAGE_ROTATE) {
521 
522         if (ctx->angle != 90 && ctx->angle != 180 && ctx->angle != 270) {
523             return NULL;
524         }
525 
526         return ngx_http_image_resize(r, ctx);
527     }
528 
529     ctx->max_width = ngx_http_image_filter_get_value(r, conf->wcv, conf->width);
530     if (ctx->max_width == 0) {
531         return NULL;
532     }
533 
534     ctx->max_height = ngx_http_image_filter_get_value(r, conf->hcv,
535                                                       conf->height);
536     if (ctx->max_height == 0) {
537         return NULL;
538     }
539 
540     if (rc == NGX_OK
541         && ctx->width <= ctx->max_width
542         && ctx->height <= ctx->max_height
543         && ctx->angle == 0
544         && !ctx->force)
545     {
546         return ngx_http_image_asis(r, ctx);
547     }
548 
549     return ngx_http_image_resize(r, ctx);
550 }
551 
552 
553 static ngx_buf_t *
554 ngx_http_image_json(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
555 {
556     size_t      len;
557     ngx_buf_t  *b;
558 
559     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
560     if (b == NULL) {
561         return NULL;
562     }
563 
564     b->memory = 1;
565     b->last_buf = 1;
566 
567     ngx_http_clean_header(r);
568 
569     r->headers_out.status = NGX_HTTP_OK;
570     ngx_str_set(&r->headers_out.content_type, "text/plain");
571     r->headers_out.content_type_lowcase = NULL;
572 
573     if (ctx == NULL) {
574         b->pos = (u_char *) "{}" CRLF;
575         b->last = b->pos + sizeof("{}" CRLF) - 1;
576 
577         ngx_http_image_length(r, b);
578 
579         return b;
580     }
581 
582     len = sizeof("{ \"img\" : "
583                  "{ \"width\": , \"height\": , \"type\": \"jpeg\" } }" CRLF) - 1
584           + 2 * NGX_SIZE_T_LEN;
585 
586     b->pos = ngx_pnalloc(r->pool, len);
587     if (b->pos == NULL) {
588         return NULL;
589     }
590 
591     b->last = ngx_sprintf(b->pos,
592                           "{ \"img\" : "
593                                        "{ \"width\": %uz,"
594                                         " \"height\": %uz,"
595                                         " \"type\": \"%s\" } }" CRLF,
596                           ctx->width, ctx->height,
597                           ngx_http_image_types[ctx->type - 1].data + 6);
598 
599     ngx_http_image_length(r, b);
600 
601     return b;
602 }
603 
604 
605 static ngx_buf_t *
606 ngx_http_image_asis(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
607 {
608     ngx_buf_t  *b;
609 
610     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
611     if (b == NULL) {
612         return NULL;
613     }
614 
615     b->pos = ctx->image;
616     b->last = ctx->last;
617     b->memory = 1;
618     b->last_buf = 1;
619 
620     ngx_http_image_length(r, b);
621 
622     return b;
623 }
624 
625 
626 static void
627 ngx_http_image_length(ngx_http_request_t *r, ngx_buf_t *b)
628 {
629     r->headers_out.content_length_n = b->last - b->pos;
630 
631     if (r->headers_out.content_length) {
632         r->headers_out.content_length->hash = 0;
633     }
634 
635     r->headers_out.content_length = NULL;
636 }
637 
638 
639 static ngx_int_t
640 ngx_http_image_size(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
641 {
642     u_char      *p, *last;
643     size_t       len, app;
644     ngx_uint_t   width, height;
645 
646     p = ctx->image;
647 
648     switch (ctx->type) {
649 
650     case NGX_HTTP_IMAGE_JPEG:
651 
652         p += 2;
653         last = ctx->image + ctx->length - 10;
654         width = 0;
655         height = 0;
656         app = 0;
657 
658         while (p < last) {
659 
660             if (p[0] == 0xff && p[1] != 0xff) {
661 
662                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
663                                "JPEG: %02xd %02xd", p[0], p[1]);
664 
665                 p++;
666 
667                 if ((*p == 0xc0 || *p == 0xc1 || *p == 0xc2 || *p == 0xc3
668                      || *p == 0xc9 || *p == 0xca || *p == 0xcb)
669                     && (width == 0 || height == 0))
670                 {
671                     width = p[6] * 256 + p[7];
672                     height = p[4] * 256 + p[5];
673                 }
674 
675                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
676                                "JPEG: %02xd %02xd", p[1], p[2]);
677 
678                 len = p[1] * 256 + p[2];
679 
680                 if (*p >= 0xe1 && *p <= 0xef) {
681                     /* application data, e.g., EXIF, Adobe XMP, etc. */
682                     app += len;
683                 }
684 
685                 p += len;
686 
687                 continue;
688             }
689 
690             p++;
691         }
692 
693         if (width == 0 || height == 0) {
694             return NGX_DECLINED;
695         }
696 
697         if (ctx->length / 20 < app) {
698             /* force conversion if application data consume more than 5% */
699             ctx->force = 1;
700             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
701                            "app data size: %uz", app);
702         }
703 
704         break;
705 
706     case NGX_HTTP_IMAGE_GIF:
707 
708         if (ctx->length < 10) {
709             return NGX_DECLINED;
710         }
711 
712         width = p[7] * 256 + p[6];
713         height = p[9] * 256 + p[8];
714 
715         break;
716 
717     case NGX_HTTP_IMAGE_PNG:
718 
719         if (ctx->length < 24) {
720             return NGX_DECLINED;
721         }
722 
723         width = p[18] * 256 + p[19];
724         height = p[22] * 256 + p[23];
725 
726         break;
727 
728     default:
729 
730         return NGX_DECLINED;
731     }
732 
733     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
734                    "image size: %d x %d", width, height);
735 
736     ctx->width = width;
737     ctx->height = height;
738 
739     return NGX_OK;
740 }
741 
742 
743 static ngx_buf_t *
744 ngx_http_image_resize(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
745 {
746     int                            sx, sy, dx, dy, ox, oy, ax, ay, size,
747                                    colors, palette, transparent, sharpen,
748                                    red, green, blue, t;
749     u_char                        *out;
750     ngx_buf_t                     *b;
751     ngx_uint_t                     resize;
752     gdImagePtr                     src, dst;
753     ngx_pool_cleanup_t            *cln;
754     ngx_http_image_filter_conf_t  *conf;
755 
756     src = ngx_http_image_source(r, ctx);
757 
758     if (src == NULL) {
759         return NULL;
760     }
761 
762     sx = gdImageSX(src);
763     sy = gdImageSY(src);
764 
765     conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
766 
767     if (!ctx->force
768         && ctx->angle == 0
769         && (ngx_uint_t) sx <= ctx->max_width
770         && (ngx_uint_t) sy <= ctx->max_height)
771     {
772         gdImageDestroy(src);
773         return ngx_http_image_asis(r, ctx);
774     }
775 
776     colors = gdImageColorsTotal(src);
777 
778     if (colors && conf->transparency) {
779         transparent = gdImageGetTransparent(src);
780 
781         if (transparent != -1) {
782             palette = colors;
783             red = gdImageRed(src, transparent);
784             green = gdImageGreen(src, transparent);
785             blue = gdImageBlue(src, transparent);
786 
787             goto transparent;
788         }
789     }
790 
791     palette = 0;
792     transparent = -1;
793     red = 0;
794     green = 0;
795     blue = 0;
796 
797 transparent:
798 
799     gdImageColorTransparent(src, -1);
800 
801     dx = sx;
802     dy = sy;
803 
804     if (conf->filter == NGX_HTTP_IMAGE_RESIZE) {
805 
806         if ((ngx_uint_t) dx > ctx->max_width) {
807             dy = dy * ctx->max_width / dx;
808             dy = dy ? dy : 1;
809             dx = ctx->max_width;
810         }
811 
812         if ((ngx_uint_t) dy > ctx->max_height) {
813             dx = dx * ctx->max_height / dy;
814             dx = dx ? dx : 1;
815             dy = ctx->max_height;
816         }
817 
818         resize = 1;
819 
820     } else if (conf->filter == NGX_HTTP_IMAGE_ROTATE) {
821 
822         resize = 0;
823 
824     } else { /* NGX_HTTP_IMAGE_CROP */
825 
826         resize = 0;
827 
828         if ((double) dx / dy < (double) ctx->max_width / ctx->max_height) {
829             if ((ngx_uint_t) dx > ctx->max_width) {
830                 dy = dy * ctx->max_width / dx;
831                 dy = dy ? dy : 1;
832                 dx = ctx->max_width;
833                 resize = 1;
834             }
835 
836         } else {
837             if ((ngx_uint_t) dy > ctx->max_height) {
838                 dx = dx * ctx->max_height / dy;
839                 dx = dx ? dx : 1;
840                 dy = ctx->max_height;
841                 resize = 1;
842             }
843         }
844     }
845 
846     if (resize) {
847         dst = ngx_http_image_new(r, dx, dy, palette);
848         if (dst == NULL) {
849             gdImageDestroy(src);
850             return NULL;
851         }
852 
853         if (colors == 0) {
854             gdImageSaveAlpha(dst, 1);
855             gdImageAlphaBlending(dst, 0);
856         }
857 
858         gdImageCopyResampled(dst, src, 0, 0, 0, 0, dx, dy, sx, sy);
859 
860         if (colors) {
861             gdImageTrueColorToPalette(dst, 1, 256);
862         }
863 
864         gdImageDestroy(src);
865 
866     } else {
867         dst = src;
868     }
869 
870     if (ctx->angle) {
871         src = dst;
872 
873         ax = (dx % 2 == 0) ? 1 : 0;
874         ay = (dy % 2 == 0) ? 1 : 0;
875 
876         switch (ctx->angle) {
877 
878         case 90:
879         case 270:
880             dst = ngx_http_image_new(r, dy, dx, palette);
881             if (dst == NULL) {
882                 gdImageDestroy(src);
883                 return NULL;
884             }
885             if (ctx->angle == 90) {
886                 ox = dy / 2 + ay;
887                 oy = dx / 2 - ax;
888 
889             } else {
890                 ox = dy / 2 - ay;
891                 oy = dx / 2 + ax;
892             }
893 
894             gdImageCopyRotated(dst, src, ox, oy, 0, 0,
895                                dx + ax, dy + ay, ctx->angle);
896             gdImageDestroy(src);
897 
898             t = dx;
899             dx = dy;
900             dy = t;
901             break;
902 
903         case 180:
904             dst = ngx_http_image_new(r, dx, dy, palette);
905             if (dst == NULL) {
906                 gdImageDestroy(src);
907                 return NULL;
908             }
909             gdImageCopyRotated(dst, src, dx / 2 - ax, dy / 2 - ay, 0, 0,
910                                dx + ax, dy + ay, ctx->angle);
911             gdImageDestroy(src);
912             break;
913         }
914     }
915 
916     if (conf->filter == NGX_HTTP_IMAGE_CROP) {
917 
918         src = dst;
919 
920         if ((ngx_uint_t) dx > ctx->max_width) {
921             ox = dx - ctx->max_width;
922 
923         } else {
924             ox = 0;
925         }
926 
927         if ((ngx_uint_t) dy > ctx->max_height) {
928             oy = dy - ctx->max_height;
929 
930         } else {
931             oy = 0;
932         }
933 
934         if (ox || oy) {
935 
936             dst = ngx_http_image_new(r, dx - ox, dy - oy, colors);
937 
938             if (dst == NULL) {
939                 gdImageDestroy(src);
940                 return NULL;
941             }
942 
943             ox /= 2;
944             oy /= 2;
945 
946             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
947                            "image crop: %d x %d @ %d x %d",
948                            dx, dy, ox, oy);
949 
950             if (colors == 0) {
951                 gdImageSaveAlpha(dst, 1);
952                 gdImageAlphaBlending(dst, 0);
953             }
954 
955             gdImageCopy(dst, src, 0, 0, ox, oy, dx - ox, dy - oy);
956 
957             if (colors) {
958                 gdImageTrueColorToPalette(dst, 1, 256);
959             }
960 
961             gdImageDestroy(src);
962         }
963     }
964 
965     if (transparent != -1 && colors) {
966         gdImageColorTransparent(dst, gdImageColorExact(dst, red, green, blue));
967     }
968 
969     sharpen = ngx_http_image_filter_get_value(r, conf->shcv, conf->sharpen);
970     if (sharpen > 0) {
971         gdImageSharpen(dst, sharpen);
972     }
973 
974     gdImageInterlace(dst, (int) conf->interlace);
975 
976     out = ngx_http_image_out(r, ctx->type, dst, &size);
977 
978     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
979                    "image: %d x %d %d", sx, sy, colors);
980 
981     gdImageDestroy(dst);
982     ngx_pfree(r->pool, ctx->image);
983 
984     if (out == NULL) {
985         return NULL;
986     }
987 
988     cln = ngx_pool_cleanup_add(r->pool, 0);
989     if (cln == NULL) {
990         gdFree(out);
991         return NULL;
992     }
993 
994     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
995     if (b == NULL) {
996         gdFree(out);
997         return NULL;
998     }
999 
1000     cln->handler = ngx_http_image_cleanup;
1001     cln->data = out;
1002 
1003     b->pos = out;
1004     b->last = out + size;
1005     b->memory = 1;
1006     b->last_buf = 1;
1007 
1008     ngx_http_image_length(r, b);
1009 
1010     return b;
1011 }
1012 
1013 
1014 static gdImagePtr
1015 ngx_http_image_source(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
1016 {
1017     char        *failed;
1018     gdImagePtr   img;
1019 
1020     img = NULL;
1021 
1022     switch (ctx->type) {
1023 
1024     case NGX_HTTP_IMAGE_JPEG:
1025         img = gdImageCreateFromJpegPtr(ctx->length, ctx->image);
1026         failed = "gdImageCreateFromJpegPtr() failed";
1027         break;
1028 
1029     case NGX_HTTP_IMAGE_GIF:
1030         img = gdImageCreateFromGifPtr(ctx->length, ctx->image);
1031         failed = "gdImageCreateFromGifPtr() failed";
1032         break;
1033 
1034     case NGX_HTTP_IMAGE_PNG:
1035         img = gdImageCreateFromPngPtr(ctx->length, ctx->image);
1036         failed = "gdImageCreateFromPngPtr() failed";
1037         break;
1038 
1039     default:
1040         failed = "unknown image type";
1041         break;
1042     }
1043 
1044     if (img == NULL) {
1045         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
1046     }
1047 
1048     return img;
1049 }
1050 
1051 
1052 static gdImagePtr
1053 ngx_http_image_new(ngx_http_request_t *r, int w, int h, int colors)
1054 {
1055     gdImagePtr  img;
1056 
1057     if (colors == 0) {
1058         img = gdImageCreateTrueColor(w, h);
1059 
1060         if (img == NULL) {
1061             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
1062                           "gdImageCreateTrueColor() failed");
1063             return NULL;
1064         }
1065 
1066     } else {
1067         img = gdImageCreate(w, h);
1068 
1069         if (img == NULL) {
1070             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
1071                           "gdImageCreate() failed");
1072             return NULL;
1073         }
1074     }
1075 
1076     return img;
1077 }
1078 
1079 
1080 static u_char *
1081 ngx_http_image_out(ngx_http_request_t *r, ngx_uint_t type, gdImagePtr img,
1082     int *size)
1083 {
1084     char                          *failed;
1085     u_char                        *out;
1086     ngx_int_t                      jq;
1087     ngx_http_image_filter_conf_t  *conf;
1088 
1089     out = NULL;
1090 
1091     switch (type) {
1092 
1093     case NGX_HTTP_IMAGE_JPEG:
1094         conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module);
1095 
1096         jq = ngx_http_image_filter_get_value(r, conf->jqcv, conf->jpeg_quality);
1097         if (jq <= 0) {
1098             return NULL;
1099         }
1100 
1101         out = gdImageJpegPtr(img, size, jq);
1102         failed = "gdImageJpegPtr() failed";
1103         break;
1104 
1105     case NGX_HTTP_IMAGE_GIF:
1106         out = gdImageGifPtr(img, size);
1107         failed = "gdImageGifPtr() failed";
1108         break;
1109 
1110     case NGX_HTTP_IMAGE_PNG:
1111         out = gdImagePngPtr(img, size);
1112         failed = "gdImagePngPtr() failed";
1113         break;
1114 
1115     default:
1116         failed = "unknown image type";
1117         break;
1118     }
1119 
1120     if (out == NULL) {
1121         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
1122     }
1123 
1124     return out;
1125 }
1126 
1127 
1128 static void
1129 ngx_http_image_cleanup(void *data)
1130 {
1131     gdFree(data);
1132 }
1133 
1134 
1135 static ngx_uint_t
1136 ngx_http_image_filter_get_value(ngx_http_request_t *r,
1137     ngx_http_complex_value_t *cv, ngx_uint_t v)
1138 {
1139     ngx_str_t  val;
1140 
1141     if (cv == NULL) {
1142         return v;
1143     }
1144 
1145     if (ngx_http_complex_value(r, cv, &val) != NGX_OK) {
1146         return 0;
1147     }
1148 
1149     return ngx_http_image_filter_value(&val);
1150 }
1151 
1152 
1153 static ngx_uint_t
1154 ngx_http_image_filter_value(ngx_str_t *value)
1155 {
1156     ngx_int_t  n;
1157 
1158     if (value->len == 1 && value->data[0] == '-') {
1159         return (ngx_uint_t) -1;
1160     }
1161 
1162     n = ngx_atoi(value->data, value->len);
1163 
1164     if (n > 0) {
1165         return (ngx_uint_t) n;
1166     }
1167 
1168     return 0;
1169 }
1170 
1171 
1172 static void *
1173 ngx_http_image_filter_create_conf(ngx_conf_t *cf)
1174 {
1175     ngx_http_image_filter_conf_t  *conf;
1176 
1177     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_image_filter_conf_t));
1178     if (conf == NULL) {
1179         return NULL;
1180     }
1181 
1182     /*
1183      * set by ngx_pcalloc():
1184      *
1185      *     conf->width = 0;
1186      *     conf->height = 0;
1187      *     conf->angle = 0;
1188      *     conf->wcv = NULL;
1189      *     conf->hcv = NULL;
1190      *     conf->acv = NULL;
1191      *     conf->jqcv = NULL;
1192      *     conf->shcv = NULL;
1193      */
1194 
1195     conf->filter = NGX_CONF_UNSET_UINT;
1196     conf->jpeg_quality = NGX_CONF_UNSET_UINT;
1197     conf->sharpen = NGX_CONF_UNSET_UINT;
1198     conf->transparency = NGX_CONF_UNSET;
1199     conf->interlace = NGX_CONF_UNSET;
1200     conf->buffer_size = NGX_CONF_UNSET_SIZE;
1201 
1202     return conf;
1203 }
1204 
1205 
1206 static char *
1207 ngx_http_image_filter_merge_conf(ngx_conf_t *cf, void *parent, void *child)
1208 {
1209     ngx_http_image_filter_conf_t *prev = parent;
1210     ngx_http_image_filter_conf_t *conf = child;
1211 
1212     if (conf->filter == NGX_CONF_UNSET_UINT) {
1213 
1214         if (prev->filter == NGX_CONF_UNSET_UINT) {
1215             conf->filter = NGX_HTTP_IMAGE_OFF;
1216 
1217         } else {
1218             conf->filter = prev->filter;
1219             conf->width = prev->width;
1220             conf->height = prev->height;
1221             conf->angle = prev->angle;
1222             conf->wcv = prev->wcv;
1223             conf->hcv = prev->hcv;
1224             conf->acv = prev->acv;
1225         }
1226     }
1227 
1228     if (conf->jpeg_quality == NGX_CONF_UNSET_UINT) {
1229 
1230         /* 75 is libjpeg default quality */
1231         ngx_conf_merge_uint_value(conf->jpeg_quality, prev->jpeg_quality, 75);
1232 
1233         if (conf->jqcv == NULL) {
1234             conf->jqcv = prev->jqcv;
1235         }
1236     }
1237 
1238     if (conf->sharpen == NGX_CONF_UNSET_UINT) {
1239         ngx_conf_merge_uint_value(conf->sharpen, prev->sharpen, 0);
1240 
1241         if (conf->shcv == NULL) {
1242             conf->shcv = prev->shcv;
1243         }
1244     }
1245 
1246     ngx_conf_merge_value(conf->transparency, prev->transparency, 1);
1247 
1248     ngx_conf_merge_value(conf->interlace, prev->interlace, 0);
1249 
1250     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
1251                               1 * 1024 * 1024);
1252 
1253     return NGX_CONF_OK;
1254 }
1255 
1256 
1257 static char *
1258 ngx_http_image_filter(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1259 {
1260     ngx_http_image_filter_conf_t *imcf = conf;
1261 
1262     ngx_str_t                         *value;
1263     ngx_int_t                          n;
1264     ngx_uint_t                         i;
1265     ngx_http_complex_value_t           cv;
1266     ngx_http_compile_complex_value_t   ccv;
1267 
1268     value = cf->args->elts;
1269 
1270     i = 1;
1271 
1272     if (cf->args->nelts == 2) {
1273         if (ngx_strcmp(value[i].data, "off") == 0) {
1274             imcf->filter = NGX_HTTP_IMAGE_OFF;
1275 
1276         } else if (ngx_strcmp(value[i].data, "test") == 0) {
1277             imcf->filter = NGX_HTTP_IMAGE_TEST;
1278 
1279         } else if (ngx_strcmp(value[i].data, "size") == 0) {
1280             imcf->filter = NGX_HTTP_IMAGE_SIZE;
1281 
1282         } else {
1283             goto failed;
1284         }
1285 
1286         return NGX_CONF_OK;
1287 
1288     } else if (cf->args->nelts == 3) {
1289 
1290         if (ngx_strcmp(value[i].data, "rotate") == 0) {
1291             if (imcf->filter != NGX_HTTP_IMAGE_RESIZE
1292                 && imcf->filter != NGX_HTTP_IMAGE_CROP)
1293             {
1294                 imcf->filter = NGX_HTTP_IMAGE_ROTATE;
1295             }
1296 
1297             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
1298 
1299             ccv.cf = cf;
1300             ccv.value = &value[++i];
1301             ccv.complex_value = &cv;
1302 
1303             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
1304                 return NGX_CONF_ERROR;
1305             }
1306 
1307             if (cv.lengths == NULL) {
1308                 n = ngx_http_image_filter_value(&value[i]);
1309 
1310                 if (n != 90 && n != 180 && n != 270) {
1311                     goto failed;
1312                 }
1313 
1314                 imcf->angle = (ngx_uint_t) n;
1315 
1316             } else {
1317                 imcf->acv = ngx_palloc(cf->pool,
1318                                        sizeof(ngx_http_complex_value_t));
1319                 if (imcf->acv == NULL) {
1320                     return NGX_CONF_ERROR;
1321                 }
1322 
1323                 *imcf->acv = cv;
1324             }
1325 
1326             return NGX_CONF_OK;
1327 
1328         } else {
1329             goto failed;
1330         }
1331     }
1332 
1333     if (ngx_strcmp(value[i].data, "resize") == 0) {
1334         imcf->filter = NGX_HTTP_IMAGE_RESIZE;
1335 
1336     } else if (ngx_strcmp(value[i].data, "crop") == 0) {
1337         imcf->filter = NGX_HTTP_IMAGE_CROP;
1338 
1339     } else {
1340         goto failed;
1341     }
1342 
1343     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
1344 
1345     ccv.cf = cf;
1346     ccv.value = &value[++i];
1347     ccv.complex_value = &cv;
1348 
1349     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
1350         return NGX_CONF_ERROR;
1351     }
1352 
1353     if (cv.lengths == NULL) {
1354         n = ngx_http_image_filter_value(&value[i]);
1355 
1356         if (n == 0) {
1357             goto failed;
1358         }
1359 
1360         imcf->width = (ngx_uint_t) n;
1361 
1362     } else {
1363         imcf->wcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
1364         if (imcf->wcv == NULL) {
1365             return NGX_CONF_ERROR;
1366         }
1367 
1368         *imcf->wcv = cv;
1369     }
1370 
1371     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
1372 
1373     ccv.cf = cf;
1374     ccv.value = &value[++i];
1375     ccv.complex_value = &cv;
1376 
1377     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
1378         return NGX_CONF_ERROR;
1379     }
1380 
1381     if (cv.lengths == NULL) {
1382         n = ngx_http_image_filter_value(&value[i]);
1383 
1384         if (n == 0) {
1385             goto failed;
1386         }
1387 
1388         imcf->height = (ngx_uint_t) n;
1389 
1390     } else {
1391         imcf->hcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
1392         if (imcf->hcv == NULL) {
1393             return NGX_CONF_ERROR;
1394         }
1395 
1396         *imcf->hcv = cv;
1397     }
1398 
1399     return NGX_CONF_OK;
1400 
1401 failed:
1402 
1403     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"",
1404                        &value[i]);
1405 
1406     return NGX_CONF_ERROR;
1407 }
1408 
1409 
1410 static char *
1411 ngx_http_image_filter_jpeg_quality(ngx_conf_t *cf, ngx_command_t *cmd,
1412     void *conf)
1413 {
1414     ngx_http_image_filter_conf_t *imcf = conf;
1415 
1416     ngx_str_t                         *value;
1417     ngx_int_t                          n;
1418     ngx_http_complex_value_t           cv;
1419     ngx_http_compile_complex_value_t   ccv;
1420 
1421     value = cf->args->elts;
1422 
1423     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
1424 
1425     ccv.cf = cf;
1426     ccv.value = &value[1];
1427     ccv.complex_value = &cv;
1428 
1429     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
1430         return NGX_CONF_ERROR;
1431     }
1432 
1433     if (cv.lengths == NULL) {
1434         n = ngx_http_image_filter_value(&value[1]);
1435 
1436         if (n <= 0) {
1437             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1438                                "invalid value \"%V\"", &value[1]);
1439             return NGX_CONF_ERROR;
1440         }
1441 
1442         imcf->jpeg_quality = (ngx_uint_t) n;
1443 
1444     } else {
1445         imcf->jqcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
1446         if (imcf->jqcv == NULL) {
1447             return NGX_CONF_ERROR;
1448         }
1449 
1450         *imcf->jqcv = cv;
1451     }
1452 
1453     return NGX_CONF_OK;
1454 }
1455 
1456 
1457 static char *
1458 ngx_http_image_filter_sharpen(ngx_conf_t *cf, ngx_command_t *cmd,
1459     void *conf)
1460 {
1461     ngx_http_image_filter_conf_t *imcf = conf;
1462 
1463     ngx_str_t                         *value;
1464     ngx_int_t                          n;
1465     ngx_http_complex_value_t           cv;
1466     ngx_http_compile_complex_value_t   ccv;
1467 
1468     value = cf->args->elts;
1469 
1470     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
1471 
1472     ccv.cf = cf;
1473     ccv.value = &value[1];
1474     ccv.complex_value = &cv;
1475 
1476     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
1477         return NGX_CONF_ERROR;
1478     }
1479 
1480     if (cv.lengths == NULL) {
1481         n = ngx_http_image_filter_value(&value[1]);
1482 
1483         if (n < 0) {
1484             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1485                                "invalid value \"%V\"", &value[1]);
1486             return NGX_CONF_ERROR;
1487         }
1488 
1489         imcf->sharpen = (ngx_uint_t) n;
1490 
1491     } else {
1492         imcf->shcv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
1493         if (imcf->shcv == NULL) {
1494             return NGX_CONF_ERROR;
1495         }
1496 
1497         *imcf->shcv = cv;
1498     }
1499 
1500     return NGX_CONF_OK;
1501 }
1502 
1503 
1504 static ngx_int_t
1505 ngx_http_image_filter_init(ngx_conf_t *cf)
1506 {
1507     ngx_http_next_header_filter = ngx_http_top_header_filter;
1508     ngx_http_top_header_filter = ngx_http_image_header_filter;
1509 
1510     ngx_http_next_body_filter = ngx_http_top_body_filter;
1511     ngx_http_top_body_filter = ngx_http_image_body_filter;
1512 
1513     return NGX_OK;
1514 }
1515 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.