git.sesse.net Git - ffmpeg/blob - libavcodec/jpeg_ls.c

   1 /*
   2  * JPEG-LS encoder and decoder
   3  * Copyright (c) 2003 Michael Niedermayer
   4  * Copyright (c) 2006 Konstantin Shishkov
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "golomb.h"
  24
  25 /**
  26  * @file jpeg_ls.c
  27  * JPEG-LS encoder and decoder.
  28  */
  29
  30 typedef struct JpeglsContext{
  31     AVCodecContext *avctx;
  32     AVFrame picture;
  33 }JpeglsContext;
  34
  35 typedef struct JLSState{
  36     int T1, T2, T3;
  37     int A[367], B[367], C[365], N[367];
  38     int limit, reset, bpp, qbpp, maxval, range;
  39     int near, twonear;
  40     int run_index[3];
  41 }JLSState;
  42
  43 static const uint8_t log2_run[32]={
  44  0, 0, 0, 0, 1, 1, 1, 1,
  45  2, 2, 2, 2, 3, 3, 3, 3,
  46  4, 4, 5, 5, 6, 6, 7, 7,
  47  8, 9,10,11,12,13,14,15
  48 };
  49
  50 /*
  51 * Uncomment this to significantly speed up decoding of broken JPEG-LS
  52 * (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit.
  53 *
  54 * There is no Golomb code with length >= 32 bits possible, so check and
  55 * avoid situation of 32 zeros, FFmpeg Golomb decoder is painfully slow
  56 * on this errors.
  57 */
  58 //#define JLS_BROKEN
  59
  60 /********** Functions for both encoder and decoder **********/
  61
  62 /**
  63  * Calculate initial JPEG-LS parameters
  64  */
  65 static void ls_init_state(JLSState *state){
  66     int i;
  67
  68     state->twonear = state->near * 2 + 1;
  69     state->range = ((state->maxval + state->twonear - 1) / state->twonear) + 1;
  70
  71     // QBPP = ceil(log2(RANGE))
  72     for(state->qbpp = 0; (1 << state->qbpp) < state->range; state->qbpp++);
  73
  74     if(state->bpp < 8)
  75         state->limit = 16 + 2 * state->bpp - state->qbpp;
  76     else
  77         state->limit = (4 * state->bpp) - state->qbpp;
  78
  79     for(i = 0; i < 367; i++) {
  80         state->A[i] = (state->range + 32) >> 6;
  81         if(state->A[i] < 2)
  82             state->A[i] = 2;
  83         state->N[i] = 1;
  84     }
  85
  86 }
  87
  88 /**
  89  * Calculate quantized gradient value, used for context determination
  90  */
  91 static inline int quantize(JLSState *s, int v){ //FIXME optimize
  92     if(v==0) return 0;
  93     if(v < 0){
  94         if(v <= -s->T3) return -4;
  95         if(v <= -s->T2) return -3;
  96         if(v <= -s->T1) return -2;
  97         if(v <  -s->near) return -1;
  98         return 0;
  99     }else{
 100         if(v <= s->near) return 0;
 101         if(v <  s->T1) return 1;
 102         if(v <  s->T2) return 2;
 103         if(v <  s->T3) return 3;
 104         return 4;
 105     }
 106 }
 107
 108 /**
 109  * Custom value clipping function used in T1, T2, T3 calculation
 110  */
 111 static inline int iso_clip(int v, int vmin, int vmax){
 112     if(v > vmax || v < vmin) return vmin;
 113     else                     return v;
 114 }
 115
 116 /**
 117  * Calculate JPEG-LS codec values
 118  */
 119 static void reset_ls_coding_parameters(JLSState *s, int reset_all){
 120     const int basic_t1= 3;
 121     const int basic_t2= 7;
 122     const int basic_t3= 21;
 123     int factor;
 124
 125     if(s->maxval==0 || reset_all) s->maxval= (1 << s->bpp) - 1;
 126
 127     if(s->maxval >=128){
 128         factor= (FFMIN(s->maxval, 4095) + 128)>>8;
 129
 130         if(s->T1==0     || reset_all)
 131             s->T1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval);
 132         if(s->T2==0     || reset_all)
 133             s->T2= iso_clip(factor*(basic_t2-3) + 3 + 5*s->near, s->T1, s->maxval);
 134         if(s->T3==0     || reset_all)
 135             s->T3= iso_clip(factor*(basic_t3-4) + 4 + 7*s->near, s->T2, s->maxval);
 136     }else{
 137         factor= 256 / (s->maxval + 1);
 138
 139         if(s->T1==0     || reset_all)
 140             s->T1= iso_clip(FFMAX(2, basic_t1/factor + 3*s->near), s->near+1, s->maxval);
 141         if(s->T2==0     || reset_all)
 142             s->T2= iso_clip(FFMAX(3, basic_t2/factor + 5*s->near), s->T1, s->maxval);
 143         if(s->T3==0     || reset_all)
 144             s->T3= iso_clip(FFMAX(4, basic_t3/factor + 6*s->near), s->T2, s->maxval);
 145     }
 146
 147     if(s->reset==0  || reset_all) s->reset= 64;
 148 //    av_log(NULL, AV_LOG_DEBUG, "[JPEG-LS RESET] T=%i,%i,%i\n", s->T1, s->T2, s->T3);
 149 }
 150
 151
 152 /********** Decoder-specific functions **********/
 153
 154 /**
 155  * Decode LSE block with initialization parameters
 156  */
 157 static int decode_lse(MJpegDecodeContext *s)
 158 {
 159     int len, id;
 160
 161     /* XXX: verify len field validity */
 162     len = get_bits(&s->gb, 16);
 163     id = get_bits(&s->gb, 8);
 164
 165     switch(id){
 166     case 1:
 167         s->maxval= get_bits(&s->gb, 16);
 168         s->t1= get_bits(&s->gb, 16);
 169         s->t2= get_bits(&s->gb, 16);
 170         s->t3= get_bits(&s->gb, 16);
 171         s->reset= get_bits(&s->gb, 16);
 172
 173 //        reset_ls_coding_parameters(s, 0);
 174         //FIXME quant table?
 175         break;
 176     case 2:
 177     case 3:
 178         av_log(s->avctx, AV_LOG_ERROR, "palette not supported\n");
 179         return -1;
 180     case 4:
 181         av_log(s->avctx, AV_LOG_ERROR, "oversize image not supported\n");
 182         return -1;
 183     default:
 184         av_log(s->avctx, AV_LOG_ERROR, "invalid id %d\n", id);
 185         return -1;
 186     }
 187 //    av_log(s->avctx, AV_LOG_DEBUG, "ID=%i, T=%i,%i,%i\n", id, s->t1, s->t2, s->t3);
 188
 189     return 0;
 190 }
 191
 192
 193 /**
 194  * Get context-dependent Golomb code, decode it and update context
 195  */
 196 static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q){
 197     int k, ret;
 198
 199     for(k = 0; (state->N[Q] << k) < state->A[Q]; k++);
 200
 201 #ifdef JLS_BROKEN
 202     if(!show_bits_long(gb, 32))return -1;
 203 #endif
 204     ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp);
 205
 206     /* decode mapped error */
 207     if(ret & 1)
 208         ret = -((ret + 1) >> 1);
 209     else
 210         ret >>= 1;
 211
 212     /* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */
 213     if(!state->near && !k && (2 * state->B[Q] <= -state->N[Q]))
 214         ret = -(ret + 1);
 215
 216     state->A[Q] += FFABS(ret);
 217     ret *= state->twonear;
 218     state->B[Q] += ret;
 219
 220     if(state->N[Q] == state->reset) {
 221         state->A[Q] >>= 1;
 222         state->B[Q] >>= 1;
 223         state->N[Q] >>= 1;
 224     }
 225     state->N[Q]++;
 226
 227     if(state->B[Q] <= -state->N[Q]) {
 228         state->B[Q] += state->N[Q];
 229         if(state->C[Q] > -128)
 230             state->C[Q]--;
 231         if(state->B[Q] <= -state->N[Q])
 232             state->B[Q] = -state->N[Q] + 1;
 233     }else if(state->B[Q] > 0){
 234         state->B[Q] -= state->N[Q];
 235         if(state->C[Q] < 127)
 236             state->C[Q]++;
 237         if(state->B[Q] > 0)
 238             state->B[Q] = 0;
 239     }
 240
 241     return ret;
 242 }
 243
 244 /**
 245  * Get Golomb code, decode it and update state for run termination
 246  */
 247 static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RItype, int limit_add){
 248     int k, ret, temp, map;
 249     int Q = 365 + RItype;
 250
 251     if(!RItype)
 252         temp = state->A[Q];
 253     else
 254         temp = state->A[Q] + (state->N[Q] >> 1);
 255
 256     for(k = 0; (state->N[Q] << k) < temp; k++);
 257
 258 #ifdef JLS_BROKEN
 259     if(!show_bits_long(gb, 32))return -1;
 260 #endif
 261     ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1, state->qbpp);
 262
 263     /* decode mapped error */
 264     map = 0;
 265     if(!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q]))
 266         map = 1;
 267     ret += RItype + map;
 268
 269     if(ret & 1){
 270         ret = map - ((ret + 1) >> 1);
 271         state->B[Q]++;
 272     } else {
 273         ret = ret >> 1;
 274     }
 275
 276     /* update state */
 277     state->A[Q] += FFABS(ret) - RItype;
 278     ret *= state->twonear;
 279     if(state->N[Q] == state->reset){
 280         state->A[Q] >>=1;
 281         state->B[Q] >>=1;
 282         state->N[Q] >>=1;
 283     }
 284     state->N[Q]++;
 285
 286     return ret;
 287 }
 288
 289 /**
 290  * Decode one line of image
 291  */
 292 static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s, uint8_t *last, uint8_t *dst, int last2, int w, int stride, int comp){
 293     int i, x = 0;
 294     int Ra, Rb, Rc, Rd;
 295     int D0, D1, D2;
 296
 297     while(x < w) {
 298         int err, pred;
 299
 300         /* compute gradients */
 301         Ra = x ? dst[x - stride] : last[x];
 302         Rb = last[x];
 303         Rc = x ? last[x - stride] : last2;
 304         Rd = (x >= w - stride) ? last[x] : last[x + stride];
 305         D0 = Rd - Rb;
 306         D1 = Rb - Rc;
 307         D2 = Rc - Ra;
 308         /* run mode */
 309         if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) {
 310             int r;
 311             int RItype;
 312
 313             /* decode full runs while available */
 314             while(get_bits1(&s->gb)) {
 315                 int r;
 316                 r = 1 << log2_run[state->run_index[comp]];
 317                 if(x + r * stride > w) {
 318                     r = (w - x) / stride;
 319                 }
 320                 for(i = 0; i < r; i++) {
 321                     dst[x] = Ra;
 322                     x += stride;
 323                 }
 324                 /* if EOL reached, we stop decoding */
 325                 if(r != (1 << log2_run[state->run_index[comp]]))
 326                     return;
 327                 if(state->run_index[comp] < 31)
 328                     state->run_index[comp]++;
 329                 if(x + stride > w)
 330                     return;
 331             }
 332             /* decode aborted run */
 333             r = log2_run[state->run_index[comp]];
 334             if(r)
 335                 r = get_bits_long(&s->gb, r);
 336             for(i = 0; i < r; i++) {
 337                 dst[x] = Ra;
 338                 x += stride;
 339             }
 340
 341             /* decode run termination value */
 342             Rb = last[x];
 343             RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0;
 344             err = ls_get_code_runterm(&s->gb, state, RItype, log2_run[state->run_index[comp]]);
 345             if(state->run_index[comp])
 346                 state->run_index[comp]--;
 347
 348             if(state->near && RItype){
 349                 pred = Ra + err;
 350             } else {
 351                 if(Rb < Ra)
 352                     pred = Rb - err;
 353                 else
 354                     pred = Rb + err;
 355             }
 356
 357             if(state->near){
 358                 if(pred < -state->near)
 359                     pred += state->range * state->twonear;
 360                 else if(pred > state->maxval + state->near)
 361                     pred -= state->range * state->twonear;
 362                 pred = clip(pred, 0, state->maxval);
 363             }
 364
 365             dst[x] = pred;
 366             x += stride;
 367         } else { /* regular mode */
 368             int context, sign;
 369
 370             context = quantize(state, D0) * 81 + quantize(state, D1) * 9 + quantize(state, D2);
 371             pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
 372
 373             if(context < 0){
 374                 context = -context;
 375                 sign = 1;
 376             }else{
 377                 sign = 0;
 378             }
 379
 380             if(sign){
 381                 pred = clip(pred - state->C[context], 0, state->maxval);
 382                 err = -ls_get_code_regular(&s->gb, state, context);
 383             } else {
 384                 pred = clip(pred + state->C[context], 0, state->maxval);
 385                 err = ls_get_code_regular(&s->gb, state, context);
 386             }
 387
 388             /* we have to do something more for near-lossless coding */
 389             pred += err;
 390             if(state->near) {
 391                 if(pred < -state->near)
 392                     pred += state->range * state->twonear;
 393                 else if(pred > state->maxval + state->near)
 394                     pred -= state->range * state->twonear;
 395                 pred = clip(pred, 0, state->maxval);
 396             }
 397
 398             dst[x] = pred;
 399             x += stride;
 400         }
 401     }
 402 }
 403
 404 static int ls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv){
 405     int i, t = 0;
 406     uint8_t *zero, *last, *cur;
 407     JLSState *state;
 408     int off, stride, width;
 409
 410     zero = av_mallocz(s->picture.linesize[0]);
 411     last = zero;
 412     cur = s->picture.data[0];
 413
 414     state = av_mallocz(sizeof(JLSState));
 415     /* initialize JPEG-LS state from JPEG parameters */
 416     state->near = near;
 417     state->bpp = (s->bits < 2) ? 2 : s->bits;
 418     state->maxval = s->maxval;
 419     state->T1 = s->t1;
 420     state->T2 = s->t2;
 421     state->T3 = s->t3;
 422     state->reset = s->reset;
 423     reset_ls_coding_parameters(state, 0);
 424     ls_init_state(state);
 425
 426 //    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);
 427 //    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);
 428     if(ilv == 0) { /* separate planes */
 429         off = s->cur_scan - 1;
 430         stride = (s->nb_components > 1) ? 3 : 1;
 431         width = s->width * stride;
 432         cur += off;
 433         for(i = 0; i < s->height; i++) {
 434             ls_decode_line(state, s, last, cur, t, width, stride, off);
 435             t = last[0];
 436             last = cur;
 437             cur += s->picture.linesize[0];
 438
 439             if (s->restart_interval && !--s->restart_count) {
 440                 align_get_bits(&s->gb);
 441                 skip_bits(&s->gb, 16); /* skip RSTn */
 442             }
 443         }
 444     } else if(ilv == 1) { /* line interleaving */
 445         int j;
 446         int Rc[3] = {0, 0, 0};
 447         memset(cur, 0, s->picture.linesize[0]);
 448         width = s->width * 3;
 449         for(i = 0; i < s->height; i++) {
 450             for(j = 0; j < 3; j++) {
 451                 ls_decode_line(state, s, last + j, cur + j, Rc[j], width, 3, j);
 452                 Rc[j] = last[j];
 453
 454                 if (s->restart_interval && !--s->restart_count) {
 455                     align_get_bits(&s->gb);
 456                     skip_bits(&s->gb, 16); /* skip RSTn */
 457                 }
 458             }
 459             last = cur;
 460             cur += s->picture.linesize[0];
 461         }
 462     } else if(ilv == 2) { /* sample interleaving */
 463         av_log(s->avctx, AV_LOG_ERROR, "Sample interleaved images are not supported.\n");
 464         av_free(state);
 465         av_free(zero);
 466         return -1;
 467     }
 468
 469     av_free(state);
 470     av_free(zero);
 471
 472     return 0;
 473 }
 474
 475 #if defined(CONFIG_ENCODERS) && defined(CONFIG_JPEGLS_ENCODER)
 476 /********** Encoder-specific functions **********/
 477
 478 /**
 479  * Encode error from regular symbol
 480  */
 481 static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, int err){
 482     int k;
 483     int val;
 484     int map;
 485
 486     for(k = 0; (state->N[Q] << k) < state->A[Q]; k++);
 487
 488     map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]);
 489
 490     if(err < 0)
 491         err += state->range;
 492     if(err >= ((state->range + 1) >> 1)) {
 493         err -= state->range;
 494         val = 2 * FFABS(err) - 1 - map;
 495     } else
 496         val = 2 * err + map;
 497
 498     set_ur_golomb_jpegls(pb, val, k, state->limit, state->qbpp);
 499
 500     state->A[Q] += FFABS(err);
 501     state->B[Q] += err * state->twonear;
 502
 503     if(state->N[Q] == state->reset) {
 504         state->A[Q] >>= 1;
 505         state->B[Q] >>= 1;
 506         state->N[Q] >>= 1;
 507     }
 508     state->N[Q]++;
 509
 510     if(state->B[Q] <= -state->N[Q]) {
 511         state->B[Q] += state->N[Q];
 512         if(state->C[Q] > -128)
 513             state->C[Q]--;
 514         if(state->B[Q] <= -state->N[Q])
 515             state->B[Q] = -state->N[Q] + 1;
 516     }else if(state->B[Q] > 0){
 517         state->B[Q] -= state->N[Q];
 518         if(state->C[Q] < 127)
 519             state->C[Q]++;
 520         if(state->B[Q] > 0)
 521             state->B[Q] = 0;
 522     }
 523 }
 524
 525 /**
 526  * Encode error from run termination
 527  */
 528 static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RItype, int err, int limit_add){
 529     int k;
 530     int val, map;
 531     int Q = 365 + RItype;
 532     int temp;
 533
 534     temp = state->A[Q];
 535     if(RItype)
 536         temp += state->N[Q] >> 1;
 537     for(k = 0; (state->N[Q] << k) < temp; k++);
 538     map = 0;
 539     if(!k && err && (2 * state->B[Q] < state->N[Q]))
 540         map = 1;
 541
 542     if(err < 0)
 543         val = - (2 * err) - 1 - RItype + map;
 544     else
 545         val = 2 * err - RItype - map;
 546     set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
 547
 548     if(err < 0)
 549         state->B[Q]++;
 550     state->A[Q] += (val + 1 - RItype) >> 1;
 551
 552     if(state->N[Q] == state->reset) {
 553         state->A[Q] >>= 1;
 554         state->B[Q] >>= 1;
 555         state->N[Q] >>= 1;
 556     }
 557     state->N[Q]++;
 558 }
 559
 560 /**
 561  * Encode run value as specified by JPEG-LS standard
 562  */
 563 static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, int comp, int trail){
 564     while(run >= (1 << log2_run[state->run_index[comp]])){
 565         put_bits(pb, 1, 1);
 566         run -= 1 << log2_run[state->run_index[comp]];
 567         if(state->run_index[comp] < 31)
 568             state->run_index[comp]++;
 569     }
 570     /* if hit EOL, encode another full run, else encode aborted run */
 571     if(!trail && run) {
 572         put_bits(pb, 1, 1);
 573     }else if(trail){
 574         put_bits(pb, 1, 0);
 575         if(log2_run[state->run_index[comp]])
 576             put_bits(pb, log2_run[state->run_index[comp]], run);
 577     }
 578 }
 579
 580 /**
 581  * Encode one line of image
 582  */
 583 static inline void ls_encode_line(JLSState *state, PutBitContext *pb, uint8_t *last, uint8_t *cur, int last2, int w, int stride, int comp){
 584     int x = 0;
 585     int Ra, Rb, Rc, Rd;
 586     int D0, D1, D2;
 587
 588     while(x < w) {
 589         int err, pred, sign;
 590
 591         /* compute gradients */
 592         Ra = x ? cur[x - stride] : last[x];
 593         Rb = last[x];
 594         Rc = x ? last[x - stride] : last2;
 595         Rd = (x >= w - stride) ? last[x] : last[x + stride];
 596         D0 = Rd - Rb;
 597         D1 = Rb - Rc;
 598         D2 = Rc - Ra;
 599
 600         /* run mode */
 601         if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) {
 602             int RUNval, RItype, run;
 603
 604             run = 0;
 605             RUNval = Ra;
 606             while(x < w && (FFABS(cur[x] - RUNval) <= state->near)){
 607                 run++;
 608                 cur[x] = Ra;
 609                 x += stride;
 610             }
 611             ls_encode_run(state, pb, run, comp, x < w);
 612             if(x >= w)
 613                 return;
 614             Rb = last[x];
 615             RItype = (FFABS(Ra - Rb) <= state->near);
 616             pred = RItype ? Ra : Rb;
 617             err = cur[x] - pred;
 618
 619             if(!RItype && Ra > Rb)
 620                 err = -err;
 621
 622             if(state->near){
 623                 if(err > 0)
 624                     err = (state->near + err) / state->twonear;
 625                 else
 626                     err = -(state->near - err) / state->twonear;
 627
 628                 if(RItype || (Rb >= Ra))
 629                     Ra = clip(pred + err * state->twonear, 0, state->maxval);
 630                 else
 631                     Ra = clip(pred - err * state->twonear, 0, state->maxval);
 632                 cur[x] = Ra;
 633             }
 634             if(err < 0)
 635                 err += state->range;
 636             if(err >= ((state->range + 1) >> 1))
 637                 err -= state->range;
 638
 639             ls_encode_runterm(state, pb, RItype, err, log2_run[state->run_index[comp]]);
 640
 641             if(state->run_index[comp] > 0)
 642                 state->run_index[comp]--;
 643             x += stride;
 644         } else { /* regular mode */
 645             int context;
 646
 647             context = quantize(state, D0) * 81 + quantize(state, D1) * 9 + quantize(state, D2);
 648             pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
 649
 650             if(context < 0){
 651                 context = -context;
 652                 sign = 1;
 653                 pred = clip(pred - state->C[context], 0, state->maxval);
 654                 err = pred - cur[x];
 655             }else{
 656                 sign = 0;
 657                 pred = clip(pred + state->C[context], 0, state->maxval);
 658                 err = cur[x] - pred;
 659             }
 660
 661             if(state->near){
 662                 if(err > 0)
 663                     err = (state->near + err) / state->twonear;
 664                 else
 665                     err = -(state->near - err) / state->twonear;
 666                 if(!sign)
 667                     Ra = clip(pred + err * state->twonear, 0, state->maxval);
 668                 else
 669                     Ra = clip(pred - err * state->twonear, 0, state->maxval);
 670                 cur[x] = Ra;
 671             }
 672
 673             ls_encode_regular(state, pb, context, err);
 674             x += stride;
 675         }
 676     }
 677 }
 678
 679 static void ls_store_lse(JLSState *state, PutBitContext *pb){
 680     /* Test if we have default params and don't need to store LSE */
 681     JLSState state2;
 682     memset(&state2, 0, sizeof(JLSState));
 683     state2.bpp = 8;
 684     state2.near = state->near;
 685     reset_ls_coding_parameters(&state2, 1);
 686     if(state->T1 == state2.T1 && state->T2 == state2.T2 && state->T3 == state2.T3 && state->reset == state2.reset)
 687         return;
 688     /* store LSE type 1 */
 689     put_marker(pb, LSE);
 690     put_bits(pb, 16, 13);
 691     put_bits(pb, 8,   1);
 692     put_bits(pb, 16, state->maxval);
 693     put_bits(pb, 16, state->T1);
 694     put_bits(pb, 16, state->T2);
 695     put_bits(pb, 16, state->T3);
 696     put_bits(pb, 16, state->reset);
 697 }
 698
 699 static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 700     JpeglsContext * const s = avctx->priv_data;
 701     AVFrame *pict = data;
 702     AVFrame * const p= (AVFrame*)&s->picture;
 703     const int near = avctx->prediction_method;
 704     PutBitContext pb, pb2;
 705     GetBitContext gb;
 706     uint8_t *buf2, *zero, *cur, *last;
 707     JLSState *state;
 708     int i, size;
 709     int comps;
 710
 711     buf2 = av_malloc(buf_size);
 712
 713     init_put_bits(&pb, buf, buf_size);
 714     init_put_bits(&pb2, buf2, buf_size);
 715
 716     *p = *pict;
 717     p->pict_type= FF_I_TYPE;
 718     p->key_frame= 1;
 719
 720     comps = (avctx->pix_fmt == PIX_FMT_GRAY8) ? 1 : 3;
 721
 722     /* write our own JPEG header, can't use mjpeg_picture_header */
 723     put_marker(&pb, SOI);
 724     put_marker(&pb, SOF48);
 725     put_bits(&pb, 16, 8 + comps * 3); // header size depends on components
 726     put_bits(&pb,  8, 8);             // bpp
 727     put_bits(&pb, 16, avctx->height);
 728     put_bits(&pb, 16, avctx->width);
 729     put_bits(&pb,  8, comps);         // components
 730     for(i = 1; i <= comps; i++) {
 731         put_bits(&pb,  8, i);    // component ID
 732         put_bits(&pb,  8, 0x11); // subsampling: none
 733         put_bits(&pb,  8, 0);    // Tiq, used by JPEG-LS ext
 734     }
 735
 736     put_marker(&pb, SOS);
 737     put_bits(&pb, 16, 6 + comps * 2);
 738     put_bits(&pb,  8, comps);
 739     for(i = 1; i <= comps; i++) {
 740         put_bits(&pb,  8, i);  // component ID
 741         put_bits(&pb,  8, 0);  // mapping index: none
 742     }
 743     put_bits(&pb,  8, near);
 744     put_bits(&pb,  8, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line
 745     put_bits(&pb,  8, 0); // point transform: none
 746
 747     state = av_mallocz(sizeof(JLSState));
 748     /* initialize JPEG-LS state from JPEG parameters */
 749     state->near = near;
 750     state->bpp = 8;
 751     reset_ls_coding_parameters(state, 0);
 752     ls_init_state(state);
 753
 754     ls_store_lse(state, &pb);
 755
 756     zero = av_mallocz(p->linesize[0]);
 757     last = zero;
 758     cur = p->data[0];
 759     if(avctx->pix_fmt == PIX_FMT_GRAY8){
 760         int t = 0;
 761
 762         for(i = 0; i < avctx->height; i++) {
 763             ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0);
 764             t = last[0];
 765             last = cur;
 766             cur += p->linesize[0];
 767         }
 768     }else if(avctx->pix_fmt == PIX_FMT_RGB24){
 769         int j, width;
 770         int Rc[3] = {0, 0, 0};
 771
 772         width = avctx->width * 3;
 773         for(i = 0; i < avctx->height; i++) {
 774             for(j = 0; j < 3; j++) {
 775                 ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j);
 776                 Rc[j] = last[j];
 777             }
 778             last = cur;
 779             cur += s->picture.linesize[0];
 780         }
 781     }else if(avctx->pix_fmt == PIX_FMT_BGR24){
 782         int j, width;
 783         int Rc[3] = {0, 0, 0};
 784
 785         width = avctx->width * 3;
 786         for(i = 0; i < avctx->height; i++) {
 787             for(j = 2; j >= 0; j--) {
 788                 ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j);
 789                 Rc[j] = last[j];
 790             }
 791             last = cur;
 792             cur += s->picture.linesize[0];
 793         }
 794     }
 795
 796     av_free(zero);
 797     av_free(state);
 798
 799     flush_put_bits(&pb2);
 800     /* do escape coding */
 801     size = put_bits_count(&pb2) >> 3;
 802     init_get_bits(&gb, buf2, size);
 803     while(get_bits_count(&gb) < size * 8){
 804         int v;
 805         v = get_bits(&gb, 8);
 806         put_bits(&pb, 8, v);
 807         if(v == 0xFF){
 808             v = get_bits(&gb, 7);
 809             put_bits(&pb, 8, v);
 810         }
 811     }
 812     align_put_bits(&pb);
 813     av_free(buf2);
 814
 815     /* End of image */
 816     put_marker(&pb, EOI);
 817     flush_put_bits(&pb);
 818
 819     emms_c();
 820
 821     return put_bits_count(&pb) >> 3;
 822 }
 823
 824 static int encode_init_ls(AVCodecContext *ctx) {
 825     JpeglsContext *c = (JpeglsContext*)ctx->priv_data;
 826
 827     c->avctx = ctx;
 828     ctx->coded_frame = &c->picture;
 829
 830     if(ctx->pix_fmt != PIX_FMT_GRAY8 && ctx->pix_fmt != PIX_FMT_RGB24 && ctx->pix_fmt != PIX_FMT_BGR24){
 831         av_log(ctx, AV_LOG_ERROR, "Only grayscale and RGB24/BGR24 images are supported\n");
 832         return -1;
 833     }
 834     return 0;
 835 }
 836
 837 AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
 838     "jpegls",
 839     CODEC_TYPE_VIDEO,
 840     CODEC_ID_JPEGLS,
 841     sizeof(JpeglsContext),
 842     encode_init_ls,
 843     encode_picture_ls,
 844     NULL,
 845     .pix_fmts= (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, -1},
 846 };
 847 #endif