Skip to content

F
ffmpeg
Commit ff4fc5ef authored by Luca Barbato's avatar Luca Barbato Committed by Diego Biurrun
Browse files
Options

jpegls: K&R formatting cosmetics 

Signed-off-by: 's avatarDiego Biurrun <diego@biurrun.de>
parent 9cacdabd
Show whitespace changes
Inline Side-by-side
Showing with 285 additions and 215 deletions
libavcodec/jpegls.c
View file @ ff4fc5ef
......@@ -27,63 +27,76 @@
#include "jpegls.h"
void ff_jpegls_init_state(JLSState *state){
void ff_jpegls_init_state(JLSState *state)
{
int i;
state->twonear = state->near * 2 + 1;
state->range = (state->maxval + state->twonear - 1) / state->twonear + 1;
// QBPP = ceil(log2(RANGE))
for(state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++);
for (state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++)
;
if(state->bpp < 8)
state->limit = 16 + 2 * state->bpp - state->qbpp;
if (state->bpp < 8)
state->limit = 2 * state->bpp - state->qbpp + 16;
else
state->limit = 4 * state->bpp - state->qbpp;
for(i = 0; i < 367; i++) {
for (i = 0; i < 367; i++) {
state->A[i] = FFMAX(state->range + 32 >> 6, 2);
state->N[i] = 1;
}
}
/**
* Custom value clipping function used in T1, T2, T3 calculation
*/
static inline int iso_clip(int v, int vmin, int vmax){
if(v > vmax || v < vmin) return vmin;
else return v;
static inline int iso_clip(int v, int vmin, int vmax)
{
if (v > vmax || v < vmin)
return vmin;
else
return v;
}
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all){
const int basic_t1= 3;
const int basic_t2= 7;
const int basic_t3= 21;
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all)
{
const int basic_t1 = 3;
const int basic_t2 = 7;
const int basic_t3 = 21;
int factor;
if(s->maxval==0 || reset_all) s->maxval= (1 << s->bpp) - 1;
if (s->maxval == 0 || reset_all)
s->maxval = (1 << s->bpp) - 1;
if(s->maxval >=128){
if (s->maxval >= 128) {
factor = FFMIN(s->maxval, 4095) + 128 >> 8;
if(s->T1==0 || reset_all)
s->T1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval);
if(s->T2==0 || reset_all)
s->T2= iso_clip(factor*(basic_t2-3) + 3 + 5*s->near, s->T1, s->maxval);
if(s->T3==0 || reset_all)
s->T3= iso_clip(factor*(basic_t3-4) + 4 + 7*s->near, s->T2, s->maxval);
}else{
factor= 256 / (s->maxval + 1);
if (s->T1 == 0 || reset_all)
s->T1 = iso_clip(factor * (basic_t1 - 2) + 2 + 3 * s->near,
s->near + 1, s->maxval);
if (s->T2 == 0 || reset_all)
s->T2 = iso_clip(factor * (basic_t2 - 3) + 3 + 5 * s->near,
s->T1, s->maxval);
if (s->T3 == 0 || reset_all)
s->T3 = iso_clip(factor * (basic_t3 - 4) + 4 + 7 * s->near,
s->T2, s->maxval);
} else {
factor = 256 / (s->maxval + 1);
if(s->T1==0 || reset_all)
s->T1= iso_clip(FFMAX(2, basic_t1/factor + 3*s->near), s->near+1, s->maxval);
if(s->T2==0 || reset_all)
s->T2= iso_clip(FFMAX(3, basic_t2/factor + 5*s->near), s->T1, s->maxval);
if(s->T3==0 || reset_all)
s->T3= iso_clip(FFMAX(4, basic_t3/factor + 7*s->near), s->T2, s->maxval);
if (s->T1 == 0 || reset_all)
s->T1 = iso_clip(FFMAX(2, basic_t1 / factor + 3 * s->near),
s->near + 1, s->maxval);
if (s->T2 == 0 || reset_all)
s->T2 = iso_clip(FFMAX(3, basic_t2 / factor + 5 * s->near),
s->T1, s->maxval);
if (s->T3 == 0 || reset_all)
s->T3 = iso_clip(FFMAX(4, basic_t3 / factor + 7 * s->near),
s->T2, s->maxval);
}
if(s->reset==0 || reset_all) s->reset= 64;
if (s->reset == 0 || reset_all)
s->reset = 64;
av_dlog(NULL, "[JPEG-LS RESET] T=%i,%i,%i\n", s->T1, s->T2, s->T3);
}
libavcodec/jpegls.h
View file @ ff4fc5ef
......@@ -28,21 +28,21 @@
#ifndef AVCODEC_JPEGLS_H
#define AVCODEC_JPEGLS_H
#include "avcodec.h"
#include "libavutil/common.h"
#include "avcodec.h"
typedef struct JpeglsContext{
typedef struct JpeglsContext {
AVCodecContext *avctx;
AVFrame picture;
}JpeglsContext;
} JpeglsContext;
typedef struct JLSState{
typedef struct JLSState {
int T1, T2, T3;
int A[367], B[367], C[365], N[367];
int limit, reset, bpp, qbpp, maxval, range;
int near, twonear;
int run_index[3];
}JLSState;
} JLSState;
extern const uint8_t ff_log2_run[32];
......@@ -54,19 +54,29 @@ void ff_jpegls_init_state(JLSState *state);
/**
* Calculate quantized gradient value, used for context determination
*/
static inline int ff_jpegls_quantize(JLSState *s, int v){ //FIXME optimize
if(v==0) return 0;
if(v < 0){
if(v <= -s->T3) return -4;
if(v <= -s->T2) return -3;
if(v <= -s->T1) return -2;
if(v < -s->near) return -1;
static inline int ff_jpegls_quantize(JLSState *s, int v)
{
if (v == 0)
return 0;
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;
} else {
if (v <= s->near)
return 0;
if (v < s->T1)
return 1;
if (v < s->T2)
return 2;
if (v < s->T3)
return 3;
return 4;
}
}
......@@ -76,37 +86,39 @@ static inline int ff_jpegls_quantize(JLSState *s, int v){ //FIXME optimize
*/
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all);
static inline void ff_jpegls_downscale_state(JLSState *state, int Q){
if(state->N[Q] == state->reset){
state->A[Q] >>=1;
state->B[Q] >>=1;
state->N[Q] >>=1;
static inline void ff_jpegls_downscale_state(JLSState *state, int Q)
{
if (state->N[Q] == state->reset) {
state->A[Q] >>= 1;
state->B[Q] >>= 1;
state->N[Q] >>= 1;
}
state->N[Q]++;
}
static inline int ff_jpegls_update_state_regular(JLSState *state, int Q, int err){
static inline int ff_jpegls_update_state_regular(JLSState *state,
int Q, int err)
{
state->A[Q] += FFABS(err);
err *= state->twonear;
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 */
libavcodec/jpeglsdec.c
View file @ ff4fc5ef
......@@ -34,18 +34,16 @@
#include "jpegls.h"
#include "jpeglsdec.h"
/*
* Uncomment this to significantly speed up decoding of broken JPEG-LS
* (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit.
*
* There is no Golomb code with length >= 32 bits possible, so check and
* avoid situation of 32 zeros, Libav Golomb decoder is painfully slow
* on this errors.
*/
* Uncomment this to significantly speed up decoding of broken JPEG-LS
* (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit.
*
* There is no Golomb code with length >= 32 bits possible, so check and
* avoid situation of 32 zeros, Libav Golomb decoder is painfully slow
* on this errors.
*/
//#define JLS_BROKEN
/**
* Decode LSE block with initialization parameters
*/
......@@ -56,13 +54,13 @@ int ff_jpegls_decode_lse(MJpegDecodeContext *s)
skip_bits(&s->gb, 16); /* length: FIXME: verify field validity */
id = get_bits(&s->gb, 8);
switch(id){
switch (id) {
case 1:
s->maxval= get_bits(&s->gb, 16);
s->t1= get_bits(&s->gb, 16);
s->t2= get_bits(&s->gb, 16);
s->t3= get_bits(&s->gb, 16);
s->reset= get_bits(&s->gb, 16);
s->maxval = get_bits(&s->gb, 16);
s->t1 = get_bits(&s->gb, 16);
s->t2 = get_bits(&s->gb, 16);
s->t3 = get_bits(&s->gb, 16);
s->reset = get_bits(&s->gb, 16);
// ff_jpegls_reset_coding_parameters(s, 0);
//FIXME quant table?
......@@ -86,27 +84,30 @@ int ff_jpegls_decode_lse(MJpegDecodeContext *s)
/**
* Get context-dependent Golomb code, decode it and update context
*/
static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q){
static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q)
{
int k, ret;
for(k = 0; (state->N[Q] << k) < state->A[Q]; k++);
for (k = 0; (state->N[Q] << k) < state->A[Q]; k++)
;
#ifdef JLS_BROKEN
if(!show_bits_long(gb, 32))return -1;
if (!show_bits_long(gb, 32))
return -1;
#endif
ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp);
/* decode mapped error */
if(ret & 1)
if (ret & 1)
ret = -(ret + 1 >> 1);
else
ret >>= 1;
/* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */
if(!state->near && !k && (2 * state->B[Q] <= -state->N[Q]))
if (!state->near && !k && (2 * state->B[Q] <= -state->N[Q]))
ret = -(ret + 1);
ret= ff_jpegls_update_state_regular(state, Q, ret);
ret = ff_jpegls_update_state_regular(state, Q, ret);
return ret;
}
......@@ -114,28 +115,33 @@ static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q)
/**
* Get Golomb code, decode it and update state for run termination
*/
static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RItype, int limit_add){
static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state,
int RItype, int limit_add)
{
int k, ret, temp, map;
int Q = 365 + RItype;
temp= state->A[Q];
if(RItype)
temp = state->A[Q];
if (RItype)
temp += state->N[Q] >> 1;
for(k = 0; (state->N[Q] << k) < temp; k++);
for (k = 0; (state->N[Q] << k) < temp; k++)
;
#ifdef JLS_BROKEN
if(!show_bits_long(gb, 32))return -1;
if (!show_bits_long(gb, 32))
return -1;
#endif
ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1, state->qbpp);
ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1,
state->qbpp);
/* decode mapped error */
map = 0;
if(!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q]))
if (!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q]))
map = 1;
ret += RItype + map;
if(ret & 1){
if (ret & 1) {
ret = map - (ret + 1 >> 1);
state->B[Q]++;
} else {
......@@ -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,34 +179,35 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
D1 = Rb - Rc;
D2 = Rc - Ra;
/* run mode */
if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) {
if ((FFABS(D0) <= state->near) &&
(FFABS(D1) <= state->near) &&
(FFABS(D2) <= state->near)) {
int r;
int RItype;
/* decode full runs while available */
while(get_bits1(&s->gb)) {
while (get_bits1(&s->gb)) {
int r;
r = 1 << ff_log2_run[state->run_index[comp]];
if(x + r * stride > w) {
if (x + r * stride > w)
r = (w - x) / stride;
}
for(i = 0; i < r; i++) {
for (i = 0; i < r; i++) {
W(dst, x, Ra);
x += stride;
}
/* if EOL reached, we stop decoding */
if (r != 1 << ff_log2_run[state->run_index[comp]])
return;
if(state->run_index[comp] < 31)
if (state->run_index[comp] < 31)
state->run_index[comp]++;
if(x + stride > w)
if (x + stride > w)
return;
}
/* decode aborted run */
r = ff_log2_run[state->run_index[comp]];
if(r)
if (r)
r = get_bits_long(&s->gb, r);
for(i = 0; i < r; i++) {
for (i = 0; i < r; i++) {
W(dst, x, Ra);
x += stride;
}
......@@ -205,14 +215,15 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
/* decode run termination value */
Rb = R(last, x);
RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0;
err = ls_get_code_runterm(&s->gb, state, RItype, ff_log2_run[state->run_index[comp]]);
if(state->run_index[comp])
err = ls_get_code_runterm(&s->gb, state, RItype,
ff_log2_run[state->run_index[comp]]);
if (state->run_index[comp])
state->run_index[comp]--;
if(state->near && RItype){
if (state->near && RItype) {
pred = Ra + err;
} else {
if(Rb < Ra)
if (Rb < Ra)
pred = Rb - err;
else
pred = Rb + err;
......@@ -220,17 +231,19 @@ 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);
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{
} 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);
} else {
......@@ -241,10 +254,10 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
/* we have to do something more for near-lossless coding */
pred += err;
}
if(state->near){
if(pred < -state->near)
if (state->near) {
if (pred < -state->near)
pred += state->range * state->twonear;
else if(pred > state->maxval + state->near)
else if (pred > state->maxval + state->near)
pred -= state->range * state->twonear;
pred = av_clip(pred, 0, state->maxval);
}
......@@ -255,7 +268,9 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *
}
}
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv){
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near,
int point_transform, int ilv)
{
int i, t = 0;
uint8_t *zero, *last, *cur;
JLSState *state;
......@@ -277,29 +292,31 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
ff_jpegls_reset_coding_parameters(state, 0);
ff_jpegls_init_state(state);
if(s->bits <= 8)
if (s->bits <= 8)
shift = point_transform + (8 - s->bits);
else
shift = point_transform + (16 - s->bits);
av_dlog(s->avctx, "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
av_dlog(s->avctx,
"JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) "
"RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
s->width, s->height, state->near, state->maxval,
state->T1, state->T2, state->T3,
state->reset, state->limit, state->qbpp, state->range);
av_dlog(s->avctx, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
ilv, point_transform, s->bits, s->cur_scan);
if(ilv == 0) { /* separate planes */
if (ilv == 0) { /* separate planes */
off = s->cur_scan - 1;
stride = (s->nb_components > 1) ? 3 : 1;
width = s->width * stride;
cur += off;
for(i = 0; i < s->height; i++) {
if(s->bits <= 8){
for (i = 0; i < s->height; i++) {
if (s->bits <= 8) {
ls_decode_line(state, s, last, cur, t, width, stride, off, 8);
t = last[0];
}else{
} else {
ls_decode_line(state, s, last, cur, t, width, stride, off, 16);
t = *((uint16_t*)last);
t = *((uint16_t *)last);
}
last = cur;
cur += s->picture_ptr->linesize[0];
......@@ -309,14 +326,15 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
skip_bits(&s->gb, 16); /* skip RSTn */
}
}
} else if(ilv == 1) { /* line interleaving */
} else if (ilv == 1) { /* line interleaving */
int j;
int Rc[3] = {0, 0, 0};
int Rc[3] = { 0, 0, 0 };
memset(cur, 0, s->picture_ptr->linesize[0]);
width = s->width * 3;
for(i = 0; i < s->height; i++) {
for(j = 0; j < 3; j++) {
ls_decode_line(state, s, last + j, cur + j, Rc[j], width, 3, j, 8);
for (i = 0; i < s->height; i++) {
for (j = 0; j < 3; j++) {
ls_decode_line(state, s, last + j, cur + j,
Rc[j], width, 3, j, 8);
Rc[j] = last[j];
if (s->restart_interval && !--s->restart_count) {
......@@ -327,35 +345,34 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
last = cur;
cur += s->picture_ptr->linesize[0];
}
} else if(ilv == 2) { /* sample interleaving */
av_log(s->avctx, AV_LOG_ERROR, "Sample interleaved images are not supported.\n");
} else if (ilv == 2) { /* sample interleaving */
av_log(s->avctx, AV_LOG_ERROR,
"Sample interleaved images are not supported.\n");
av_free(state);
av_free(zero);
return -1;
}
if(shift){ /* we need to do point transform or normalize samples */
if (shift) { /* we need to do point transform or normalize samples */
int x, w;
w = s->width * s->nb_components;
if(s->bits <= 8){
if (s->bits <= 8) {
uint8_t *src = s->picture_ptr->data[0];
for(i = 0; i < s->height; i++){
for(x = off; x < w; x+= stride){
for (i = 0; i < s->height; i++) {
for (x = off; x < w; x += stride)
src[x] <<= shift;
}
src += s->picture_ptr->linesize[0];
}
}else{
uint16_t *src = (uint16_t*) s->picture_ptr->data[0];
} else {
uint16_t *src = (uint16_t *)s->picture_ptr->data[0];
for(i = 0; i < s->height; i++){
for(x = 0; x < w; x++){
for (i = 0; i < s->height; i++) {
for (x = 0; x < w; x++)
src[x] <<= shift;
}
src += s->picture_ptr->linesize[0]/2;
src += s->picture_ptr->linesize[0] / 2;
}
}
}
......@@ -365,9 +382,9 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
return 0;
}
AVCodec ff_jpegls_decoder = {
.name = "jpegls",
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_JPEGLS,
.priv_data_size = sizeof(MJpegDecodeContext),
......@@ -375,5 +392,4 @@ AVCodec ff_jpegls_decoder = {
.close = ff_mjpeg_decode_end,
.decode = ff_mjpeg_decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
};
libavcodec/jpeglsdec.h
View file @ ff4fc5ef
......@@ -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 */
libavcodec/jpeglsenc.c
View file @ ff4fc5ef
......@@ -33,20 +33,22 @@
#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;
......@@ -62,27 +64,30 @@ static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q,
/**
* Encode error from run termination
*/
static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RItype, int err, int limit_add){
static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb,
int RItype, int err, int limit_add)
{
int k;
int val, map;
int Q = 365 + RItype;
int temp;
temp = state->A[Q];
if(RItype)
if (RItype)
temp += state->N[Q] >> 1;
for(k = 0; (state->N[Q] << k) < temp; k++);
for (k = 0; (state->N[Q] << k) < temp; k++)
;
map = 0;
if(!k && err && (2 * state->B[Q] < state->N[Q]))
if (!k && err && (2 * state->B[Q] < state->N[Q]))
map = 1;
if(err < 0)
val = - (2 * err) - 1 - RItype + map;
if (err < 0)
val = -(2 * err) - 1 - RItype + map;
else
val = 2 * err - RItype - map;
set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
if(err < 0)
if (err < 0)
state->B[Q]++;
state->A[Q] += (val + 1 - RItype) >> 1;
......@@ -92,19 +97,21 @@ static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RIt
/**
* Encode run value as specified by JPEG-LS standard
*/
static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, int comp, int trail){
while(run >= (1 << ff_log2_run[state->run_index[comp]])){
static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run,
int comp, int trail)
{
while (run >= (1 << ff_log2_run[state->run_index[comp]])) {
put_bits(pb, 1, 1);
run -= 1 << ff_log2_run[state->run_index[comp]];
if(state->run_index[comp] < 31)
if (state->run_index[comp] < 31)
state->run_index[comp]++;
}
/* if hit EOL, encode another full run, else encode aborted run */
if(!trail && run) {
if (!trail && run) {
put_bits(pb, 1, 1);
}else if(trail){
} else if (trail) {
put_bits(pb, 1, 0);
if(ff_log2_run[state->run_index[comp]])
if (ff_log2_run[state->run_index[comp]])
put_bits(pb, ff_log2_run[state->run_index[comp]], run);
}
}
......@@ -112,12 +119,15 @@ static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, in
/**
* Encode one line of image
*/
static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last, void *cur, int last2, int w, int stride, int comp, int bits){
static inline void ls_encode_line(JLSState *state, PutBitContext *pb,
void *last, void *cur, int last2, int w,
int stride, int comp, int bits)
{
int x = 0;
int Ra, Rb, Rc, Rd;
int D0, D1, D2;
while(x < w) {
while (x < w) {
int err, pred, sign;
/* compute gradients */
......@@ -130,71 +140,76 @@ static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last
D2 = Rc - Ra;
/* run mode */
if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) {
if ((FFABS(D0) <= state->near) &&
(FFABS(D1) <= state->near) &&
(FFABS(D2) <= state->near)) {
int RUNval, RItype, run;
run = 0;
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);
RItype = FFABS(Ra - Rb) <= state->near;
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)
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);
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{
} else {
sign = 0;
pred = av_clip(pred + state->C[context], 0, state->maxval);
err = R(cur, x) - pred;
}
if(state->near){
if(err > 0)
if (state->near) {
if (err > 0)
err = (state->near + err) / state->twonear;
else
err = -(state->near - err) / state->twonear;
if(!sign)
if (!sign)
Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
else
Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
......@@ -207,13 +222,17 @@ 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.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);
......@@ -229,8 +248,8 @@ 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;
JpeglsContext *const s = avctx->priv_data;
AVFrame *const p = &s->picture;
const int near = avctx->prediction_method;
PutBitContext pb, pb2;
GetBitContext gb;
......@@ -240,15 +259,16 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
int comps;
*p = *pict;
p->pict_type= AV_PICTURE_TYPE_I;
p->key_frame= 1;
p->pict_type = AV_PICTURE_TYPE_I;
p->key_frame = 1;
if(avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)
if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
avctx->pix_fmt == AV_PIX_FMT_GRAY16)
comps = 1;
else
comps = 3;
if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*comps*4 +
if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height * comps * 4 +
FF_MIN_BUFFER_SIZE)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
return ret;
......@@ -267,7 +287,7 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
put_bits(&pb, 16, avctx->height);
put_bits(&pb, 16, avctx->width);
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, 0x11); // subsampling: none
put_bits(&pb, 8, 0); // Tiq, used by JPEG-LS ext
......@@ -276,7 +296,7 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
put_marker(&pb, SOS);
put_bits(&pb, 16, 6 + comps * 2);
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, 0); // mapping index: none
}
......@@ -296,45 +316,47 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
zero = av_mallocz(p->linesize[0]);
last = zero;
cur = p->data[0];
if(avctx->pix_fmt == AV_PIX_FMT_GRAY8){
if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
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);
t = last[0];
last = cur;
cur += p->linesize[0];
}
}else if(avctx->pix_fmt == AV_PIX_FMT_GRAY16){
} else if (avctx->pix_fmt == AV_PIX_FMT_GRAY16) {
int t = 0;
for(i = 0; i < avctx->height; i++) {
for (i = 0; i < avctx->height; i++) {
ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 16);
t = *((uint16_t*)last);
t = *((uint16_t *)last);
last = cur;
cur += p->linesize[0];
}
}else if(avctx->pix_fmt == AV_PIX_FMT_RGB24){
} else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
int j, width;
int Rc[3] = {0, 0, 0};
int Rc[3] = { 0, 0, 0 };
width = avctx->width * 3;
for(i = 0; i < avctx->height; i++) {
for(j = 0; j < 3; j++) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8);
for (i = 0; i < avctx->height; i++) {
for (j = 0; j < 3; j++) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
width, 3, j, 8);
Rc[j] = last[j];
}
last = cur;
cur += s->picture.linesize[0];
}
}else if(avctx->pix_fmt == AV_PIX_FMT_BGR24){
} else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
int j, width;
int Rc[3] = {0, 0, 0};
int Rc[3] = { 0, 0, 0 };
width = avctx->width * 3;
for(i = 0; i < avctx->height; i++) {
for(j = 2; j >= 0; j--) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8);
for (i = 0; i < avctx->height; i++) {
for (j = 2; j >= 0; j--) {
ls_encode_line(state, &pb2, last + j, cur + j, Rc[j],
width, 3, j, 8);
Rc[j] = last[j];
}
last = cur;
......@@ -345,20 +367,20 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
av_free(zero);
av_free(state);
// the specification says that after doing 0xff escaping unused bits in the
// last byte must be set to 0, so just append 7 "optional" zero-bits to
// avoid special-casing.
/* the specification says that after doing 0xff escaping unused bits in
* the last byte must be set to 0, so just append 7 "optional" zero-bits
* to avoid special-casing. */
put_bits(&pb2, 7, 0);
size = put_bits_count(&pb2);
flush_put_bits(&pb2);
/* do escape coding */
init_get_bits(&gb, buf2, size);
size -= 7;
while(get_bits_count(&gb) < size){
while (get_bits_count(&gb) < size) {
int v;
v = get_bits(&gb, 8);
put_bits(&pb, 8, v);
if(v == 0xFF){
if (v == 0xFF) {
v = get_bits(&gb, 7);
put_bits(&pb, 8, v);
}
......@@ -378,29 +400,35 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
return 0;
}
static av_cold int encode_init_ls(AVCodecContext *ctx) {
JpeglsContext *c = (JpeglsContext*)ctx->priv_data;
static av_cold int encode_init_ls(AVCodecContext *ctx)
{
JpeglsContext *c = (JpeglsContext *)ctx->priv_data;
c->avctx = ctx;
ctx->coded_frame = &c->picture;
if(ctx->pix_fmt != AV_PIX_FMT_GRAY8 && ctx->pix_fmt != AV_PIX_FMT_GRAY16 && ctx->pix_fmt != AV_PIX_FMT_RGB24 && ctx->pix_fmt != AV_PIX_FMT_BGR24){
av_log(ctx, AV_LOG_ERROR, "Only grayscale and RGB24/BGR24 images are supported\n");
if (ctx->pix_fmt != AV_PIX_FMT_GRAY8 &&
ctx->pix_fmt != AV_PIX_FMT_GRAY16 &&
ctx->pix_fmt != AV_PIX_FMT_RGB24 &&
ctx->pix_fmt != AV_PIX_FMT_BGR24) {
av_log(ctx, AV_LOG_ERROR,
"Only grayscale and RGB24/BGR24 images are supported\n");
return -1;
}
return 0;
}
AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them
AVCodec ff_jpegls_encoder = {
.name = "jpegls",
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_JPEGLS,
.priv_data_size = sizeof(JpeglsContext),
.init = encode_init_ls,
.encode2 = encode_picture_ls,
.pix_fmts = (const enum AVPixelFormat[]){
AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
},
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
};
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment