virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

jpegls: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Luca Barbato 2013-05-15 19:03:53 +02:00 committed by Diego Biurrun
parent 9cacdabd1c
commit ff4fc5ef12
5 changed files with 336 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
libavcodec/jpegls.c
View File

@ -27,63 +27,76 @@
#include "jpegls.h" #include "jpegls.h"
void ff_jpegls_init_state(JLSState *state){ void ff_jpegls_init_state(JLSState *state)
{
int i; int i;
state->twonear = state->near * 2 + 1; state->twonear = state->near * 2 + 1;
state->range = (state->maxval + state->twonear - 1) / state->twonear + 1; state->range = (state->maxval + state->twonear - 1) / state->twonear + 1;
// QBPP = ceil(log2(RANGE)) // 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) if (state->bpp < 8)
state->limit = 16 + 2 * state->bpp - state->qbpp; state->limit = 2 * state->bpp - state->qbpp + 16;
else else
state->limit = 4 * state->bpp - state->qbpp; 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->A[i] = FFMAX(state->range + 32 >> 6, 2);
state->N[i] = 1; state->N[i] = 1;
} }
} }
/** /**
* Custom value clipping function used in T1, T2, T3 calculation * Custom value clipping function used in T1, T2, T3 calculation
*/ */
static inline int iso_clip(int v, int vmin, int vmax){ static inline int iso_clip(int v, int vmin, int vmax)
if(v > vmax || v < vmin) return vmin; {
else return v; if (v > vmax || v < vmin)
return vmin;
else
return v;
} }
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all){ void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all)
const int basic_t1= 3; {
const int basic_t2= 7; const int basic_t1 = 3;
const int basic_t3= 21; const int basic_t2 = 7;
const int basic_t3 = 21;
int factor; 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; factor = FFMIN(s->maxval, 4095) + 128 >> 8;
if(s->T1==0 || reset_all) if (s->T1 == 0 || reset_all)
s->T1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval); s->T1 = iso_clip(factor * (basic_t1 - 2) + 2 + 3 * s->near,
if(s->T2==0 || reset_all) s->near + 1, s->maxval);
s->T2= iso_clip(factor*(basic_t2-3) + 3 + 5*s->near, s->T1, s->maxval); if (s->T2 == 0 || reset_all)
if(s->T3==0 || reset_all) s->T2 = iso_clip(factor * (basic_t2 - 3) + 3 + 5 * s->near,
s->T3= iso_clip(factor*(basic_t3-4) + 4 + 7*s->near, s->T2, s->maxval); s->T1, s->maxval);
}else{ if (s->T3 == 0 || reset_all)
factor= 256 / (s->maxval + 1); 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) if (s->T1 == 0 || reset_all)
s->T1= iso_clip(FFMAX(2, basic_t1/factor + 3*s->near), s->near+1, s->maxval); s->T1 = iso_clip(FFMAX(2, basic_t1 / factor + 3 * s->near),
if(s->T2==0 || reset_all) s->near + 1, s->maxval);
s->T2= iso_clip(FFMAX(3, basic_t2/factor + 5*s->near), s->T1, s->maxval); if (s->T2 == 0 || reset_all)
if(s->T3==0 || reset_all) s->T2 = iso_clip(FFMAX(3, basic_t2 / factor + 5 * s->near),
s->T3= iso_clip(FFMAX(4, basic_t3/factor + 7*s->near), s->T2, s->maxval); 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); av_dlog(NULL, "[JPEG-LS RESET] T=%i,%i,%i\n", s->T1, s->T2, s->T3);
} }

78
libavcodec/jpegls.h
View File

@ -28,21 +28,21 @@
#ifndef AVCODEC_JPEGLS_H #ifndef AVCODEC_JPEGLS_H
#define AVCODEC_JPEGLS_H #define AVCODEC_JPEGLS_H
#include "avcodec.h"
#include "libavutil/common.h" #include "libavutil/common.h"
#include "avcodec.h"
typedef struct JpeglsContext{ typedef struct JpeglsContext {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame picture; AVFrame picture;
}JpeglsContext; } JpeglsContext;
typedef struct JLSState{ typedef struct JLSState {
int T1, T2, T3; int T1, T2, T3;
int A[367], B[367], C[365], N[367]; int A[367], B[367], C[365], N[367];
int limit, reset, bpp, qbpp, maxval, range; int limit, reset, bpp, qbpp, maxval, range;
int near, twonear; int near, twonear;
int run_index[3]; int run_index[3];
}JLSState; } JLSState;
extern const uint8_t ff_log2_run[32]; 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 * Calculate quantized gradient value, used for context determination
*/ */
static inline int ff_jpegls_quantize(JLSState *s, int v){ //FIXME optimize static inline int ff_jpegls_quantize(JLSState *s, int v)
if(v==0) return 0; {
if(v < 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;
return 0; return 0;
}else{ if (v < 0) {
if(v <= s->near) return 0; if (v <= -s->T3)
if(v < s->T1) return 1; return -4;
if(v < s->T2) return 2; if (v <= -s->T2)
if(v < s->T3) return 3; 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; 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); void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all);
static inline void ff_jpegls_downscale_state(JLSState *state, int Q)
static inline void ff_jpegls_downscale_state(JLSState *state, int Q){ {
if(state->N[Q] == state->reset){ if (state->N[Q] == state->reset) {
state->A[Q] >>=1; state->A[Q] >>= 1;
state->B[Q] >>=1; state->B[Q] >>= 1;
state->N[Q] >>=1; state->N[Q] >>= 1;
} }
state->N[Q]++; 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); state->A[Q] += FFABS(err);
err *= state->twonear; err *= state->twonear;
state->B[Q] += err; state->B[Q] += err;
ff_jpegls_downscale_state(state, Q); ff_jpegls_downscale_state(state, Q);
if(state->B[Q] <= -state->N[Q]) { if (state->B[Q] <= -state->N[Q]) {
state->B[Q]= FFMAX(state->B[Q] + state->N[Q], 1-state->N[Q]); state->B[Q] = FFMAX(state->B[Q] + state->N[Q], 1 - state->N[Q]);
if(state->C[Q] > -128) if (state->C[Q] > -128)
state->C[Q]--; state->C[Q]--;
}else if(state->B[Q] > 0){ } else if (state->B[Q] > 0) {
state->B[Q]= FFMIN(state->B[Q] - state->N[Q], 0); state->B[Q] = FFMIN(state->B[Q] - state->N[Q], 0);
if(state->C[Q] < 127) if (state->C[Q] < 127)
state->C[Q]++; state->C[Q]++;
} }
return err; return err;
} }
#define R(a, i ) (bits == 8 ? ((uint8_t*)(a))[i] : ((uint16_t*)(a))[i] ) #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 W(a, i, v) (bits == 8 ? (((uint8_t *)(a))[i] = v) : (((uint16_t *)(a))[i] = v))
#endif /* AVCODEC_JPEGLS_H */ #endif /* AVCODEC_JPEGLS_H */

208
libavcodec/jpeglsdec.c
View File

@ -34,18 +34,16 @@
#include "jpegls.h" #include "jpegls.h"
#include "jpeglsdec.h" #include "jpeglsdec.h"
/* /*
* Uncomment this to significantly speed up decoding of broken JPEG-LS * Uncomment this to significantly speed up decoding of broken JPEG-LS
* (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit. * (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 * There is no Golomb code with length >= 32 bits possible, so check and
* avoid situation of 32 zeros, Libav Golomb decoder is painfully slow * avoid situation of 32 zeros, Libav Golomb decoder is painfully slow
* on this errors. * on this errors.
*/ */
//#define JLS_BROKEN //#define JLS_BROKEN
/** /**
* Decode LSE block with initialization parameters * 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 */ skip_bits(&s->gb, 16); /* length: FIXME: verify field validity */
id = get_bits(&s->gb, 8); id = get_bits(&s->gb, 8);
switch(id){ switch (id) {
case 1: case 1:
s->maxval= get_bits(&s->gb, 16); s->maxval = get_bits(&s->gb, 16);
s->t1= get_bits(&s->gb, 16); s->t1 = get_bits(&s->gb, 16);
s->t2= get_bits(&s->gb, 16); s->t2 = get_bits(&s->gb, 16);
s->t3= get_bits(&s->gb, 16); s->t3 = get_bits(&s->gb, 16);
s->reset= get_bits(&s->gb, 16); s->reset = get_bits(&s->gb, 16);
// ff_jpegls_reset_coding_parameters(s, 0); // ff_jpegls_reset_coding_parameters(s, 0);
//FIXME quant table? //FIXME quant table?
@ -86,27 +84,30 @@ int ff_jpegls_decode_lse(MJpegDecodeContext *s)
/** /**
* Get context-dependent Golomb code, decode it and update context * 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; 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 #ifdef JLS_BROKEN
if(!show_bits_long(gb, 32))return -1; if (!show_bits_long(gb, 32))
return -1;
#endif #endif
ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp); ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp);
/* decode mapped error */ /* decode mapped error */
if(ret & 1) if (ret & 1)
ret = -(ret + 1 >> 1); ret = -(ret + 1 >> 1);
else else
ret >>= 1; ret >>= 1;
/* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */ /* 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 = -(ret + 1);
ret= ff_jpegls_update_state_regular(state, Q, ret); ret = ff_jpegls_update_state_regular(state, Q, ret);
return 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 * 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 k, ret, temp, map;
int Q = 365 + RItype; int Q = 365 + RItype;
temp= state->A[Q]; temp = state->A[Q];
if(RItype) if (RItype)
temp += state->N[Q] >> 1; 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 #ifdef JLS_BROKEN
if(!show_bits_long(gb, 32))return -1; if (!show_bits_long(gb, 32))
return -1;
#endif #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 */ /* decode mapped error */
map = 0; 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; map = 1;
ret += RItype + map; ret += RItype + map;
if(ret & 1){ if (ret & 1) {
ret = map - (ret + 1 >> 1); ret = map - (ret + 1 >> 1);
state->B[Q]++; state->B[Q]++;
} else { } else {
@ -144,7 +150,7 @@ static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RI
/* update state */ /* update state */
state->A[Q] += FFABS(ret) - RItype; state->A[Q] += FFABS(ret) - RItype;
ret *= state->twonear; ret *= state->twonear;
ff_jpegls_downscale_state(state, Q); ff_jpegls_downscale_state(state, Q);
return ret; return ret;
@ -153,12 +159,15 @@ static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RI
/** /**
* Decode one line of image * 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 i, x = 0;
int Ra, Rb, Rc, Rd; int Ra, Rb, Rc, Rd;
int D0, D1, D2; int D0, D1, D2;
while(x < w) { while (x < w) {
int err, pred; int err, pred;
/* compute gradients */ /* compute gradients */
@ -170,49 +179,51 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
D1 = Rb - Rc; D1 = Rb - Rc;
D2 = Rc - Ra; D2 = Rc - Ra;
/* run mode */ /* 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 r;
int RItype; int RItype;
/* decode full runs while available */ /* decode full runs while available */
while(get_bits1(&s->gb)) { while (get_bits1(&s->gb)) {
int r; int r;
r = 1 << ff_log2_run[state->run_index[comp]]; r = 1 << ff_log2_run[state->run_index[comp]];
if(x + r * stride > w) { if (x + r * stride > w)
r = (w - x) / stride; r = (w - x) / stride;
} for (i = 0; i < r; i++) {
for(i = 0; i < r; i++) {
W(dst, x, Ra); W(dst, x, Ra);
x += stride; x += stride;
} }
/* if EOL reached, we stop decoding */ /* if EOL reached, we stop decoding */
if (r != 1 << ff_log2_run[state->run_index[comp]]) if (r != 1 << ff_log2_run[state->run_index[comp]])
return; return;
if(state->run_index[comp] < 31) if (state->run_index[comp] < 31)
state->run_index[comp]++; state->run_index[comp]++;
if(x + stride > w) if (x + stride > w)
return; return;
} }
/* decode aborted run */ /* decode aborted run */
r = ff_log2_run[state->run_index[comp]]; r = ff_log2_run[state->run_index[comp]];
if(r) if (r)
r = get_bits_long(&s->gb, r); r = get_bits_long(&s->gb, r);
for(i = 0; i < r; i++) { for (i = 0; i < r; i++) {
W(dst, x, Ra); W(dst, x, Ra);
x += stride; x += stride;
} }
/* decode run termination value */ /* decode run termination value */
Rb = R(last, x); Rb = R(last, x);
RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0; RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0;
err = ls_get_code_runterm(&s->gb, state, RItype, ff_log2_run[state->run_index[comp]]); err = ls_get_code_runterm(&s->gb, state, RItype,
if(state->run_index[comp]) ff_log2_run[state->run_index[comp]]);
if (state->run_index[comp])
state->run_index[comp]--; state->run_index[comp]--;
if(state->near && RItype){ if (state->near && RItype) {
pred = Ra + err; pred = Ra + err;
} else { } else {
if(Rb < Ra) if (Rb < Ra)
pred = Rb - err; pred = Rb - err;
else else
pred = Rb + err; pred = Rb + err;
@ -220,31 +231,33 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
} else { /* regular mode */ } else { /* regular mode */
int context, sign; int context, sign;
context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2); context = ff_jpegls_quantize(state, D0) * 81 +
pred = mid_pred(Ra, Ra + Rb - Rc, Rb); 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; context = -context;
sign = 1; sign = 1;
}else{ } else {
sign = 0; sign = 0;
} }
if(sign){ if (sign) {
pred = av_clip(pred - state->C[context], 0, state->maxval); 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 { } else {
pred = av_clip(pred + state->C[context], 0, state->maxval); 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 */ /* we have to do something more for near-lossless coding */
pred += err; pred += err;
} }
if(state->near){ if (state->near) {
if(pred < -state->near) if (pred < -state->near)
pred += state->range * state->twonear; 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 -= state->range * state->twonear;
pred = av_clip(pred, 0, state->maxval); 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; int i, t = 0;
uint8_t *zero, *last, *cur; uint8_t *zero, *last, *cur;
JLSState *state; 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]); zero = av_mallocz(s->picture_ptr->linesize[0]);
last = zero; last = zero;
cur = s->picture_ptr->data[0]; cur = s->picture_ptr->data[0];
state = av_mallocz(sizeof(JLSState)); state = av_mallocz(sizeof(JLSState));
/* initialize JPEG-LS state from JPEG parameters */ /* initialize JPEG-LS state from JPEG parameters */
state->near = near; state->near = near;
state->bpp = (s->bits < 2) ? 2 : s->bits; state->bpp = (s->bits < 2) ? 2 : s->bits;
state->maxval = s->maxval; state->maxval = s->maxval;
state->T1 = s->t1; state->T1 = s->t1;
state->T2 = s->t2; state->T2 = s->t2;
state->T3 = s->t3; state->T3 = s->t3;
state->reset = s->reset; state->reset = s->reset;
ff_jpegls_reset_coding_parameters(state, 0); ff_jpegls_reset_coding_parameters(state, 0);
ff_jpegls_init_state(state); ff_jpegls_init_state(state);
if(s->bits <= 8) if (s->bits <= 8)
shift = point_transform + (8 - s->bits); shift = point_transform + (8 - s->bits);
else else
shift = point_transform + (16 - s->bits); 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, s->width, s->height, state->near, state->maxval,
state->T1, state->T2, state->T3, state->T1, state->T2, state->T3,
state->reset, state->limit, state->qbpp, state->range); state->reset, state->limit, state->qbpp, state->range);
av_dlog(s->avctx, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n", av_dlog(s->avctx, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
ilv, point_transform, s->bits, s->cur_scan); ilv, point_transform, s->bits, s->cur_scan);
if(ilv == 0) { /* separate planes */ if (ilv == 0) { /* separate planes */
off = s->cur_scan - 1; off = s->cur_scan - 1;
stride = (s->nb_components > 1) ? 3 : 1; stride = (s->nb_components > 1) ? 3 : 1;
width = s->width * stride; width = s->width * stride;
cur += off; cur += off;
for(i = 0; i < s->height; i++) { for (i = 0; i < s->height; i++) {
if(s->bits <= 8){ if (s->bits <= 8) {
ls_decode_line(state, s, last, cur, t, width, stride, off, 8); ls_decode_line(state, s, last, cur, t, width, stride, off, 8);
t = last[0]; t = last[0];
}else{ } else {
ls_decode_line(state, s, last, cur, t, width, stride, off, 16); ls_decode_line(state, s, last, cur, t, width, stride, off, 16);
t = *((uint16_t*)last); t = *((uint16_t *)last);
} }
last = cur; last = cur;
cur += s->picture_ptr->linesize[0]; 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 */ skip_bits(&s->gb, 16); /* skip RSTn */
} }
} }
} else if(ilv == 1) { /* line interleaving */ } else if (ilv == 1) { /* line interleaving */
int j; int j;
int Rc[3] = {0, 0, 0}; int Rc[3] = { 0, 0, 0 };
memset(cur, 0, s->picture_ptr->linesize[0]); memset(cur, 0, s->picture_ptr->linesize[0]);
width = s->width * 3; width = s->width * 3;
for(i = 0; i < s->height; i++) { for (i = 0; i < s->height; i++) {
for(j = 0; j < 3; j++) { for (j = 0; j < 3; j++) {
ls_decode_line(state, s, last + j, cur + j, Rc[j], width, 3, j, 8); ls_decode_line(state, s, last + j, cur + j,
Rc[j], width, 3, j, 8);
Rc[j] = last[j]; Rc[j] = last[j];
if (s->restart_interval && !--s->restart_count) { 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; last = cur;
cur += s->picture_ptr->linesize[0]; cur += s->picture_ptr->linesize[0];
} }
} else if(ilv == 2) { /* sample interleaving */ } else if (ilv == 2) { /* sample interleaving */
av_log(s->avctx, AV_LOG_ERROR, "Sample interleaved images are not supported.\n"); av_log(s->avctx, AV_LOG_ERROR,
"Sample interleaved images are not supported.\n");
av_free(state); av_free(state);
av_free(zero); av_free(zero);
return -1; 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; int x, w;
w = s->width * s->nb_components; w = s->width * s->nb_components;
if(s->bits <= 8){ if (s->bits <= 8) {
uint8_t *src = s->picture_ptr->data[0]; uint8_t *src = s->picture_ptr->data[0];
for(i = 0; i < s->height; i++){ for (i = 0; i < s->height; i++) {
for(x = off; x < w; x+= stride){ for (x = off; x < w; x += stride)
src[x] <<= shift; src[x] <<= shift;
}
src += s->picture_ptr->linesize[0]; src += s->picture_ptr->linesize[0];
} }
}else{ } else {
uint16_t *src = (uint16_t*) s->picture_ptr->data[0]; uint16_t *src = (uint16_t *)s->picture_ptr->data[0];
for(i = 0; i < s->height; i++){ for (i = 0; i < s->height; i++) {
for(x = 0; x < w; x++){ for (x = 0; x < w; x++)
src[x] <<= shift; 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; return 0;
} }
AVCodec ff_jpegls_decoder = { AVCodec ff_jpegls_decoder = {
.name = "jpegls", .name = "jpegls",
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_JPEGLS, .id = AV_CODEC_ID_JPEGLS,
.priv_data_size = sizeof(MJpegDecodeContext), .priv_data_size = sizeof(MJpegDecodeContext),
@ -375,5 +392,4 @@ AVCodec ff_jpegls_decoder = {
.close = ff_mjpeg_decode_end, .close = ff_mjpeg_decode_end,
.decode = ff_mjpeg_decode_frame, .decode = ff_mjpeg_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
}; };

3
libavcodec/jpeglsdec.h
View File

@ -36,6 +36,7 @@
*/ */
int ff_jpegls_decode_lse(MJpegDecodeContext *s); 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 */ #endif /* AVCODEC_JPEGLSDEC_H */

240
libavcodec/jpeglsenc.c
View File

@ -33,24 +33,26 @@
#include "mjpeg.h" #include "mjpeg.h"
#include "jpegls.h" #include "jpegls.h"
/** /**
* Encode error from regular symbol * 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 k;
int val; int val;
int map; 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]); map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]);
if(err < 0) if (err < 0)
err += state->range; err += state->range;
if (err >= (state->range + 1 >> 1)) { if (err >= (state->range + 1 >> 1)) {
err -= state->range; err -= state->range;
val = 2 * FFABS(err) - 1 - map; val = 2 * FFABS(err) - 1 - map;
} else } else
val = 2 * err + map; 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 * 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 k;
int val, map; int val, map;
int Q = 365 + RItype; int Q = 365 + RItype;
int temp; int temp;
temp = state->A[Q]; temp = state->A[Q];
if(RItype) if (RItype)
temp += state->N[Q] >> 1; 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; map = 0;
if(!k && err && (2 * state->B[Q] < state->N[Q])) if (!k && err && (2 * state->B[Q] < state->N[Q]))
map = 1; map = 1;
if(err < 0) if (err < 0)
val = - (2 * err) - 1 - RItype + map; val = -(2 * err) - 1 - RItype + map;
else else
val = 2 * err - RItype - map; val = 2 * err - RItype - map;
set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp); set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
if(err < 0) if (err < 0)
state->B[Q]++; state->B[Q]++;
state->A[Q] += (val + 1 - RItype) >> 1; 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 * 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){ static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run,
while(run >= (1 << ff_log2_run[state->run_index[comp]])){ int comp, int trail)
{
while (run >= (1 << ff_log2_run[state->run_index[comp]])) {
put_bits(pb, 1, 1); put_bits(pb, 1, 1);
run -= 1 << ff_log2_run[state->run_index[comp]]; 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]++; state->run_index[comp]++;
} }
/* if hit EOL, encode another full run, else encode aborted run */ /* if hit EOL, encode another full run, else encode aborted run */
if(!trail && run) { if (!trail && run) {
put_bits(pb, 1, 1); put_bits(pb, 1, 1);
}else if(trail){ } else if (trail) {
put_bits(pb, 1, 0); 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); 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 * 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 x = 0;
int Ra, Rb, Rc, Rd; int Ra, Rb, Rc, Rd;
int D0, D1, D2; int D0, D1, D2;
while(x < w) { while (x < w) {
int err, pred, sign; int err, pred, sign;
/* compute gradients */ /* compute gradients */
@ -130,71 +140,76 @@ static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last
D2 = Rc - Ra; D2 = Rc - Ra;
/* run mode */ /* 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; int RUNval, RItype, run;
run = 0; run = 0;
RUNval = Ra; RUNval = Ra;
while(x < w && (FFABS(R(cur, x) - RUNval) <= state->near)){ while (x < w && (FFABS(R(cur, x) - RUNval) <= state->near)) {
run++; run++;
W(cur, x, Ra); W(cur, x, Ra);
x += stride; x += stride;
} }
ls_encode_run(state, pb, run, comp, x < w); ls_encode_run(state, pb, run, comp, x < w);
if(x >= w) if (x >= w)
return; return;
Rb = R(last, x); Rb = R(last, x);
RItype = FFABS(Ra - Rb) <= state->near; RItype = FFABS(Ra - Rb) <= state->near;
pred = RItype ? Ra : Rb; pred = RItype ? Ra : Rb;
err = R(cur, x) - pred; err = R(cur, x) - pred;
if(!RItype && Ra > Rb) if (!RItype && Ra > Rb)
err = -err; err = -err;
if(state->near){ if (state->near) {
if(err > 0) if (err > 0)
err = (state->near + err) / state->twonear; err = (state->near + err) / state->twonear;
else else
err = -(state->near - err) / state->twonear; err = -(state->near - err) / state->twonear;
if(RItype || (Rb >= Ra)) if (RItype || (Rb >= Ra))
Ra = av_clip(pred + err * state->twonear, 0, state->maxval); Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
else else
Ra = av_clip(pred - err * state->twonear, 0, state->maxval); Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
W(cur, x, Ra); W(cur, x, Ra);
} }
if(err < 0) if (err < 0)
err += state->range; err += state->range;
if (err >= state->range + 1 >> 1) if (err >= state->range + 1 >> 1)
err -= state->range; 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]--; state->run_index[comp]--;
} else { /* regular mode */ } else { /* regular mode */
int context; int context;
context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2); context = ff_jpegls_quantize(state, D0) * 81 +
pred = mid_pred(Ra, Ra + Rb - Rc, Rb); 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; context = -context;
sign = 1; sign = 1;
pred = av_clip(pred - state->C[context], 0, state->maxval); pred = av_clip(pred - state->C[context], 0, state->maxval);
err = pred - R(cur, x); err = pred - R(cur, x);
}else{ } else {
sign = 0; sign = 0;
pred = av_clip(pred + state->C[context], 0, state->maxval); pred = av_clip(pred + state->C[context], 0, state->maxval);
err = R(cur, x) - pred; err = R(cur, x) - pred;
} }
if(state->near){ if (state->near) {
if(err > 0) if (err > 0)
err = (state->near + err) / state->twonear; err = (state->near + err) / state->twonear;
else else
err = -(state->near - err) / state->twonear; err = -(state->near - err) / state->twonear;
if(!sign) if (!sign)
Ra = av_clip(pred + err * state->twonear, 0, state->maxval); Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
else else
Ra = av_clip(pred - err * state->twonear, 0, state->maxval); 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 */ /* Test if we have default params and don't need to store LSE */
JLSState state2 = { 0 }; JLSState state2 = { 0 };
state2.bpp = state->bpp; state2.bpp = state->bpp;
state2.near = state->near; state2.near = state->near;
ff_jpegls_reset_coding_parameters(&state2, 1); 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; return;
/* store LSE type 1 */ /* store LSE type 1 */
put_marker(pb, LSE); put_marker(pb, LSE);
put_bits(pb, 16, 13); 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->maxval);
put_bits(pb, 16, state->T1); put_bits(pb, 16, state->T1);
put_bits(pb, 16, state->T2); 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, static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet) const AVFrame *pict, int *got_packet)
{ {
JpeglsContext * const s = avctx->priv_data; JpeglsContext *const s = avctx->priv_data;
AVFrame * const p = &s->picture; AVFrame *const p = &s->picture;
const int near = avctx->prediction_method; const int near = avctx->prediction_method;
PutBitContext pb, pb2; PutBitContext pb, pb2;
GetBitContext gb; GetBitContext gb;
uint8_t *buf2, *zero, *cur, *last; uint8_t *buf2, *zero, *cur, *last;
@ -239,17 +258,18 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
int i, size, ret; int i, size, ret;
int comps; int comps;
*p = *pict; *p = *pict;
p->pict_type= AV_PICTURE_TYPE_I; p->pict_type = AV_PICTURE_TYPE_I;
p->key_frame= 1; 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; comps = 1;
else else
comps = 3; comps = 3;
if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*comps*4 + if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height * comps * 4 +
FF_MIN_BUFFER_SIZE)) < 0) { FF_MIN_BUFFER_SIZE)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n"); av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
return ret; return ret;
} }
@ -263,31 +283,31 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
put_marker(&pb, SOI); put_marker(&pb, SOI);
put_marker(&pb, SOF48); put_marker(&pb, SOF48);
put_bits(&pb, 16, 8 + comps * 3); // header size depends on components 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->height);
put_bits(&pb, 16, avctx->width); put_bits(&pb, 16, avctx->width);
put_bits(&pb, 8, comps); // components put_bits(&pb, 8, comps); // components
for(i = 1; i <= comps; i++) { for (i = 1; i <= comps; i++) {
put_bits(&pb, 8, i); // component ID put_bits(&pb, 8, i); // component ID
put_bits(&pb, 8, 0x11); // subsampling: none put_bits(&pb, 8, 0x11); // subsampling: none
put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext
} }
put_marker(&pb, SOS); put_marker(&pb, SOS);
put_bits(&pb, 16, 6 + comps * 2); put_bits(&pb, 16, 6 + comps * 2);
put_bits(&pb, 8, comps); put_bits(&pb, 8, comps);
for(i = 1; i <= comps; i++) { for (i = 1; i <= comps; i++) {
put_bits(&pb, 8, i); // component ID put_bits(&pb, 8, i); // component ID
put_bits(&pb, 8, 0); // mapping index: none put_bits(&pb, 8, 0); // mapping index: none
} }
put_bits(&pb, 8, near); put_bits(&pb, 8, near);
put_bits(&pb, 8, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line 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, 0); // point transform: none
state = av_mallocz(sizeof(JLSState)); state = av_mallocz(sizeof(JLSState));
/* initialize JPEG-LS state from JPEG parameters */ /* initialize JPEG-LS state from JPEG parameters */
state->near = near; 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_reset_coding_parameters(state, 0);
ff_jpegls_init_state(state); ff_jpegls_init_state(state);
@ -295,46 +315,48 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
zero = av_mallocz(p->linesize[0]); zero = av_mallocz(p->linesize[0]);
last = zero; last = zero;
cur = p->data[0]; cur = p->data[0];
if(avctx->pix_fmt == AV_PIX_FMT_GRAY8){ if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
int t = 0; 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, 8); ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 8);
t = last[0]; t = last[0];
last = cur; last = cur;
cur += p->linesize[0]; 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; 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); ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 16);
t = *((uint16_t*)last); t = *((uint16_t *)last);
last = cur; last = cur;
cur += p->linesize[0]; 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 j, width;
int Rc[3] = {0, 0, 0}; int Rc[3] = { 0, 0, 0 };
width = avctx->width * 3; width = avctx->width * 3;
for(i = 0; i < avctx->height; i++) { for (i = 0; i < avctx->height; i++) {
for(j = 0; j < 3; j++) { for (j = 0; j < 3; j++) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8); ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
width, 3, j, 8);
Rc[j] = last[j]; Rc[j] = last[j];
} }
last = cur; last = cur;
cur += s->picture.linesize[0]; 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 j, width;
int Rc[3] = {0, 0, 0}; int Rc[3] = { 0, 0, 0 };
width = avctx->width * 3; width = avctx->width * 3;
for(i = 0; i < avctx->height; i++) { for (i = 0; i < avctx->height; i++) {
for(j = 2; j >= 0; j--) { for (j = 2; j >= 0; j--) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8); ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
width, 3, j, 8);
Rc[j] = last[j]; Rc[j] = last[j];
} }
last = cur; last = cur;
@ -345,20 +367,20 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
av_free(zero); av_free(zero);
av_free(state); av_free(state);
// the specification says that after doing 0xff escaping unused bits in the /* the specification says that after doing 0xff escaping unused bits in
// last byte must be set to 0, so just append 7 "optional" zero-bits to * the last byte must be set to 0, so just append 7 "optional" zero-bits
// avoid special-casing. * to avoid special-casing. */
put_bits(&pb2, 7, 0); put_bits(&pb2, 7, 0);
size = put_bits_count(&pb2); size = put_bits_count(&pb2);
flush_put_bits(&pb2); flush_put_bits(&pb2);
/* do escape coding */ /* do escape coding */
init_get_bits(&gb, buf2, size); init_get_bits(&gb, buf2, size);
size -= 7; size -= 7;
while(get_bits_count(&gb) < size){ while (get_bits_count(&gb) < size) {
int v; int v;
v = get_bits(&gb, 8); v = get_bits(&gb, 8);
put_bits(&pb, 8, v); put_bits(&pb, 8, v);
if(v == 0xFF){ if (v == 0xFF) {
v = get_bits(&gb, 7); v = get_bits(&gb, 7);
put_bits(&pb, 8, v); put_bits(&pb, 8, v);
} }
@ -378,29 +400,35 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
return 0; return 0;
} }
static av_cold int encode_init_ls(AVCodecContext *ctx) { static av_cold int encode_init_ls(AVCodecContext *ctx)
JpeglsContext *c = (JpeglsContext*)ctx->priv_data; {
JpeglsContext *c = (JpeglsContext *)ctx->priv_data;
c->avctx = ctx; c->avctx = ctx;
ctx->coded_frame = &c->picture; 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){ if (ctx->pix_fmt != AV_PIX_FMT_GRAY8 &&
av_log(ctx, AV_LOG_ERROR, "Only grayscale and RGB24/BGR24 images are supported\n"); 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 -1;
} }
return 0; return 0;
} }
AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them AVCodec ff_jpegls_encoder = {
.name = "jpegls", .name = "jpegls",
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_JPEGLS, .id = AV_CODEC_ID_JPEGLS,
.priv_data_size = sizeof(JpeglsContext), .priv_data_size = sizeof(JpeglsContext),
.init = encode_init_ls, .init = encode_init_ls,
.encode2 = encode_picture_ls, .encode2 = encode_picture_ls,
.pix_fmts = (const enum AVPixelFormat[]){ .pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE AV_PIX_FMT_NONE
}, },
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
}; };