falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge commit 'ff4fc5ef12a37716c5c5d8928a2db92428e916ec' 

* commit 'ff4fc5ef12a37716c5c5d8928a2db92428e916ec':
  jpegls: K&R formatting cosmetics

Conflicts:
	libavcodec/jpegls.c
	libavcodec/jpegls.h
	libavcodec/jpeglsdec.c
	libavcodec/jpeglsenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n2.0
Michael Niedermayer 12 years ago
parent
0d83b5722e ff4fc5ef12
commit
39354d6089
5 changed files with 334 additions and 264 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +41
    -28
      libavcodec/jpegls.c
  2. +45
    -33
      libavcodec/jpegls.h
  3. +113
    -97
      libavcodec/jpeglsdec.c
  4. +2
    -1
      libavcodec/jpeglsdec.h
  5. +133
    -105
      libavcodec/jpeglsenc.c

+ 41
- 28
libavcodec/jpegls.c View File

@@ -27,61 +27,74 @@

#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++)
;

state->bpp = FFMAX(av_log2(state->maxval) + 1, 2);
state->limit = 2*(state->bpp + FFMAX(state->bpp, 8)) - 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);
}

+ 45
- 33
libavcodec/jpegls.h View File

@@ -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[4];
}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,39 +86,41 @@ 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)
{
if(FFABS(err) > 0xFFFF)
return -0x10000;
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 */

+ 113
- 97
libavcodec/jpeglsdec.c View File

@@ -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, FFmpeg 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, FFmpeg 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,52 +179,54 @@ 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);
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;
}

/* 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;
@@ -223,31 +234,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);
}
@@ -258,7 +271,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;
@@ -266,45 +281,47 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor

zero = av_mallocz(s->picture.linesize[0]);
last = zero;
cur = s->picture.data[0];
cur = s->picture.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);

if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
av_log(s->avctx, AV_LOG_DEBUG, "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
av_log(s->avctx, AV_LOG_DEBUG,
"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_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
ilv, point_transform, s->bits, s->cur_scan);
}
if(ilv == 0) { /* separate planes */
if (ilv == 0) { /* separate planes */
stride = (s->nb_components > 1) ? 3 : 1;
off = av_clip(s->cur_scan - 1, 0, stride - 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);
off = av_clip(s->cur_scan - 1, 0, stride - 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);
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.linesize[0];
@@ -314,15 +331,16 @@ 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 };
stride = (s->nb_components > 1) ? 3 : 1;
memset(cur, 0, s->picture.linesize[0]);
width = s->width * stride;
for(i = 0; i < s->height; i++) {
for(j = 0; j < stride; j++) {
ls_decode_line(state, s, last + j, cur + j, Rc[j], width, stride, j, 8);
for (i = 0; i < s->height; i++) {
for (j = 0; j < stride; j++) {
ls_decode_line(state, s, last + j, cur + j,
Rc[j], width, stride, j, 8);
Rc[j] = last[j];

if (s->restart_interval && !--s->restart_count) {
@@ -333,35 +351,34 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
last = cur;
cur += s->picture.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.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.linesize[0];
}
}else{
uint16_t *src = (uint16_t*) s->picture.data[0];
} else {
uint16_t *src = (uint16_t *)s->picture.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.linesize[0]/2;
src += s->picture.linesize[0] / 2;
}
}
}
@@ -371,9 +388,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),
@@ -381,5 +398,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"),
};

+ 2
- 1
libavcodec/jpeglsdec.h View File

@@ -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 */

+ 133
- 105
libavcodec/jpeglsenc.c View File

@@ -34,24 +34,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;

@@ -63,27 +65,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;

@@ -93,19 +98,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);
}
}
@@ -113,12 +120,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 */
@@ -131,71 +141,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);
@@ -208,18 +223,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);
@@ -230,9 +249,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;
@@ -240,17 +259,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_packet2(avctx, pkt, avctx->width*avctx->height*comps*4 +
FF_MIN_BUFFER_SIZE)) < 0)
if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width *avctx->height * comps * 4 +
FF_MIN_BUFFER_SIZE)) < 0)
return ret;

buf2 = av_malloc(pkt->size);
@@ -262,31 +282,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);

@@ -298,46 +318,48 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
return AVERROR(ENOMEM);
}
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;
@@ -348,20 +370,20 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
av_freep(&zero);
av_freep(&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);
}
@@ -381,14 +403,19 @@ 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;
@@ -396,14 +423,15 @@ static av_cold int encode_init_ls(AVCodecContext *ctx) {

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"),
};

Write Preview
Loading…
Cancel
Save