Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

jpegls: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/18/head
Luca Barbato 12 years ago committed by Diego Biurrun
parent 9cacdabd1c
commit ff4fc5ef12
5 changed files with 336 additions and 266 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 73
      libavcodec/jpegls.c
  2. 78
      libavcodec/jpegls.h
  3. 208
      libavcodec/jpeglsdec.c
  4. 3
      libavcodec/jpeglsdec.h
  5. 240
      libavcodec/jpeglsenc.c

73
libavcodec/jpegls.c
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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"),
}; };

Write Preview
Loading…
Cancel
Save