summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLuca Barbato <lu_zero@gentoo.org>2013-05-15 19:03:53 +0200
committerDiego Biurrun <diego@biurrun.de>2013-05-16 00:00:41 +0200
commitff4fc5ef12a37716c5c5d8928a2db92428e916ec (patch)
treedf53348294673f375561116bae674ea242f49da4
parent9cacdabd1c8cd257a942d8289349c37d992989b7 (diff)
downloadffmpeg-streaming-ff4fc5ef12a37716c5c5d8928a2db92428e916ec.zip
ffmpeg-streaming-ff4fc5ef12a37716c5c5d8928a2db92428e916ec.tar.gz
jpegls: K&R formatting cosmetics
Signed-off-by: Diego Biurrun <diego@biurrun.de>
-rw-r--r--libavcodec/jpegls.c73
-rw-r--r--libavcodec/jpegls.h78
-rw-r--r--libavcodec/jpeglsdec.c208
-rw-r--r--libavcodec/jpeglsdec.h3
-rw-r--r--libavcodec/jpeglsenc.c240
5 files changed, 336 insertions, 266 deletions
diff --git a/libavcodec/jpegls.c b/libavcodec/jpegls.c
index bbe1a04..52a4500 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 18c71a8..4bf9562 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 5f01631..6d884a4 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 4732822..d60a87b 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 4d219cb..9f1fc1f 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"),
};
OpenPOWER on IntegriCloud