![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_image_filter_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules|
Return to ngx_http_image_filter_module.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules |
1.1 misho 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: }