00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "avcodec.h"
00029 #include "bitstream.h"
00030 #include "golomb.h"
00031 #include "dsputil.h"
00032 #include "mjpeg.h"
00033 #include "jpegls.h"
00034
00035
00039 static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, int err){
00040 int k;
00041 int val;
00042 int map;
00043
00044 for(k = 0; (state->N[Q] << k) < state->A[Q]; k++);
00045
00046 map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]);
00047
00048 if(err < 0)
00049 err += state->range;
00050 if(err >= ((state->range + 1) >> 1)) {
00051 err -= state->range;
00052 val = 2 * FFABS(err) - 1 - map;
00053 } else
00054 val = 2 * err + map;
00055
00056 set_ur_golomb_jpegls(pb, val, k, state->limit, state->qbpp);
00057
00058 ff_jpegls_update_state_regular(state, Q, err);
00059 }
00060
00064 static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RItype, int err, int limit_add){
00065 int k;
00066 int val, map;
00067 int Q = 365 + RItype;
00068 int temp;
00069
00070 temp = state->A[Q];
00071 if(RItype)
00072 temp += state->N[Q] >> 1;
00073 for(k = 0; (state->N[Q] << k) < temp; k++);
00074 map = 0;
00075 if(!k && err && (2 * state->B[Q] < state->N[Q]))
00076 map = 1;
00077
00078 if(err < 0)
00079 val = - (2 * err) - 1 - RItype + map;
00080 else
00081 val = 2 * err - RItype - map;
00082 set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
00083
00084 if(err < 0)
00085 state->B[Q]++;
00086 state->A[Q] += (val + 1 - RItype) >> 1;
00087
00088 ff_jpegls_downscale_state(state, Q);
00089 }
00090
00094 static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run, int comp, int trail){
00095 while(run >= (1 << ff_log2_run[state->run_index[comp]])){
00096 put_bits(pb, 1, 1);
00097 run -= 1 << ff_log2_run[state->run_index[comp]];
00098 if(state->run_index[comp] < 31)
00099 state->run_index[comp]++;
00100 }
00101
00102 if(!trail && run) {
00103 put_bits(pb, 1, 1);
00104 }else if(trail){
00105 put_bits(pb, 1, 0);
00106 if(ff_log2_run[state->run_index[comp]])
00107 put_bits(pb, ff_log2_run[state->run_index[comp]], run);
00108 }
00109 }
00110
00114 static inline void ls_encode_line(JLSState *state, PutBitContext *pb, void *last, void *cur, int last2, int w, int stride, int comp, int bits){
00115 int x = 0;
00116 int Ra, Rb, Rc, Rd;
00117 int D0, D1, D2;
00118
00119 while(x < w) {
00120 int err, pred, sign;
00121
00122
00123 Ra = x ? R(cur, x - stride) : R(last, x);
00124 Rb = R(last, x);
00125 Rc = x ? R(last, x - stride) : last2;
00126 Rd = (x >= w - stride) ? R(last, x) : R(last, x + stride);
00127 D0 = Rd - Rb;
00128 D1 = Rb - Rc;
00129 D2 = Rc - Ra;
00130
00131
00132 if((FFABS(D0) <= state->near) && (FFABS(D1) <= state->near) && (FFABS(D2) <= state->near)) {
00133 int RUNval, RItype, run;
00134
00135 run = 0;
00136 RUNval = Ra;
00137 while(x < w && (FFABS(R(cur, x) - RUNval) <= state->near)){
00138 run++;
00139 W(cur, x, Ra);
00140 x += stride;
00141 }
00142 ls_encode_run(state, pb, run, comp, x < w);
00143 if(x >= w)
00144 return;
00145 Rb = R(last, x);
00146 RItype = (FFABS(Ra - Rb) <= state->near);
00147 pred = RItype ? Ra : Rb;
00148 err = R(cur, x) - pred;
00149
00150 if(!RItype && Ra > Rb)
00151 err = -err;
00152
00153 if(state->near){
00154 if(err > 0)
00155 err = (state->near + err) / state->twonear;
00156 else
00157 err = -(state->near - err) / state->twonear;
00158
00159 if(RItype || (Rb >= Ra))
00160 Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
00161 else
00162 Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
00163 W(cur, x, Ra);
00164 }
00165 if(err < 0)
00166 err += state->range;
00167 if(err >= ((state->range + 1) >> 1))
00168 err -= state->range;
00169
00170 ls_encode_runterm(state, pb, RItype, err, ff_log2_run[state->run_index[comp]]);
00171
00172 if(state->run_index[comp] > 0)
00173 state->run_index[comp]--;
00174 } else {
00175 int context;
00176
00177 context = ff_jpegls_quantize(state, D0) * 81 + ff_jpegls_quantize(state, D1) * 9 + ff_jpegls_quantize(state, D2);
00178 pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
00179
00180 if(context < 0){
00181 context = -context;
00182 sign = 1;
00183 pred = av_clip(pred - state->C[context], 0, state->maxval);
00184 err = pred - R(cur, x);
00185 }else{
00186 sign = 0;
00187 pred = av_clip(pred + state->C[context], 0, state->maxval);
00188 err = R(cur, x) - pred;
00189 }
00190
00191 if(state->near){
00192 if(err > 0)
00193 err = (state->near + err) / state->twonear;
00194 else
00195 err = -(state->near - err) / state->twonear;
00196 if(!sign)
00197 Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
00198 else
00199 Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
00200 W(cur, x, Ra);
00201 }
00202
00203 ls_encode_regular(state, pb, context, err);
00204 }
00205 x += stride;
00206 }
00207 }
00208
00209 static void ls_store_lse(JLSState *state, PutBitContext *pb){
00210
00211 JLSState state2;
00212 memset(&state2, 0, sizeof(JLSState));
00213 state2.bpp = state->bpp;
00214 state2.near = state->near;
00215 ff_jpegls_reset_coding_parameters(&state2, 1);
00216 if(state->T1 == state2.T1 && state->T2 == state2.T2 && state->T3 == state2.T3 && state->reset == state2.reset)
00217 return;
00218
00219 put_marker(pb, LSE);
00220 put_bits(pb, 16, 13);
00221 put_bits(pb, 8, 1);
00222 put_bits(pb, 16, state->maxval);
00223 put_bits(pb, 16, state->T1);
00224 put_bits(pb, 16, state->T2);
00225 put_bits(pb, 16, state->T3);
00226 put_bits(pb, 16, state->reset);
00227 }
00228
00229 static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
00230 JpeglsContext * const s = avctx->priv_data;
00231 AVFrame *pict = data;
00232 AVFrame * const p= (AVFrame*)&s->picture;
00233 const int near = avctx->prediction_method;
00234 PutBitContext pb, pb2;
00235 GetBitContext gb;
00236 uint8_t *buf2, *zero, *cur, *last;
00237 JLSState *state;
00238 int i, size;
00239 int comps;
00240
00241 buf2 = av_malloc(buf_size);
00242
00243 init_put_bits(&pb, buf, buf_size);
00244 init_put_bits(&pb2, buf2, buf_size);
00245
00246 *p = *pict;
00247 p->pict_type= FF_I_TYPE;
00248 p->key_frame= 1;
00249
00250 if(avctx->pix_fmt == PIX_FMT_GRAY8 || avctx->pix_fmt == PIX_FMT_GRAY16)
00251 comps = 1;
00252 else
00253 comps = 3;
00254
00255
00256 put_marker(&pb, SOI);
00257 put_marker(&pb, SOF48);
00258 put_bits(&pb, 16, 8 + comps * 3);
00259 put_bits(&pb, 8, (avctx->pix_fmt == PIX_FMT_GRAY16) ? 16 : 8);
00260 put_bits(&pb, 16, avctx->height);
00261 put_bits(&pb, 16, avctx->width);
00262 put_bits(&pb, 8, comps);
00263 for(i = 1; i <= comps; i++) {
00264 put_bits(&pb, 8, i);
00265 put_bits(&pb, 8, 0x11);
00266 put_bits(&pb, 8, 0);
00267 }
00268
00269 put_marker(&pb, SOS);
00270 put_bits(&pb, 16, 6 + comps * 2);
00271 put_bits(&pb, 8, comps);
00272 for(i = 1; i <= comps; i++) {
00273 put_bits(&pb, 8, i);
00274 put_bits(&pb, 8, 0);
00275 }
00276 put_bits(&pb, 8, near);
00277 put_bits(&pb, 8, (comps > 1) ? 1 : 0);
00278 put_bits(&pb, 8, 0);
00279
00280 state = av_mallocz(sizeof(JLSState));
00281
00282 state->near = near;
00283 state->bpp = (avctx->pix_fmt == PIX_FMT_GRAY16) ? 16 : 8;
00284 ff_jpegls_reset_coding_parameters(state, 0);
00285 ff_jpegls_init_state(state);
00286
00287 ls_store_lse(state, &pb);
00288
00289 zero = av_mallocz(p->linesize[0]);
00290 last = zero;
00291 cur = p->data[0];
00292 if(avctx->pix_fmt == PIX_FMT_GRAY8){
00293 int t = 0;
00294
00295 for(i = 0; i < avctx->height; i++) {
00296 ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 8);
00297 t = last[0];
00298 last = cur;
00299 cur += p->linesize[0];
00300 }
00301 }else if(avctx->pix_fmt == PIX_FMT_GRAY16){
00302 int t = 0;
00303
00304 for(i = 0; i < avctx->height; i++) {
00305 ls_encode_line(state, &pb2, last, cur, t, avctx->width, 1, 0, 16);
00306 t = *((uint16_t*)last);
00307 last = cur;
00308 cur += p->linesize[0];
00309 }
00310 }else if(avctx->pix_fmt == PIX_FMT_RGB24){
00311 int j, width;
00312 int Rc[3] = {0, 0, 0};
00313
00314 width = avctx->width * 3;
00315 for(i = 0; i < avctx->height; i++) {
00316 for(j = 0; j < 3; j++) {
00317 ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8);
00318 Rc[j] = last[j];
00319 }
00320 last = cur;
00321 cur += s->picture.linesize[0];
00322 }
00323 }else if(avctx->pix_fmt == PIX_FMT_BGR24){
00324 int j, width;
00325 int Rc[3] = {0, 0, 0};
00326
00327 width = avctx->width * 3;
00328 for(i = 0; i < avctx->height; i++) {
00329 for(j = 2; j >= 0; j--) {
00330 ls_encode_line(state, &pb2, last + j, cur + j, Rc[j], width, 3, j, 8);
00331 Rc[j] = last[j];
00332 }
00333 last = cur;
00334 cur += s->picture.linesize[0];
00335 }
00336 }
00337
00338 av_free(zero);
00339 av_free(state);
00340
00341
00342
00343
00344 put_bits(&pb2, 7, 0);
00345 size = put_bits_count(&pb2);
00346 flush_put_bits(&pb2);
00347
00348 init_get_bits(&gb, buf2, size);
00349 size -= 7;
00350 while(get_bits_count(&gb) < size){
00351 int v;
00352 v = get_bits(&gb, 8);
00353 put_bits(&pb, 8, v);
00354 if(v == 0xFF){
00355 v = get_bits(&gb, 7);
00356 put_bits(&pb, 8, v);
00357 }
00358 }
00359 align_put_bits(&pb);
00360 av_free(buf2);
00361
00362
00363 put_marker(&pb, EOI);
00364 flush_put_bits(&pb);
00365
00366 emms_c();
00367
00368 return put_bits_count(&pb) >> 3;
00369 }
00370
00371 static int encode_init_ls(AVCodecContext *ctx) {
00372 JpeglsContext *c = (JpeglsContext*)ctx->priv_data;
00373
00374 c->avctx = ctx;
00375 ctx->coded_frame = &c->picture;
00376
00377 if(ctx->pix_fmt != PIX_FMT_GRAY8 && ctx->pix_fmt != PIX_FMT_GRAY16 && ctx->pix_fmt != PIX_FMT_RGB24 && ctx->pix_fmt != PIX_FMT_BGR24){
00378 av_log(ctx, AV_LOG_ERROR, "Only grayscale and RGB24/BGR24 images are supported\n");
00379 return -1;
00380 }
00381 return 0;
00382 }
00383
00384 AVCodec jpegls_encoder = {
00385 "jpegls",
00386 CODEC_TYPE_VIDEO,
00387 CODEC_ID_JPEGLS,
00388 sizeof(JpeglsContext),
00389 encode_init_ls,
00390 encode_picture_ls,
00391 NULL,
00392 .pix_fmts= (enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, -1},
00393 };