From ff4fc5ef12a37716c5c5d8928a2db92428e916ec Mon Sep 17 00:00:00 2001 From: Luca Barbato Date: Wed, 15 May 2013 19:03:53 +0200 Subject: [PATCH] jpegls: K&R formatting cosmetics Signed-off-by: Diego Biurrun --- libavcodec/jpegls.c | 73 +++++++------ libavcodec/jpegls.h | 78 ++++++++------ libavcodec/jpeglsdec.c | 208 ++++++++++++++++++----------------- libavcodec/jpeglsdec.h | 3 +- libavcodec/jpeglsenc.c | 240 +++++++++++++++++++++++------------------ 5 files changed, 336 insertions(+), 266 deletions(-) diff --git a/libavcodec/jpegls.c b/libavcodec/jpegls.c index bbe1a04e56..52a4500636 100644 --- a/libavcodec/jpegls.c +++ b/libavcodec/jpegls.c @@ -27,63 +27,76 @@ #include "jpegls.h" -void ff_jpegls_init_state(JLSState *state){ +void ff_jpegls_init_state(JLSState *state) +{ int i; state->twonear = state->near * 2 + 1; state->range = (state->maxval + state->twonear - 1) / state->twonear + 1; // QBPP = ceil(log2(RANGE)) - for(state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++); + for (state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++) + ; - if(state->bpp < 8) - state->limit = 16 + 2 * state->bpp - state->qbpp; + if (state->bpp < 8) + state->limit = 2 * state->bpp - state->qbpp + 16; else state->limit = 4 * state->bpp - state->qbpp; - for(i = 0; i < 367; i++) { + for (i = 0; i < 367; i++) { state->A[i] = FFMAX(state->range + 32 >> 6, 2); state->N[i] = 1; } - } /** * Custom value clipping function used in T1, T2, T3 calculation */ -static inline int iso_clip(int v, int vmin, int vmax){ - if(v > vmax || v < vmin) return vmin; - else return v; +static inline int iso_clip(int v, int vmin, int vmax) +{ + if (v > vmax || v < vmin) + return vmin; + else + return v; } -void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all){ - const int basic_t1= 3; - const int basic_t2= 7; - const int basic_t3= 21; +void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all) +{ + const int basic_t1 = 3; + const int basic_t2 = 7; + const int basic_t3 = 21; int factor; - if(s->maxval==0 || reset_all) s->maxval= (1 << s->bpp) - 1; + if (s->maxval == 0 || reset_all) + s->maxval = (1 << s->bpp) - 1; - if(s->maxval >=128){ + if (s->maxval >= 128) { factor = FFMIN(s->maxval, 4095) + 128 >> 8; - if(s->T1==0 || reset_all) - s->T1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval); - if(s->T2==0 || reset_all) - s->T2= iso_clip(factor*(basic_t2-3) + 3 + 5*s->near, s->T1, s->maxval); - if(s->T3==0 || reset_all) - s->T3= iso_clip(factor*(basic_t3-4) + 4 + 7*s->near, s->T2, s->maxval); - }else{ - factor= 256 / (s->maxval + 1); + if (s->T1 == 0 || reset_all) + s->T1 = iso_clip(factor * (basic_t1 - 2) + 2 + 3 * s->near, + s->near + 1, s->maxval); + if (s->T2 == 0 || reset_all) + s->T2 = iso_clip(factor * (basic_t2 - 3) + 3 + 5 * s->near, + s->T1, s->maxval); + if (s->T3 == 0 || reset_all) + s->T3 = iso_clip(factor * (basic_t3 - 4) + 4 + 7 * s->near, + s->T2, s->maxval); + } else { + factor = 256 / (s->maxval + 1); - if(s->T1==0 || reset_all) - s->T1= iso_clip(FFMAX(2, basic_t1/factor + 3*s->near), s->near+1, s->maxval); - if(s->T2==0 || reset_all) - s->T2= iso_clip(FFMAX(3, basic_t2/factor + 5*s->near), s->T1, s->maxval); - if(s->T3==0 || reset_all) - s->T3= iso_clip(FFMAX(4, basic_t3/factor + 7*s->near), s->T2, s->maxval); + if (s->T1 == 0 || reset_all) + s->T1 = iso_clip(FFMAX(2, basic_t1 / factor + 3 * s->near), + s->near + 1, s->maxval); + if (s->T2 == 0 || reset_all) + s->T2 = iso_clip(FFMAX(3, basic_t2 / factor + 5 * s->near), + s->T1, s->maxval); + if (s->T3 == 0 || reset_all) + s->T3 = iso_clip(FFMAX(4, basic_t3 / factor + 7 * s->near), + s->T2, s->maxval); } - if(s->reset==0 || reset_all) s->reset= 64; + if (s->reset == 0 || reset_all) + s->reset = 64; av_dlog(NULL, "[JPEG-LS RESET] T=%i,%i,%i\n", s->T1, s->T2, s->T3); } diff --git a/libavcodec/jpegls.h b/libavcodec/jpegls.h index 18c71a82d0..4bf95626f9 100644 --- a/libavcodec/jpegls.h +++ b/libavcodec/jpegls.h @@ -28,21 +28,21 @@ #ifndef AVCODEC_JPEGLS_H #define AVCODEC_JPEGLS_H -#include "avcodec.h" #include "libavutil/common.h" +#include "avcodec.h" -typedef struct JpeglsContext{ +typedef struct JpeglsContext { AVCodecContext *avctx; AVFrame picture; -}JpeglsContext; +} JpeglsContext; -typedef struct JLSState{ +typedef struct JLSState { int T1, T2, T3; int A[367], B[367], C[365], N[367]; int limit, reset, bpp, qbpp, maxval, range; int near, twonear; int run_index[3]; -}JLSState; +} JLSState; extern const uint8_t ff_log2_run[32]; @@ -54,19 +54,29 @@ void ff_jpegls_init_state(JLSState *state); /** * Calculate quantized gradient value, used for context determination */ -static inline int ff_jpegls_quantize(JLSState *s, int v){ //FIXME optimize - if(v==0) return 0; - if(v < 0){ - if(v <= -s->T3) return -4; - if(v <= -s->T2) return -3; - if(v <= -s->T1) return -2; - if(v < -s->near) return -1; +static inline int ff_jpegls_quantize(JLSState *s, int v) +{ + if (v == 0) return 0; - }else{ - if(v <= s->near) return 0; - if(v < s->T1) return 1; - if(v < s->T2) return 2; - if(v < s->T3) return 3; + if (v < 0) { + if (v <= -s->T3) + return -4; + if (v <= -s->T2) + return -3; + if (v <= -s->T1) + return -2; + if (v < -s->near) + return -1; + return 0; + } else { + if (v <= s->near) + return 0; + if (v < s->T1) + return 1; + if (v < s->T2) + return 2; + if (v < s->T3) + return 3; return 4; } } @@ -76,37 +86,39 @@ static inline int ff_jpegls_quantize(JLSState *s, int v){ //FIXME optimize */ void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all); - -static inline void ff_jpegls_downscale_state(JLSState *state, int Q){ - if(state->N[Q] == state->reset){ - state->A[Q] >>=1; - state->B[Q] >>=1; - state->N[Q] >>=1; +static inline void ff_jpegls_downscale_state(JLSState *state, int Q) +{ + if (state->N[Q] == state->reset) { + state->A[Q] >>= 1; + state->B[Q] >>= 1; + state->N[Q] >>= 1; } state->N[Q]++; } -static inline int ff_jpegls_update_state_regular(JLSState *state, int Q, int err){ +static inline int ff_jpegls_update_state_regular(JLSState *state, + int Q, int err) +{ state->A[Q] += FFABS(err); - err *= state->twonear; + err *= state->twonear; state->B[Q] += err; ff_jpegls_downscale_state(state, Q); - if(state->B[Q] <= -state->N[Q]) { - state->B[Q]= FFMAX(state->B[Q] + state->N[Q], 1-state->N[Q]); - if(state->C[Q] > -128) + if (state->B[Q] <= -state->N[Q]) { + state->B[Q] = FFMAX(state->B[Q] + state->N[Q], 1 - state->N[Q]); + if (state->C[Q] > -128) state->C[Q]--; - }else if(state->B[Q] > 0){ - state->B[Q]= FFMIN(state->B[Q] - state->N[Q], 0); - if(state->C[Q] < 127) + } else if (state->B[Q] > 0) { + state->B[Q] = FFMIN(state->B[Q] - state->N[Q], 0); + if (state->C[Q] < 127) state->C[Q]++; } return err; } -#define R(a, i ) (bits == 8 ? ((uint8_t*)(a))[i] : ((uint16_t*)(a))[i] ) -#define W(a, i, v) (bits == 8 ? (((uint8_t*)(a))[i]=v) : (((uint16_t*)(a))[i]=v)) +#define R(a, i) (bits == 8 ? ((uint8_t *)(a))[i] : ((uint16_t *)(a))[i]) +#define W(a, i, v) (bits == 8 ? (((uint8_t *)(a))[i] = v) : (((uint16_t *)(a))[i] = v)) #endif /* AVCODEC_JPEGLS_H */ diff --git a/libavcodec/jpeglsdec.c b/libavcodec/jpeglsdec.c index 5f01631ad2..6d884a4771 100644 --- a/libavcodec/jpeglsdec.c +++ b/libavcodec/jpeglsdec.c @@ -34,18 +34,16 @@ #include "jpegls.h" #include "jpeglsdec.h" - /* -* Uncomment this to significantly speed up decoding of broken JPEG-LS -* (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit. -* -* There is no Golomb code with length >= 32 bits possible, so check and -* avoid situation of 32 zeros, Libav Golomb decoder is painfully slow -* on this errors. -*/ + * Uncomment this to significantly speed up decoding of broken JPEG-LS + * (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit. + * + * There is no Golomb code with length >= 32 bits possible, so check and + * avoid situation of 32 zeros, Libav Golomb decoder is painfully slow + * on this errors. + */ //#define JLS_BROKEN - /** * Decode LSE block with initialization parameters */ @@ -56,13 +54,13 @@ int ff_jpegls_decode_lse(MJpegDecodeContext *s) skip_bits(&s->gb, 16); /* length: FIXME: verify field validity */ id = get_bits(&s->gb, 8); - switch(id){ + switch (id) { case 1: - s->maxval= get_bits(&s->gb, 16); - s->t1= get_bits(&s->gb, 16); - s->t2= get_bits(&s->gb, 16); - s->t3= get_bits(&s->gb, 16); - s->reset= get_bits(&s->gb, 16); + s->maxval = get_bits(&s->gb, 16); + s->t1 = get_bits(&s->gb, 16); + s->t2 = get_bits(&s->gb, 16); + s->t3 = get_bits(&s->gb, 16); + s->reset = get_bits(&s->gb, 16); // ff_jpegls_reset_coding_parameters(s, 0); //FIXME quant table? @@ -86,27 +84,30 @@ int ff_jpegls_decode_lse(MJpegDecodeContext *s) /** * Get context-dependent Golomb code, decode it and update context */ -static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q){ +static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q) +{ int k, ret; - for(k = 0; (state->N[Q] << k) < state->A[Q]; k++); + for (k = 0; (state->N[Q] << k) < state->A[Q]; k++) + ; #ifdef JLS_BROKEN - if(!show_bits_long(gb, 32))return -1; + if (!show_bits_long(gb, 32)) + return -1; #endif ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp); /* decode mapped error */ - if(ret & 1) + if (ret & 1) ret = -(ret + 1 >> 1); else ret >>= 1; /* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */ - if(!state->near && !k && (2 * state->B[Q] <= -state->N[Q])) + if (!state->near && !k && (2 * state->B[Q] <= -state->N[Q])) ret = -(ret + 1); - ret= ff_jpegls_update_state_regular(state, Q, ret); + ret = ff_jpegls_update_state_regular(state, Q, ret); return ret; } @@ -114,28 +115,33 @@ static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q) /** * Get Golomb code, decode it and update state for run termination */ -static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RItype, int limit_add){ +static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, + int RItype, int limit_add) +{ int k, ret, temp, map; int Q = 365 + RItype; - temp= state->A[Q]; - if(RItype) + temp = state->A[Q]; + if (RItype) temp += state->N[Q] >> 1; - for(k = 0; (state->N[Q] << k) < temp; k++); + for (k = 0; (state->N[Q] << k) < temp; k++) + ; #ifdef JLS_BROKEN - if(!show_bits_long(gb, 32))return -1; + if (!show_bits_long(gb, 32)) + return -1; #endif - ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1, state->qbpp); + ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1, + state->qbpp); /* decode mapped error */ map = 0; - if(!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q])) + if (!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q])) map = 1; ret += RItype + map; - if(ret & 1){ + if (ret & 1) { ret = map - (ret + 1 >> 1); state->B[Q]++; } else { @@ -144,7 +150,7 @@ static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RI /* update state */ state->A[Q] += FFABS(ret) - RItype; - ret *= state->twonear; + ret *= state->twonear; ff_jpegls_downscale_state(state, Q); return ret; @@ -153,12 +159,15 @@ static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RI /** * Decode one line of image */ -static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *last, void *dst, int last2, int w, int stride, int comp, int bits){ +static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, + void *last, void *dst, int last2, int w, + int stride, int comp, int bits) +{ int i, x = 0; int Ra, Rb, Rc, Rd; int D0, D1, D2; - while(x < w) { + while (x < w) { int err, pred; /* compute gradients */ @@ -170,49 +179,51 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void * D1 = Rb - Rc; D2 = Rc - Ra; /* run mode */ - if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) { + if ((FFABS(D0) <= state->near) && + (FFABS(D1) <= state->near) && + (FFABS(D2) <= state->near)) { int r; int RItype; /* decode full runs while available */ - while(get_bits1(&s->gb)) { + while (get_bits1(&s->gb)) { int r; r = 1 << ff_log2_run[state->run_index[comp]]; - if(x + r * stride > w) { + if (x + r * stride > w) r = (w - x) / stride; - } - for(i = 0; i < r; i++) { + for (i = 0; i < r; i++) { W(dst, x, Ra); x += stride; } /* if EOL reached, we stop decoding */ if (r != 1 << ff_log2_run[state->run_index[comp]]) return; - if(state->run_index[comp] < 31) + if (state->run_index[comp] < 31) state->run_index[comp]++; - if(x + stride > w) + if (x + stride > w) return; } /* decode aborted run */ r = ff_log2_run[state->run_index[comp]]; - if(r) + if (r) r = get_bits_long(&s->gb, r); - for(i = 0; i < r; i++) { + for (i = 0; i < r; i++) { W(dst, x, Ra); x += stride; } /* decode run termination value */ - Rb = R(last, x); + Rb = R(last, x); RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0; - err = ls_get_code_runterm(&s->gb, state, RItype, ff_log2_run[state->run_index[comp]]); - if(state->run_index[comp]) + err = ls_get_code_runterm(&s->gb, state, RItype, + ff_log2_run[state->run_index[comp]]); + if (state->run_index[comp]) state->run_index[comp]--; - if(state->near && RItype){ + if (state->near && RItype) { pred = Ra + err; } else { - if(Rb < Ra) + if (Rb < Ra) pred = Rb - err; else pred = Rb + err; @@ -220,31 +231,33 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void * } else { /* regular mode */ int context, sign; - context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2); - pred = mid_pred(Ra, Ra + Rb - Rc, Rb); + context = ff_jpegls_quantize(state, D0) * 81 + + ff_jpegls_quantize(state, D1) * 9 + + ff_jpegls_quantize(state, D2); + pred = mid_pred(Ra, Ra + Rb - Rc, Rb); - if(context < 0){ + if (context < 0) { context = -context; - sign = 1; - }else{ + sign = 1; + } else { sign = 0; } - if(sign){ + if (sign) { pred = av_clip(pred - state->C[context], 0, state->maxval); - err = -ls_get_code_regular(&s->gb, state, context); + err = -ls_get_code_regular(&s->gb, state, context); } else { pred = av_clip(pred + state->C[context], 0, state->maxval); - err = ls_get_code_regular(&s->gb, state, context); + err = ls_get_code_regular(&s->gb, state, context); } /* we have to do something more for near-lossless coding */ pred += err; } - if(state->near){ - if(pred < -state->near) + if (state->near) { + if (pred < -state->near) pred += state->range * state->twonear; - else if(pred > state->maxval + state->near) + else if (pred > state->maxval + state->near) pred -= state->range * state->twonear; pred = av_clip(pred, 0, state->maxval); } @@ -255,7 +268,9 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void * } } -int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv){ +int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, + int point_transform, int ilv) +{ int i, t = 0; uint8_t *zero, *last, *cur; JLSState *state; @@ -263,43 +278,45 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor zero = av_mallocz(s->picture_ptr->linesize[0]); last = zero; - cur = s->picture_ptr->data[0]; + cur = s->picture_ptr->data[0]; state = av_mallocz(sizeof(JLSState)); /* initialize JPEG-LS state from JPEG parameters */ - state->near = near; - state->bpp = (s->bits < 2) ? 2 : s->bits; + state->near = near; + state->bpp = (s->bits < 2) ? 2 : s->bits; state->maxval = s->maxval; - state->T1 = s->t1; - state->T2 = s->t2; - state->T3 = s->t3; - state->reset = s->reset; + state->T1 = s->t1; + state->T2 = s->t2; + state->T3 = s->t3; + state->reset = s->reset; ff_jpegls_reset_coding_parameters(state, 0); ff_jpegls_init_state(state); - if(s->bits <= 8) + if (s->bits <= 8) shift = point_transform + (8 - s->bits); else shift = point_transform + (16 - s->bits); - av_dlog(s->avctx, "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n", + av_dlog(s->avctx, + "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) " + "RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n", s->width, s->height, state->near, state->maxval, state->T1, state->T2, state->T3, state->reset, state->limit, state->qbpp, state->range); av_dlog(s->avctx, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n", ilv, point_transform, s->bits, s->cur_scan); - if(ilv == 0) { /* separate planes */ - off = s->cur_scan - 1; + if (ilv == 0) { /* separate planes */ + off = s->cur_scan - 1; stride = (s->nb_components > 1) ? 3 : 1; - width = s->width * stride; - cur += off; - for(i = 0; i < s->height; i++) { - if(s->bits <= 8){ - ls_decode_line(state, s, last, cur, t, width, stride, off, 8); + width = s->width * stride; + cur += off; + for (i = 0; i < s->height; i++) { + if (s->bits <= 8) { + ls_decode_line(state, s, last, cur, t, width, stride, off, 8); t = last[0]; - }else{ + } else { ls_decode_line(state, s, last, cur, t, width, stride, off, 16); - t = *((uint16_t*)last); + t = *((uint16_t *)last); } last = cur; cur += s->picture_ptr->linesize[0]; @@ -309,14 +326,15 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor skip_bits(&s->gb, 16); /* skip RSTn */ } } - } else if(ilv == 1) { /* line interleaving */ + } else if (ilv == 1) { /* line interleaving */ int j; - int Rc[3] = {0, 0, 0}; + int Rc[3] = { 0, 0, 0 }; memset(cur, 0, s->picture_ptr->linesize[0]); width = s->width * 3; - for(i = 0; i < s->height; i++) { - for(j = 0; j < 3; j++) { - ls_decode_line(state, s, last + j, cur + j, Rc[j], width, 3, j, 8); + for (i = 0; i < s->height; i++) { + for (j = 0; j < 3; j++) { + ls_decode_line(state, s, last + j, cur + j, + Rc[j], width, 3, j, 8); Rc[j] = last[j]; if (s->restart_interval && !--s->restart_count) { @@ -327,35 +345,34 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor last = cur; cur += s->picture_ptr->linesize[0]; } - } else if(ilv == 2) { /* sample interleaving */ - av_log(s->avctx, AV_LOG_ERROR, "Sample interleaved images are not supported.\n"); + } else if (ilv == 2) { /* sample interleaving */ + av_log(s->avctx, AV_LOG_ERROR, + "Sample interleaved images are not supported.\n"); av_free(state); av_free(zero); return -1; } - if(shift){ /* we need to do point transform or normalize samples */ + if (shift) { /* we need to do point transform or normalize samples */ int x, w; w = s->width * s->nb_components; - if(s->bits <= 8){ + if (s->bits <= 8) { uint8_t *src = s->picture_ptr->data[0]; - for(i = 0; i < s->height; i++){ - for(x = off; x < w; x+= stride){ + for (i = 0; i < s->height; i++) { + for (x = off; x < w; x += stride) src[x] <<= shift; - } src += s->picture_ptr->linesize[0]; } - }else{ - uint16_t *src = (uint16_t*) s->picture_ptr->data[0]; + } else { + uint16_t *src = (uint16_t *)s->picture_ptr->data[0]; - for(i = 0; i < s->height; i++){ - for(x = 0; x < w; x++){ + for (i = 0; i < s->height; i++) { + for (x = 0; x < w; x++) src[x] <<= shift; - } - src += s->picture_ptr->linesize[0]/2; + src += s->picture_ptr->linesize[0] / 2; } } } @@ -365,9 +382,9 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor return 0; } - AVCodec ff_jpegls_decoder = { .name = "jpegls", + .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_JPEGLS, .priv_data_size = sizeof(MJpegDecodeContext), @@ -375,5 +392,4 @@ AVCodec ff_jpegls_decoder = { .close = ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1, - .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), }; diff --git a/libavcodec/jpeglsdec.h b/libavcodec/jpeglsdec.h index 473282207d..d60a87bdd5 100644 --- a/libavcodec/jpeglsdec.h +++ b/libavcodec/jpeglsdec.h @@ -36,6 +36,7 @@ */ int ff_jpegls_decode_lse(MJpegDecodeContext *s); -int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv); +int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, + int point_transform, int ilv); #endif /* AVCODEC_JPEGLSDEC_H */ diff --git a/libavcodec/jpeglsenc.c b/libavcodec/jpeglsenc.c index 4d219cbade..9f1fc1f618 100644 --- a/libavcodec/jpeglsenc.c +++ b/libavcodec/jpeglsenc.c @@ -33,24 +33,26 @@ #include "mjpeg.h" #include "jpegls.h" - /** * Encode error from regular symbol */ -static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, int err){ +static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, + int err) +{ int k; int val; int map; - for(k = 0; (state->N[Q] << k) < state->A[Q]; k++); + for (k = 0; (state->N[Q] << k) < state->A[Q]; k++) + ; map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]); - if(err < 0) + if (err < 0) err += state->range; if (err >= (state->range + 1 >> 1)) { err -= state->range; - val = 2 * FFABS(err) - 1 - map; + val = 2 * FFABS(err) - 1 - map; } else val = 2 * err + map; @@ -62,27 +64,30 @@ static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, /** * Encode error from run termination */ -static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RItype, int err, int limit_add){ +static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, + int RItype, int err, int limit_add) +{ int k; int val, map; int Q = 365 + RItype; int temp; temp = state->A[Q]; - if(RItype) + if (RItype) temp += state->N[Q] >> 1; - for(k = 0; (state->N[Q] << k) < temp; k++); + for (k = 0; (state->N[Q] << k) < temp; k++) + ; map = 0; - if(!k && err && (2 * state->B[Q] < state->N[Q])) + if (!k && err && (2 * state->B[Q] < state->N[Q])) map = 1; - if(err < 0) - val = - (2 * err) - 1 - RItype + map; + if (err < 0) + val = -(2 * err) - 1 - RItype + map; else val = 2 * err - RItype - map; set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp); - if(err < 0) + if (err < 0) state->B[Q]++; state->A[Q] += (val + 1 - RItype) >> 1; @@ -92,19 +97,21 @@ static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RIt /** * Encode run value as specified by JPEG-LS standard */ -static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, int comp, int trail){ - while(run >= (1 << ff_log2_run[state->run_index[comp]])){ +static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, + int comp, int trail) +{ + while (run >= (1 << ff_log2_run[state->run_index[comp]])) { put_bits(pb, 1, 1); run -= 1 << ff_log2_run[state->run_index[comp]]; - if(state->run_index[comp] < 31) + if (state->run_index[comp] < 31) state->run_index[comp]++; } /* if hit EOL, encode another full run, else encode aborted run */ - if(!trail && run) { + if (!trail && run) { put_bits(pb, 1, 1); - }else if(trail){ + } else if (trail) { put_bits(pb, 1, 0); - if(ff_log2_run[state->run_index[comp]]) + if (ff_log2_run[state->run_index[comp]]) put_bits(pb, ff_log2_run[state->run_index[comp]], run); } } @@ -112,12 +119,15 @@ static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, in /** * Encode one line of image */ -static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last, void *cur, int last2, int w, int stride, int comp, int bits){ +static inline void ls_encode_line(JLSState *state, PutBitContext *pb, + void *last, void *cur, int last2, int w, + int stride, int comp, int bits) +{ int x = 0; int Ra, Rb, Rc, Rd; int D0, D1, D2; - while(x < w) { + while (x < w) { int err, pred, sign; /* compute gradients */ @@ -130,71 +140,76 @@ static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last D2 = Rc - Ra; /* run mode */ - if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) { + if ((FFABS(D0) <= state->near) && + (FFABS(D1) <= state->near) && + (FFABS(D2) <= state->near)) { int RUNval, RItype, run; - run = 0; + run = 0; RUNval = Ra; - while(x < w && (FFABS(R(cur, x) - RUNval) <= state->near)){ + while (x < w && (FFABS(R(cur, x) - RUNval) <= state->near)) { run++; W(cur, x, Ra); x += stride; } ls_encode_run(state, pb, run, comp, x < w); - if(x >= w) + if (x >= w) return; - Rb = R(last, x); + Rb = R(last, x); RItype = FFABS(Ra - Rb) <= state->near; - pred = RItype ? Ra : Rb; - err = R(cur, x) - pred; + pred = RItype ? Ra : Rb; + err = R(cur, x) - pred; - if(!RItype && Ra > Rb) + if (!RItype && Ra > Rb) err = -err; - if(state->near){ - if(err > 0) - err = (state->near + err) / state->twonear; + if (state->near) { + if (err > 0) + err = (state->near + err) / state->twonear; else err = -(state->near - err) / state->twonear; - if(RItype || (Rb >= Ra)) + if (RItype || (Rb >= Ra)) Ra = av_clip(pred + err * state->twonear, 0, state->maxval); else Ra = av_clip(pred - err * state->twonear, 0, state->maxval); W(cur, x, Ra); } - if(err < 0) + if (err < 0) err += state->range; if (err >= state->range + 1 >> 1) err -= state->range; - ls_encode_runterm(state, pb, RItype, err, ff_log2_run[state->run_index[comp]]); + ls_encode_runterm(state, pb, RItype, err, + ff_log2_run[state->run_index[comp]]); - if(state->run_index[comp] > 0) + if (state->run_index[comp] > 0) state->run_index[comp]--; } else { /* regular mode */ int context; - context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2); - pred = mid_pred(Ra, Ra + Rb - Rc, Rb); + context = ff_jpegls_quantize(state, D0) * 81 + + ff_jpegls_quantize(state, D1) * 9 + + ff_jpegls_quantize(state, D2); + pred = mid_pred(Ra, Ra + Rb - Rc, Rb); - if(context < 0){ + if (context < 0) { context = -context; - sign = 1; - pred = av_clip(pred - state->C[context], 0, state->maxval); - err = pred - R(cur, x); - }else{ + sign = 1; + pred = av_clip(pred - state->C[context], 0, state->maxval); + err = pred - R(cur, x); + } else { sign = 0; pred = av_clip(pred + state->C[context], 0, state->maxval); - err = R(cur, x) - pred; + err = R(cur, x) - pred; } - if(state->near){ - if(err > 0) - err = (state->near + err) / state->twonear; + if (state->near) { + if (err > 0) + err = (state->near + err) / state->twonear; else err = -(state->near - err) / state->twonear; - if(!sign) + if (!sign) Ra = av_clip(pred + err * state->twonear, 0, state->maxval); else Ra = av_clip(pred - err * state->twonear, 0, state->maxval); @@ -207,18 +222,22 @@ static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last } } -static void ls_store_lse(JLSState *state, PutBitContext *pb){ +static void ls_store_lse(JLSState *state, PutBitContext *pb) +{ /* Test if we have default params and don't need to store LSE */ JLSState state2 = { 0 }; - state2.bpp = state->bpp; + state2.bpp = state->bpp; state2.near = state->near; ff_jpegls_reset_coding_parameters(&state2, 1); - if(state->T1 == state2.T1 && state->T2 == state2.T2 && state->T3 == state2.T3 && state->reset == state2.reset) + if (state->T1 == state2.T1 && + state->T2 == state2.T2 && + state->T3 == state2.T3 && + state->reset == state2.reset) return; /* store LSE type 1 */ put_marker(pb, LSE); put_bits(pb, 16, 13); - put_bits(pb, 8, 1); + put_bits(pb, 8, 1); put_bits(pb, 16, state->maxval); put_bits(pb, 16, state->T1); put_bits(pb, 16, state->T2); @@ -229,9 +248,9 @@ static void ls_store_lse(JLSState *state, PutBitContext *pb){ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet) { - JpeglsContext * const s = avctx->priv_data; - AVFrame * const p = &s->picture; - const int near = avctx->prediction_method; + JpeglsContext *const s = avctx->priv_data; + AVFrame *const p = &s->picture; + const int near = avctx->prediction_method; PutBitContext pb, pb2; GetBitContext gb; uint8_t *buf2, *zero, *cur, *last; @@ -239,17 +258,18 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, int i, size, ret; int comps; - *p = *pict; - p->pict_type= AV_PICTURE_TYPE_I; - p->key_frame= 1; + *p = *pict; + p->pict_type = AV_PICTURE_TYPE_I; + p->key_frame = 1; - if(avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16) + if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || + avctx->pix_fmt == AV_PIX_FMT_GRAY16) comps = 1; else comps = 3; - if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*comps*4 + - FF_MIN_BUFFER_SIZE)) < 0) { + if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height * comps * 4 + + FF_MIN_BUFFER_SIZE)) < 0) { av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n"); return ret; } @@ -263,31 +283,31 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, put_marker(&pb, SOI); put_marker(&pb, SOF48); put_bits(&pb, 16, 8 + comps * 3); // header size depends on components - put_bits(&pb, 8, (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8); // bpp + put_bits(&pb, 8, (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8); // bpp put_bits(&pb, 16, avctx->height); put_bits(&pb, 16, avctx->width); - put_bits(&pb, 8, comps); // components - for(i = 1; i <= comps; i++) { - put_bits(&pb, 8, i); // component ID - put_bits(&pb, 8, 0x11); // subsampling: none - put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext + put_bits(&pb, 8, comps); // components + for (i = 1; i <= comps; i++) { + put_bits(&pb, 8, i); // component ID + put_bits(&pb, 8, 0x11); // subsampling: none + put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext } put_marker(&pb, SOS); put_bits(&pb, 16, 6 + comps * 2); - put_bits(&pb, 8, comps); - for(i = 1; i <= comps; i++) { - put_bits(&pb, 8, i); // component ID - put_bits(&pb, 8, 0); // mapping index: none + put_bits(&pb, 8, comps); + for (i = 1; i <= comps; i++) { + put_bits(&pb, 8, i); // component ID + put_bits(&pb, 8, 0); // mapping index: none } - put_bits(&pb, 8, near); - put_bits(&pb, 8, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line - put_bits(&pb, 8, 0); // point transform: none + put_bits(&pb, 8, near); + put_bits(&pb, 8, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line + put_bits(&pb, 8, 0); // point transform: none state = av_mallocz(sizeof(JLSState)); /* initialize JPEG-LS state from JPEG parameters */ state->near = near; - state->bpp = (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8; + state->bpp = (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8; ff_jpegls_reset_coding_parameters(state, 0); ff_jpegls_init_state(state); @@ -295,46 +315,48 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, zero = av_mallocz(p->linesize[0]); last = zero; - cur = p->data[0]; - if(avctx->pix_fmt == AV_PIX_FMT_GRAY8){ + cur = p->data[0]; + if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) { int t = 0; - for(i = 0; i < avctx->height; i++) { - ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 8); - t = last[0]; + for (i = 0; i < avctx->height; i++) { + ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 8); + t = last[0]; last = cur; cur += p->linesize[0]; } - }else if(avctx->pix_fmt == AV_PIX_FMT_GRAY16){ + } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY16) { int t = 0; - for(i = 0; i < avctx->height; i++) { + for (i = 0; i < avctx->height; i++) { ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 16); - t = *((uint16_t*)last); + t = *((uint16_t *)last); last = cur; cur += p->linesize[0]; } - }else if(avctx->pix_fmt == AV_PIX_FMT_RGB24){ + } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) { int j, width; - int Rc[3] = {0, 0, 0}; + int Rc[3] = { 0, 0, 0 }; width = avctx->width * 3; - for(i = 0; i < avctx->height; i++) { - for(j = 0; j < 3; j++) { - ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8); + for (i = 0; i < avctx->height; i++) { + for (j = 0; j < 3; j++) { + ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], + width, 3, j, 8); Rc[j] = last[j]; } last = cur; cur += s->picture.linesize[0]; } - }else if(avctx->pix_fmt == AV_PIX_FMT_BGR24){ + } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) { int j, width; - int Rc[3] = {0, 0, 0}; + int Rc[3] = { 0, 0, 0 }; width = avctx->width * 3; - for(i = 0; i < avctx->height; i++) { - for(j = 2; j >= 0; j--) { - ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8); + for (i = 0; i < avctx->height; i++) { + for (j = 2; j >= 0; j--) { + ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], + width, 3, j, 8); Rc[j] = last[j]; } last = cur; @@ -345,20 +367,20 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, av_free(zero); av_free(state); - // the specification says that after doing 0xff escaping unused bits in the - // last byte must be set to 0, so just append 7 "optional" zero-bits to - // avoid special-casing. + /* the specification says that after doing 0xff escaping unused bits in + * the last byte must be set to 0, so just append 7 "optional" zero-bits + * to avoid special-casing. */ put_bits(&pb2, 7, 0); size = put_bits_count(&pb2); flush_put_bits(&pb2); /* do escape coding */ init_get_bits(&gb, buf2, size); size -= 7; - while(get_bits_count(&gb) < size){ + while (get_bits_count(&gb) < size) { int v; v = get_bits(&gb, 8); put_bits(&pb, 8, v); - if(v == 0xFF){ + if (v == 0xFF) { v = get_bits(&gb, 7); put_bits(&pb, 8, v); } @@ -378,29 +400,35 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, return 0; } -static av_cold int encode_init_ls(AVCodecContext *ctx) { - JpeglsContext *c = (JpeglsContext*)ctx->priv_data; +static av_cold int encode_init_ls(AVCodecContext *ctx) +{ + JpeglsContext *c = (JpeglsContext *)ctx->priv_data; - c->avctx = ctx; + c->avctx = ctx; ctx->coded_frame = &c->picture; - if(ctx->pix_fmt != AV_PIX_FMT_GRAY8 && ctx->pix_fmt != AV_PIX_FMT_GRAY16 && ctx->pix_fmt != AV_PIX_FMT_RGB24 && ctx->pix_fmt != AV_PIX_FMT_BGR24){ - av_log(ctx, AV_LOG_ERROR, "Only grayscale and RGB24/BGR24 images are supported\n"); + if (ctx->pix_fmt != AV_PIX_FMT_GRAY8 && + ctx->pix_fmt != AV_PIX_FMT_GRAY16 && + ctx->pix_fmt != AV_PIX_FMT_RGB24 && + ctx->pix_fmt != AV_PIX_FMT_BGR24) { + av_log(ctx, AV_LOG_ERROR, + "Only grayscale and RGB24/BGR24 images are supported\n"); return -1; } return 0; } -AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them +AVCodec ff_jpegls_encoder = { .name = "jpegls", + .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_JPEGLS, .priv_data_size = sizeof(JpeglsContext), .init = encode_init_ls, .encode2 = encode_picture_ls, - .pix_fmts = (const enum AVPixelFormat[]){ - AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, + .pix_fmts = (const enum AVPixelFormat[]) { + AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24, + AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_NONE }, - .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), };