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

Merge commit 'ff4fc5ef12a37716c5c5d8928a2db92428e916ec'

Browse Source 
* 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>
pull/18/head
Michael Niedermayer 12 years ago
parent 0d83b5722e ff4fc5ef12
commit 39354d6089
5 changed files with 334 additions and 264 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 69
      libavcodec/jpegls.c
  2. 78
      libavcodec/jpegls.h
  3. 210
      libavcodec/jpeglsdec.c
  4. 3
      libavcodec/jpeglsdec.h
  5. 238
      libavcodec/jpeglsenc.c

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

78
libavcodec/jpegls.h
Unescape 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 */

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

3
libavcodec/jpeglsdec.h
Unescape 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 */

238
libavcodec/jpeglsenc.c
Unescape 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