« back to all changes in this revision
Viewing changes to ffmpeg/libavcodec/mjpeg.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Christian Marillat
- Date: 2004-08-29 10:53:42 UTC
- Revision ID: james.westby@ubuntu.com-20040829105342-qgmnry37eadfkoxx
Tags: upstream-1.1.3
Import upstream version 1.1.3
- files added:
- Xw
- ffmpeg
- ffmpeg/doc
- ffmpeg/libavcodec
- ffmpeg/libavcodec/alpha
- ffmpeg/libavcodec/armv4l
- ffmpeg/libavcodec/i386
- ffmpeg/libavcodec/liba52
- ffmpeg/libavcodec/libpostproc
- ffmpeg/libavcodec/mlib
- ffmpeg/libavcodec/ppc
- ffmpeg/libavcodec/ps2
- ffmpeg/libavcodec/sh4
- ffmpeg/libavformat
- ffmpeg/tests
- ffmpeg/vhook
- getopt
- gt
- man
- src
- xbm
added
removed
ffmpeg/libavcodec/mjpeg.c
1
/*
2
* MJPEG encoder and decoder
3
* Copyright (c) 2000, 2001 Fabrice Bellard.
4
*
5
* This library is free software; you can redistribute it and/or
6
* modify it under the terms of the GNU Lesser General Public
7
* License as published by the Free Software Foundation; either
8
* version 2 of the License, or (at your option) any later version.
9
*
10
* This library is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
* Lesser General Public License for more details.
14
*
15
* You should have received a copy of the GNU Lesser General Public
16
* License along with this library; if not, write to the Free Software
17
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
*
19
* Support for external huffman table, various fixes (AVID workaround),
20
* aspecting, new decode_frame mechanism and apple mjpeg-b support
21
* by Alex Beregszaszi <alex@naxine.org>
22
*/
23
24
/**
25
* @file mjpeg.c
26
* MJPEG encoder and decoder.
27
*/
28
29
//#define DEBUG
30
#include <assert.h>
31
32
#include "avcodec.h"
33
#include "dsputil.h"
34
#include "mpegvideo.h"
35
36
/* use two quantizer tables (one for luminance and one for chrominance) */
37
/* not yet working */
38
#undef TWOMATRIXES
39
40
typedef struct MJpegContext {
41
uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
42
uint16_t huff_code_dc_luminance[12];
43
uint8_t huff_size_dc_chrominance[12];
44
uint16_t huff_code_dc_chrominance[12];
45
46
uint8_t huff_size_ac_luminance[256];
47
uint16_t huff_code_ac_luminance[256];
48
uint8_t huff_size_ac_chrominance[256];
49
uint16_t huff_code_ac_chrominance[256];
50
} MJpegContext;
51
52
/* JPEG marker codes */
53
typedef enum {
54
/* start of frame */
55
SOF0 = 0xc0, /* baseline */
56
SOF1 = 0xc1, /* extended sequential, huffman */
57
SOF2 = 0xc2, /* progressive, huffman */
58
SOF3 = 0xc3, /* lossless, huffman */
59
60
SOF5 = 0xc5, /* differential sequential, huffman */
61
SOF6 = 0xc6, /* differential progressive, huffman */
62
SOF7 = 0xc7, /* differential lossless, huffman */
63
JPG = 0xc8, /* reserved for JPEG extension */
64
SOF9 = 0xc9, /* extended sequential, arithmetic */
65
SOF10 = 0xca, /* progressive, arithmetic */
66
SOF11 = 0xcb, /* lossless, arithmetic */
67
68
SOF13 = 0xcd, /* differential sequential, arithmetic */
69
SOF14 = 0xce, /* differential progressive, arithmetic */
70
SOF15 = 0xcf, /* differential lossless, arithmetic */
71
72
DHT = 0xc4, /* define huffman tables */
73
74
DAC = 0xcc, /* define arithmetic-coding conditioning */
75
76
/* restart with modulo 8 count "m" */
77
RST0 = 0xd0,
78
RST1 = 0xd1,
79
RST2 = 0xd2,
80
RST3 = 0xd3,
81
RST4 = 0xd4,
82
RST5 = 0xd5,
83
RST6 = 0xd6,
84
RST7 = 0xd7,
85
86
SOI = 0xd8, /* start of image */
87
EOI = 0xd9, /* end of image */
88
SOS = 0xda, /* start of scan */
89
DQT = 0xdb, /* define quantization tables */
90
DNL = 0xdc, /* define number of lines */
91
DRI = 0xdd, /* define restart interval */
92
DHP = 0xde, /* define hierarchical progression */
93
EXP = 0xdf, /* expand reference components */
94
95
APP0 = 0xe0,
96
APP1 = 0xe1,
97
APP2 = 0xe2,
98
APP3 = 0xe3,
99
APP4 = 0xe4,
100
APP5 = 0xe5,
101
APP6 = 0xe6,
102
APP7 = 0xe7,
103
APP8 = 0xe8,
104
APP9 = 0xe9,
105
APP10 = 0xea,
106
APP11 = 0xeb,
107
APP12 = 0xec,
108
APP13 = 0xed,
109
APP14 = 0xee,
110
APP15 = 0xef,
111
112
JPG0 = 0xf0,
113
JPG1 = 0xf1,
114
JPG2 = 0xf2,
115
JPG3 = 0xf3,
116
JPG4 = 0xf4,
117
JPG5 = 0xf5,
118
JPG6 = 0xf6,
119
JPG7 = 0xf7,
120
JPG8 = 0xf8,
121
JPG9 = 0xf9,
122
JPG10 = 0xfa,
123
JPG11 = 0xfb,
124
JPG12 = 0xfc,
125
JPG13 = 0xfd,
126
127
COM = 0xfe, /* comment */
128
129
TEM = 0x01, /* temporary private use for arithmetic coding */
130
131
/* 0x02 -> 0xbf reserved */
132
} JPEG_MARKER;
133
134
#if 0
135
/* These are the sample quantization tables given in JPEG spec section K.1.
136
* The spec says that the values given produce "good" quality, and
137
* when divided by 2, "very good" quality.
138
*/
139
static const unsigned char std_luminance_quant_tbl[64] = {
140
16, 11, 10, 16, 24, 40, 51, 61,
141
12, 12, 14, 19, 26, 58, 60, 55,
142
14, 13, 16, 24, 40, 57, 69, 56,
143
14, 17, 22, 29, 51, 87, 80, 62,
144
18, 22, 37, 56, 68, 109, 103, 77,
145
24, 35, 55, 64, 81, 104, 113, 92,
146
49, 64, 78, 87, 103, 121, 120, 101,
147
72, 92, 95, 98, 112, 100, 103, 99
148
};
149
static const unsigned char std_chrominance_quant_tbl[64] = {
150
17, 18, 24, 47, 99, 99, 99, 99,
151
18, 21, 26, 66, 99, 99, 99, 99,
152
24, 26, 56, 99, 99, 99, 99, 99,
153
47, 66, 99, 99, 99, 99, 99, 99,
154
99, 99, 99, 99, 99, 99, 99, 99,
155
99, 99, 99, 99, 99, 99, 99, 99,
156
99, 99, 99, 99, 99, 99, 99, 99,
157
99, 99, 99, 99, 99, 99, 99, 99
158
};
159
#endif
160
161
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
162
/* IMPORTANT: these are only valid for 8-bit data precision! */
163
static const uint8_t bits_dc_luminance[17] =
164
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
165
static const uint8_t val_dc_luminance[] =
166
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
167
168
static const uint8_t bits_dc_chrominance[17] =
169
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170
static const uint8_t val_dc_chrominance[] =
171
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172
173
static const uint8_t bits_ac_luminance[17] =
174
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
175
static const uint8_t val_ac_luminance[] =
176
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
177
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
178
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
179
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
180
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
181
0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
182
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
183
0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
184
0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
185
0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
186
0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
187
0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
188
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
189
0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
190
0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
191
0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
192
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
193
0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
194
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
195
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
196
0xf9, 0xfa
197
};
198
199
static const uint8_t bits_ac_chrominance[17] =
200
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
201
202
static const uint8_t val_ac_chrominance[] =
203
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
204
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
205
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
206
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
207
0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
208
0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
209
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
210
0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
211
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
212
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
213
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
214
0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
215
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
216
0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
217
0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
218
0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
219
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
220
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
221
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
222
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223
0xf9, 0xfa
224
};
225
226
/* isn't this function nicer than the one in the libjpeg ? */
227
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
228
const uint8_t *bits_table, const uint8_t *val_table)
229
{
230
int i, j, k,nb, code, sym;
231
232
code = 0;
233
k = 0;
234
for(i=1;i<=16;i++) {
235
nb = bits_table[i];
236
for(j=0;j<nb;j++) {
237
sym = val_table[k++];
238
huff_size[sym] = i;
239
huff_code[sym] = code;
240
code++;
241
}
242
code <<= 1;
243
}
244
}
245
246
int mjpeg_init(MpegEncContext *s)
247
{
248
MJpegContext *m;
249
250
m = av_malloc(sizeof(MJpegContext));
251
if (!m)
252
return -1;
253
254
s->min_qcoeff=-1023;
255
s->max_qcoeff= 1023;
256
257
/* build all the huffman tables */
258
build_huffman_codes(m->huff_size_dc_luminance,
259
m->huff_code_dc_luminance,
260
bits_dc_luminance,
261
val_dc_luminance);
262
build_huffman_codes(m->huff_size_dc_chrominance,
263
m->huff_code_dc_chrominance,
264
bits_dc_chrominance,
265
val_dc_chrominance);
266
build_huffman_codes(m->huff_size_ac_luminance,
267
m->huff_code_ac_luminance,
268
bits_ac_luminance,
269
val_ac_luminance);
270
build_huffman_codes(m->huff_size_ac_chrominance,
271
m->huff_code_ac_chrominance,
272
bits_ac_chrominance,
273
val_ac_chrominance);
274
275
s->mjpeg_ctx = m;
276
return 0;
277
}
278
279
void mjpeg_close(MpegEncContext *s)
280
{
281
av_free(s->mjpeg_ctx);
282
}
283
284
#define PREDICT(ret, topleft, top, left, predictor)\
285
switch(predictor){\
286
case 1: ret= left; break;\
287
case 2: ret= top; break;\
288
case 3: ret= topleft; break;\
289
case 4: ret= left + top - topleft; break;\
290
case 5: ret= left + ((top - topleft)>>1); break;\
291
case 6: ret= top + ((left - topleft)>>1); break;\
292
default:\
293
case 7: ret= (left + top)>>1; break;\
294
}
295
296
#ifdef CONFIG_ENCODERS
297
static inline void put_marker(PutBitContext *p, int code)
298
{
299
put_bits(p, 8, 0xff);
300
put_bits(p, 8, code);
301
}
302
303
/* table_class: 0 = DC coef, 1 = AC coefs */
304
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
305
const uint8_t *bits_table, const uint8_t *value_table)
306
{
307
PutBitContext *p = &s->pb;
308
int n, i;
309
310
put_bits(p, 4, table_class);
311
put_bits(p, 4, table_id);
312
313
n = 0;
314
for(i=1;i<=16;i++) {
315
n += bits_table[i];
316
put_bits(p, 8, bits_table[i]);
317
}
318
319
for(i=0;i<n;i++)
320
put_bits(p, 8, value_table[i]);
321
322
return n + 17;
323
}
324
325
static void jpeg_table_header(MpegEncContext *s)
326
{
327
PutBitContext *p = &s->pb;
328
int i, j, size;
329
uint8_t *ptr;
330
331
/* quant matrixes */
332
put_marker(p, DQT);
333
#ifdef TWOMATRIXES
334
put_bits(p, 16, 2 + 2 * (1 + 64));
335
#else
336
put_bits(p, 16, 2 + 1 * (1 + 64));
337
#endif
338
put_bits(p, 4, 0); /* 8 bit precision */
339
put_bits(p, 4, 0); /* table 0 */
340
for(i=0;i<64;i++) {
341
j = s->intra_scantable.permutated[i];
342
put_bits(p, 8, s->intra_matrix[j]);
343
}
344
#ifdef TWOMATRIXES
345
put_bits(p, 4, 0); /* 8 bit precision */
346
put_bits(p, 4, 1); /* table 1 */
347
for(i=0;i<64;i++) {
348
j = s->intra_scantable.permutated[i];
349
put_bits(p, 8, s->chroma_intra_matrix[j]);
350
}
351
#endif
352
353
/* huffman table */
354
put_marker(p, DHT);
355
flush_put_bits(p);
356
ptr = pbBufPtr(p);
357
put_bits(p, 16, 0); /* patched later */
358
size = 2;
359
size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
360
size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
361
362
size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
363
size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
364
ptr[0] = size >> 8;
365
ptr[1] = size;
366
}
367
368
static void jpeg_put_comments(MpegEncContext *s)
369
{
370
PutBitContext *p = &s->pb;
371
int size;
372
uint8_t *ptr;
373
374
if (s->aspect_ratio_info /* && !lossless */)
375
{
376
/* JFIF header */
377
put_marker(p, APP0);
378
put_bits(p, 16, 16);
379
put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
380
put_bits(p, 16, 0x0201); /* v 1.02 */
381
put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
382
switch(s->aspect_ratio_info)
383
{
384
case FF_ASPECT_4_3_625:
385
case FF_ASPECT_4_3_525:
386
put_bits(p, 16, 4);
387
put_bits(p, 16, 3);
388
break;
389
case FF_ASPECT_16_9_625:
390
case FF_ASPECT_16_9_525:
391
put_bits(p, 16, 16);
392
put_bits(p, 16, 9);
393
break;
394
case FF_ASPECT_EXTENDED:
395
put_bits(p, 16, s->aspected_width);
396
put_bits(p, 16, s->aspected_height);
397
break;
398
case FF_ASPECT_SQUARE:
399
default:
400
put_bits(p, 16, 1); /* aspect: 1:1 */
401
put_bits(p, 16, 1);
402
break;
403
}
404
put_bits(p, 8, 0); /* thumbnail width */
405
put_bits(p, 8, 0); /* thumbnail height */
406
}
407
408
/* comment */
409
if(!(s->flags & CODEC_FLAG_BITEXACT)){
410
put_marker(p, COM);
411
flush_put_bits(p);
412
ptr = pbBufPtr(p);
413
put_bits(p, 16, 0); /* patched later */
414
put_string(p, LIBAVCODEC_IDENT);
415
size = strlen(LIBAVCODEC_IDENT)+3;
416
ptr[0] = size >> 8;
417
ptr[1] = size;
418
}
419
}
420
421
void mjpeg_picture_header(MpegEncContext *s)
422
{
423
const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
424
425
put_marker(&s->pb, SOI);
426
427
if (!s->mjpeg_data_only_frames)
428
{
429
jpeg_put_comments(s);
430
431
if (s->mjpeg_write_tables) jpeg_table_header(s);
432
433
put_marker(&s->pb, lossless ? SOF3 : SOF0);
434
435
put_bits(&s->pb, 16, 17);
436
if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
437
put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
438
else
439
put_bits(&s->pb, 8, 8); /* 8 bits/component */
440
put_bits(&s->pb, 16, s->height);
441
put_bits(&s->pb, 16, s->width);
442
put_bits(&s->pb, 8, 3); /* 3 components */
443
444
/* Y component */
445
put_bits(&s->pb, 8, 1); /* component number */
446
put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
447
put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
448
put_bits(&s->pb, 8, 0); /* select matrix */
449
450
/* Cb component */
451
put_bits(&s->pb, 8, 2); /* component number */
452
put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
453
put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
454
#ifdef TWOMATRIXES
455
put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
456
#else
457
put_bits(&s->pb, 8, 0); /* select matrix */
458
#endif
459
460
/* Cr component */
461
put_bits(&s->pb, 8, 3); /* component number */
462
put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
463
put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
464
#ifdef TWOMATRIXES
465
put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
466
#else
467
put_bits(&s->pb, 8, 0); /* select matrix */
468
#endif
469
}
470
471
/* scan header */
472
put_marker(&s->pb, SOS);
473
put_bits(&s->pb, 16, 12); /* length */
474
put_bits(&s->pb, 8, 3); /* 3 components */
475
476
/* Y component */
477
put_bits(&s->pb, 8, 1); /* index */
478
put_bits(&s->pb, 4, 0); /* DC huffman table index */
479
put_bits(&s->pb, 4, 0); /* AC huffman table index */
480
481
/* Cb component */
482
put_bits(&s->pb, 8, 2); /* index */
483
put_bits(&s->pb, 4, 1); /* DC huffman table index */
484
put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
485
486
/* Cr component */
487
put_bits(&s->pb, 8, 3); /* index */
488
put_bits(&s->pb, 4, 1); /* DC huffman table index */
489
put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
490
491
put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
492
put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
493
put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
494
}
495
496
static void escape_FF(MpegEncContext *s, int start)
497
{
498
int size= get_bit_count(&s->pb) - start*8;
499
int i, ff_count;
500
uint8_t *buf= s->pb.buf + start;
501
int align= (-(size_t)(buf))&3;
502
503
assert((size&7) == 0);
504
size >>= 3;
505
506
ff_count=0;
507
for(i=0; i<size && i<align; i++){
508
if(buf[i]==0xFF) ff_count++;
509
}
510
for(; i<size-15; i+=16){
511
int acc, v;
512
513
v= *(uint32_t*)(&buf[i]);
514
acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
515
v= *(uint32_t*)(&buf[i+4]);
516
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517
v= *(uint32_t*)(&buf[i+8]);
518
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519
v= *(uint32_t*)(&buf[i+12]);
520
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
521
522
acc>>=4;
523
acc+= (acc>>16);
524
acc+= (acc>>8);
525
ff_count+= acc&0xFF;
526
}
527
for(; i<size; i++){
528
if(buf[i]==0xFF) ff_count++;
529
}
530
531
if(ff_count==0) return;
532
533
/* skip put bits */
534
for(i=0; i<ff_count-3; i+=4)
535
put_bits(&s->pb, 32, 0);
536
put_bits(&s->pb, (ff_count-i)*8, 0);
537
flush_put_bits(&s->pb);
538
539
for(i=size-1; ff_count; i--){
540
int v= buf[i];
541
542
if(v==0xFF){
543
//printf("%d %d\n", i, ff_count);
544
buf[i+ff_count]= 0;
545
ff_count--;
546
}
547
548
buf[i+ff_count]= v;
549
}
550
}
551
552
void mjpeg_picture_trailer(MpegEncContext *s)
553
{
554
int pad= (-get_bit_count(&s->pb))&7;
555
556
put_bits(&s->pb, pad,0xFF>>(8-pad));
557
flush_put_bits(&s->pb);
558
559
assert((s->header_bits&7)==0);
560
561
escape_FF(s, s->header_bits>>3);
562
563
put_marker(&s->pb, EOI);
564
}
565
566
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
567
uint8_t *huff_size, uint16_t *huff_code)
568
{
569
int mant, nbits;
570
571
if (val == 0) {
572
put_bits(&s->pb, huff_size[0], huff_code[0]);
573
} else {
574
mant = val;
575
if (val < 0) {
576
val = -val;
577
mant--;
578
}
579
580
nbits= av_log2_16bit(val) + 1;
581
582
put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
583
584
put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
585
}
586
}
587
588
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
589
{
590
int mant, nbits, code, i, j;
591
int component, dc, run, last_index, val;
592
MJpegContext *m = s->mjpeg_ctx;
593
uint8_t *huff_size_ac;
594
uint16_t *huff_code_ac;
595
596
/* DC coef */
597
component = (n <= 3 ? 0 : n - 4 + 1);
598
dc = block[0]; /* overflow is impossible */
599
val = dc - s->last_dc[component];
600
if (n < 4) {
601
mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
602
huff_size_ac = m->huff_size_ac_luminance;
603
huff_code_ac = m->huff_code_ac_luminance;
604
} else {
605
mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
606
huff_size_ac = m->huff_size_ac_chrominance;
607
huff_code_ac = m->huff_code_ac_chrominance;
608
}
609
s->last_dc[component] = dc;
610
611
/* AC coefs */
612
613
run = 0;
614
last_index = s->block_last_index[n];
615
for(i=1;i<=last_index;i++) {
616
j = s->intra_scantable.permutated[i];
617
val = block[j];
618
if (val == 0) {
619
run++;
620
} else {
621
while (run >= 16) {
622
put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
623
run -= 16;
624
}
625
mant = val;
626
if (val < 0) {
627
val = -val;
628
mant--;
629
}
630
631
nbits= av_log2(val) + 1;
632
code = (run << 4) | nbits;
633
634
put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
635
636
put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
637
run = 0;
638
}
639
}
640
641
/* output EOB only if not already 64 values */
642
if (last_index < 63 || run != 0)
643
put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
644
}
645
646
void mjpeg_encode_mb(MpegEncContext *s,
647
DCTELEM block[6][64])
648
{
649
int i;
650
for(i=0;i<6;i++) {
651
encode_block(s, block[i], i);
652
}
653
}
654
655
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
656
MpegEncContext * const s = avctx->priv_data;
657
MJpegContext * const m = s->mjpeg_ctx;
658
AVFrame *pict = data;
659
const int width= s->width;
660
const int height= s->height;
661
AVFrame * const p= (AVFrame*)&s->current_picture;
662
const int predictor= avctx->prediction_method+1;
663
664
init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
665
666
*p = *pict;
667
p->pict_type= FF_I_TYPE;
668
p->key_frame= 1;
669
670
mjpeg_picture_header(s);
671
672
s->header_bits= get_bit_count(&s->pb);
673
674
if(avctx->pix_fmt == PIX_FMT_RGBA32){
675
int x, y, i;
676
const int linesize= p->linesize[0];
677
uint16_t buffer[2048][4];
678
int left[3], top[3], topleft[3];
679
680
for(i=0; i<3; i++){
681
buffer[0][i]= 1 << (9 - 1);
682
}
683
684
for(y = 0; y < height; y++) {
685
const int modified_predictor= y ? predictor : 1;
686
uint8_t *ptr = p->data[0] + (linesize * y);
687
688
for(i=0; i<3; i++){
689
top[i]= left[i]= topleft[i]= buffer[0][i];
690
}
691
for(x = 0; x < width; x++) {
692
buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
693
buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
694
buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
695
696
for(i=0;i<3;i++) {
697
int pred, diff;
698
699
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
700
701
topleft[i]= top[i];
702
top[i]= buffer[x+1][i];
703
704
left[i]= buffer[x][i];
705
706
diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
707
708
if(i==0)
709
mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
710
else
711
mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
712
}
713
}
714
}
715
}else{
716
int mb_x, mb_y, i;
717
const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
718
const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
719
720
for(mb_y = 0; mb_y < mb_height; mb_y++) {
721
for(mb_x = 0; mb_x < mb_width; mb_x++) {
722
if(mb_x==0 || mb_y==0){
723
for(i=0;i<3;i++) {
724
uint8_t *ptr;
725
int x, y, h, v, linesize;
726
h = s->mjpeg_hsample[i];
727
v = s->mjpeg_vsample[i];
728
linesize= p->linesize[i];
729
730
for(y=0; y<v; y++){
731
for(x=0; x<h; x++){
732
int pred;
733
734
ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
735
if(y==0 && mb_y==0){
736
if(x==0 && mb_x==0){
737
pred= 128;
738
}else{
739
pred= ptr[-1];
740
}
741
}else{
742
if(x==0 && mb_x==0){
743
pred= ptr[-linesize];
744
}else{
745
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
746
}
747
}
748
749
if(i==0)
750
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
751
else
752
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
753
}
754
}
755
}
756
}else{
757
for(i=0;i<3;i++) {
758
uint8_t *ptr;
759
int x, y, h, v, linesize;
760
h = s->mjpeg_hsample[i];
761
v = s->mjpeg_vsample[i];
762
linesize= p->linesize[i];
763
764
for(y=0; y<v; y++){
765
for(x=0; x<h; x++){
766
int pred;
767
768
ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
769
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
770
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
771
772
if(i==0)
773
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
774
else
775
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
776
}
777
}
778
}
779
}
780
}
781
}
782
}
783
784
emms_c();
785
786
mjpeg_picture_trailer(s);
787
s->picture_number++;
788
789
flush_put_bits(&s->pb);
790
return pbBufPtr(&s->pb) - s->pb.buf;
791
// return (get_bit_count(&f->pb)+7)/8;
792
}
793
794
#endif //CONFIG_ENCODERS
795
796
/******************************************/
797
/* decoding */
798
799
#define MAX_COMPONENTS 4
800
801
typedef struct MJpegDecodeContext {
802
AVCodecContext *avctx;
803
GetBitContext gb;
804
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
805
806
int start_code; /* current start code */
807
int buffer_size;
808
uint8_t *buffer;
809
810
int16_t quant_matrixes[4][64];
811
VLC vlcs[2][4];
812
int qscale[4]; ///< quantizer scale calculated from quant_matrixes
813
814
int org_width, org_height; /* size given at codec init */
815
int first_picture; /* true if decoding first picture */
816
int interlaced; /* true if interlaced */
817
int bottom_field; /* true if bottom field */
818
int lossless;
819
int rgb;
820
int rct; /* standard rct */
821
int pegasus_rct; /* pegasus reversible colorspace transform */
822
int bits; /* bits per component */
823
824
int width, height;
825
int mb_width, mb_height;
826
int nb_components;
827
int component_id[MAX_COMPONENTS];
828
int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
829
int v_count[MAX_COMPONENTS];
830
int comp_index[MAX_COMPONENTS];
831
int dc_index[MAX_COMPONENTS];
832
int ac_index[MAX_COMPONENTS];
833
int nb_blocks[MAX_COMPONENTS];
834
int h_scount[MAX_COMPONENTS];
835
int v_scount[MAX_COMPONENTS];
836
int h_max, v_max; /* maximum h and v counts */
837
int quant_index[4]; /* quant table index for each component */
838
int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
839
uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
840
int linesize[MAX_COMPONENTS];
841
uint8_t *qscale_table;
842
DCTELEM block[64] __align8;
843
ScanTable scantable;
844
void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
845
846
int restart_interval;
847
int restart_count;
848
849
int buggy_avid;
850
int interlace_polarity;
851
} MJpegDecodeContext;
852
853
static int mjpeg_decode_dht(MJpegDecodeContext *s);
854
855
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
856
int nb_codes)
857
{
858
uint8_t huff_size[256];
859
uint16_t huff_code[256];
860
861
memset(huff_size, 0, sizeof(huff_size));
862
build_huffman_codes(huff_size, huff_code, bits_table, val_table);
863
864
return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
865
}
866
867
static int mjpeg_decode_init(AVCodecContext *avctx)
868
{
869
MJpegDecodeContext *s = avctx->priv_data;
870
MpegEncContext s2;
871
872
s->avctx = avctx;
873
874
/* ugly way to get the idct & scantable FIXME */
875
memset(&s2, 0, sizeof(MpegEncContext));
876
s2.flags= avctx->flags;
877
s2.avctx= avctx;
878
// s2->out_format = FMT_MJPEG;
879
s2.width = 8;
880
s2.height = 8;
881
if (MPV_common_init(&s2) < 0)
882
return -1;
883
s->scantable= s2.intra_scantable;
884
s->idct_put= s2.dsp.idct_put;
885
MPV_common_end(&s2);
886
887
s->mpeg_enc_ctx_allocated = 0;
888
s->buffer_size = 102400; /* smaller buffer should be enough,
889
but photojpg files could ahive bigger sizes */
890
s->buffer = av_malloc(s->buffer_size);
891
if (!s->buffer)
892
return -1;
893
s->start_code = -1;
894
s->first_picture = 1;
895
s->org_width = avctx->width;
896
s->org_height = avctx->height;
897
898
build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
899
build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
900
build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
901
build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
902
903
if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
904
{
905
printf("mjpeg: using external huffman table\n");
906
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
907
mjpeg_decode_dht(s);
908
/* should check for error - but dunno */
909
}
910
911
return 0;
912
}
913
914
/* quantize tables */
915
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
916
{
917
int len, index, i, j;
918
919
len = get_bits(&s->gb, 16) - 2;
920
921
while (len >= 65) {
922
/* only 8 bit precision handled */
923
if (get_bits(&s->gb, 4) != 0)
924
{
925
dprintf("dqt: 16bit precision\n");
926
return -1;
927
}
928
index = get_bits(&s->gb, 4);
929
if (index >= 4)
930
return -1;
931
dprintf("index=%d\n", index);
932
/* read quant table */
933
for(i=0;i<64;i++) {
934
j = s->scantable.permutated[i];
935
s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
936
}
937
938
//XXX FIXME finetune, and perhaps add dc too
939
s->qscale[index]= FFMAX(
940
s->quant_matrixes[index][s->scantable.permutated[1]],
941
s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
942
len -= 65;
943
}
944
945
return 0;
946
}
947
948
/* decode huffman tables and build VLC decoders */
949
static int mjpeg_decode_dht(MJpegDecodeContext *s)
950
{
951
int len, index, i, class, n, v, code_max;
952
uint8_t bits_table[17];
953
uint8_t val_table[256];
954
955
len = get_bits(&s->gb, 16) - 2;
956
957
while (len > 0) {
958
if (len < 17)
959
return -1;
960
class = get_bits(&s->gb, 4);
961
if (class >= 2)
962
return -1;
963
index = get_bits(&s->gb, 4);
964
if (index >= 4)
965
return -1;
966
n = 0;
967
for(i=1;i<=16;i++) {
968
bits_table[i] = get_bits(&s->gb, 8);
969
n += bits_table[i];
970
}
971
len -= 17;
972
if (len < n || n > 256)
973
return -1;
974
975
code_max = 0;
976
for(i=0;i<n;i++) {
977
v = get_bits(&s->gb, 8);
978
if (v > code_max)
979
code_max = v;
980
val_table[i] = v;
981
}
982
len -= n;
983
984
/* build VLC and flush previous vlc if present */
985
free_vlc(&s->vlcs[class][index]);
986
dprintf("class=%d index=%d nb_codes=%d\n",
987
class, index, code_max + 1);
988
if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
989
return -1;
990
}
991
}
992
return 0;
993
}
994
995
static int mjpeg_decode_sof(MJpegDecodeContext *s)
996
{
997
int len, nb_components, i, width, height;
998
999
/* XXX: verify len field validity */
1000
len = get_bits(&s->gb, 16);
1001
s->bits= get_bits(&s->gb, 8);
1002
1003
if(s->pegasus_rct) s->bits=9;
1004
if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1005
1006
if (s->bits != 8 && !s->lossless){
1007
printf("only 8 bits/component accepted\n");
1008
return -1;
1009
}
1010
height = get_bits(&s->gb, 16);
1011
width = get_bits(&s->gb, 16);
1012
dprintf("sof0: picture: %dx%d\n", width, height);
1013
1014
nb_components = get_bits(&s->gb, 8);
1015
if (nb_components <= 0 ||
1016
nb_components > MAX_COMPONENTS)
1017
return -1;
1018
s->nb_components = nb_components;
1019
s->h_max = 1;
1020
s->v_max = 1;
1021
for(i=0;i<nb_components;i++) {
1022
/* component id */
1023
s->component_id[i] = get_bits(&s->gb, 8) - 1;
1024
s->h_count[i] = get_bits(&s->gb, 4);
1025
s->v_count[i] = get_bits(&s->gb, 4);
1026
/* compute hmax and vmax (only used in interleaved case) */
1027
if (s->h_count[i] > s->h_max)
1028
s->h_max = s->h_count[i];
1029
if (s->v_count[i] > s->v_max)
1030
s->v_max = s->v_count[i];
1031
s->quant_index[i] = get_bits(&s->gb, 8);
1032
if (s->quant_index[i] >= 4)
1033
return -1;
1034
dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1035
s->v_count[i], s->component_id[i], s->quant_index[i]);
1036
}
1037
1038
if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1039
1040
/* if different size, realloc/alloc picture */
1041
/* XXX: also check h_count and v_count */
1042
if (width != s->width || height != s->height) {
1043
for(i=0;i<MAX_COMPONENTS;i++)
1044
av_freep(&s->current_picture[i]);
1045
1046
av_freep(&s->qscale_table);
1047
1048
s->width = width;
1049
s->height = height;
1050
/* test interlaced mode */
1051
if (s->first_picture &&
1052
s->org_height != 0 &&
1053
s->height < ((s->org_height * 3) / 4)) {
1054
s->interlaced = 1;
1055
// s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1056
s->bottom_field = 0;
1057
}
1058
1059
if(s->rgb){
1060
int w, h;
1061
w = s->width;
1062
h = s->height;
1063
if (s->interlaced)
1064
w *= 2;
1065
s->linesize[0] = 4*w;
1066
s->current_picture[0] = av_mallocz(4*w * h);
1067
s->current_picture[1] = s->current_picture[2] = NULL;
1068
}else{
1069
for(i=0;i<nb_components;i++) {
1070
int w, h;
1071
w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
1072
h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1073
w = w * 8 * s->h_count[i];
1074
h = h * 8 * s->v_count[i];
1075
if (s->interlaced)
1076
w *= 2;
1077
s->linesize[i] = w;
1078
s->current_picture[i] = av_mallocz(w * h);
1079
if (!s->current_picture[i])
1080
{
1081
dprintf("error: no picture buffers allocated\n");
1082
return -1;
1083
}
1084
}
1085
}
1086
s->qscale_table= av_mallocz((s->width+15)/16);
1087
1088
s->first_picture = 0;
1089
}
1090
1091
if (len != (8+(3*nb_components)))
1092
{
1093
dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1094
}
1095
1096
return 0;
1097
}
1098
1099
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1100
{
1101
int code;
1102
code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1103
if (code < 0)
1104
{
1105
dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1106
&s->vlcs[0][dc_index]);
1107
return 0xffff;
1108
}
1109
1110
if(code)
1111
return get_xbits(&s->gb, code);
1112
else
1113
return 0;
1114
}
1115
1116
/* decode block and dequantize */
1117
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1118
int component, int dc_index, int ac_index, int quant_index)
1119
{
1120
int code, i, j, level, val;
1121
VLC *ac_vlc;
1122
int16_t *quant_matrix;
1123
1124
/* DC coef */
1125
val = mjpeg_decode_dc(s, dc_index);
1126
if (val == 0xffff) {
1127
dprintf("error dc\n");
1128
return -1;
1129
}
1130
quant_matrix = s->quant_matrixes[quant_index];
1131
val = val * quant_matrix[0] + s->last_dc[component];
1132
s->last_dc[component] = val;
1133
block[0] = val;
1134
/* AC coefs */
1135
ac_vlc = &s->vlcs[1][ac_index];
1136
i = 1;
1137
for(;;) {
1138
code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1139
1140
if (code < 0) {
1141
dprintf("error ac\n");
1142
return -1;
1143
}
1144
/* EOB */
1145
if (code == 0)
1146
break;
1147
if (code == 0xf0) {
1148
i += 16;
1149
} else {
1150
level = get_xbits(&s->gb, code & 0xf);
1151
i += code >> 4;
1152
if (i >= 64) {
1153
dprintf("error count: %d\n", i);
1154
return -1;
1155
}
1156
j = s->scantable.permutated[i];
1157
block[j] = level * quant_matrix[j];
1158
i++;
1159
if (i >= 64)
1160
break;
1161
}
1162
}
1163
return 0;
1164
}
1165
1166
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1167
int i, mb_x, mb_y;
1168
uint16_t buffer[2048][4];
1169
int left[3], top[3], topleft[3];
1170
const int linesize= s->linesize[0];
1171
const int mask= (1<<s->bits)-1;
1172
1173
for(i=0; i<3; i++){
1174
buffer[0][i]= 1 << (s->bits + point_transform - 1);
1175
}
1176
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1177
const int modified_predictor= mb_y ? predictor : 1;
1178
uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1179
1180
if (s->interlaced && s->bottom_field)
1181
ptr += linesize >> 1;
1182
1183
for(i=0; i<3; i++){
1184
top[i]= left[i]= topleft[i]= buffer[0][i];
1185
}
1186
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187
if (s->restart_interval && !s->restart_count)
1188
s->restart_count = s->restart_interval;
1189
1190
for(i=0;i<3;i++) {
1191
int pred;
1192
1193
topleft[i]= top[i];
1194
top[i]= buffer[mb_x][i];
1195
1196
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1197
1198
left[i]=
1199
buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1200
}
1201
1202
if (s->restart_interval && !--s->restart_count) {
1203
align_get_bits(&s->gb);
1204
skip_bits(&s->gb, 16); /* skip RSTn */
1205
}
1206
}
1207
1208
if(s->rct){
1209
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1210
ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1211
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1212
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1213
}
1214
}else if(s->pegasus_rct){
1215
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1216
ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1217
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1218
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1219
}
1220
}else{
1221
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1222
ptr[4*mb_x+0] = buffer[mb_x][0];
1223
ptr[4*mb_x+1] = buffer[mb_x][1];
1224
ptr[4*mb_x+2] = buffer[mb_x][2];
1225
}
1226
}
1227
}
1228
return 0;
1229
}
1230
1231
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1232
int i, mb_x, mb_y;
1233
const int nb_components=3;
1234
1235
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1236
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1237
if (s->restart_interval && !s->restart_count)
1238
s->restart_count = s->restart_interval;
1239
1240
if(mb_x==0 || mb_y==0 || s->interlaced){
1241
for(i=0;i<nb_components;i++) {
1242
uint8_t *ptr;
1243
int n, h, v, x, y, c, j, linesize;
1244
n = s->nb_blocks[i];
1245
c = s->comp_index[i];
1246
h = s->h_scount[i];
1247
v = s->v_scount[i];
1248
x = 0;
1249
y = 0;
1250
linesize= s->linesize[c];
1251
1252
for(j=0; j<n; j++) {
1253
int pred;
1254
1255
ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1256
if(y==0 && mb_y==0){
1257
if(x==0 && mb_x==0){
1258
pred= 128 << point_transform;
1259
}else{
1260
pred= ptr[-1];
1261
}
1262
}else{
1263
if(x==0 && mb_x==0){
1264
pred= ptr[-linesize];
1265
}else{
1266
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1267
}
1268
}
1269
1270
if (s->interlaced && s->bottom_field)
1271
ptr += linesize >> 1;
1272
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1273
1274
if (++x == h) {
1275
x = 0;
1276
y++;
1277
}
1278
}
1279
}
1280
}else{
1281
for(i=0;i<nb_components;i++) {
1282
uint8_t *ptr;
1283
int n, h, v, x, y, c, j, linesize;
1284
n = s->nb_blocks[i];
1285
c = s->comp_index[i];
1286
h = s->h_scount[i];
1287
v = s->v_scount[i];
1288
x = 0;
1289
y = 0;
1290
linesize= s->linesize[c];
1291
1292
for(j=0; j<n; j++) {
1293
int pred;
1294
1295
ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1296
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1297
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1298
if (++x == h) {
1299
x = 0;
1300
y++;
1301
}
1302
}
1303
}
1304
}
1305
if (s->restart_interval && !--s->restart_count) {
1306
align_get_bits(&s->gb);
1307
skip_bits(&s->gb, 16); /* skip RSTn */
1308
}
1309
}
1310
}
1311
return 0;
1312
}
1313
1314
static int mjpeg_decode_scan(MJpegDecodeContext *s){
1315
int i, mb_x, mb_y;
1316
const int nb_components=3;
1317
1318
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1319
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1320
if (s->restart_interval && !s->restart_count)
1321
s->restart_count = s->restart_interval;
1322
1323
for(i=0;i<nb_components;i++) {
1324
uint8_t *ptr;
1325
int n, h, v, x, y, c, j;
1326
n = s->nb_blocks[i];
1327
c = s->comp_index[i];
1328
h = s->h_scount[i];
1329
v = s->v_scount[i];
1330
x = 0;
1331
y = 0;
1332
for(j=0;j<n;j++) {
1333
memset(s->block, 0, sizeof(s->block));
1334
if (decode_block(s, s->block, i,
1335
s->dc_index[i], s->ac_index[i],
1336
s->quant_index[c]) < 0) {
1337
dprintf("error y=%d x=%d\n", mb_y, mb_x);
1338
return -1;
1339
}
1340
// dprintf("mb: %d %d processed\n", mb_y, mb_x);
1341
ptr = s->current_picture[c] +
1342
(s->linesize[c] * (v * mb_y + y) * 8) +
1343
(h * mb_x + x) * 8;
1344
if (s->interlaced && s->bottom_field)
1345
ptr += s->linesize[c] >> 1;
1346
s->idct_put(ptr, s->linesize[c], s->block);
1347
if (++x == h) {
1348
x = 0;
1349
y++;
1350
}
1351
}
1352
}
1353
/* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1354
if (s->restart_interval && (s->restart_interval < 1350) &&
1355
!--s->restart_count) {
1356
align_get_bits(&s->gb);
1357
skip_bits(&s->gb, 16); /* skip RSTn */
1358
for (i=0; i<nb_components; i++) /* reset dc */
1359
s->last_dc[i] = 1024;
1360
}
1361
}
1362
}
1363
return 0;
1364
}
1365
1366
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1367
{
1368
int len, nb_components, i, h, v, predictor, point_transform;
1369
int vmax, hmax, index, id;
1370
const int block_size= s->lossless ? 1 : 8;
1371
1372
/* XXX: verify len field validity */
1373
len = get_bits(&s->gb, 16);
1374
nb_components = get_bits(&s->gb, 8);
1375
if (len != 6+2*nb_components)
1376
{
1377
dprintf("decode_sos: invalid len (%d)\n", len);
1378
return -1;
1379
}
1380
/* XXX: only interleaved scan accepted */
1381
if (nb_components != 3)
1382
{
1383
dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1384
return -1;
1385
}
1386
vmax = 0;
1387
hmax = 0;
1388
for(i=0;i<nb_components;i++) {
1389
id = get_bits(&s->gb, 8) - 1;
1390
dprintf("component: %d\n", id);
1391
/* find component index */
1392
for(index=0;index<s->nb_components;index++)
1393
if (id == s->component_id[index])
1394
break;
1395
if (index == s->nb_components)
1396
{
1397
dprintf("decode_sos: index(%d) out of components\n", index);
1398
return -1;
1399
}
1400
1401
s->comp_index[i] = index;
1402
1403
s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1404
s->h_scount[i] = s->h_count[index];
1405
s->v_scount[i] = s->v_count[index];
1406
1407
s->dc_index[i] = get_bits(&s->gb, 4);
1408
s->ac_index[i] = get_bits(&s->gb, 4);
1409
1410
if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1411
s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1412
goto out_of_range;
1413
#if 0 //buggy
1414
switch(s->start_code)
1415
{
1416
case SOF0:
1417
if (dc_index[i] > 1 || ac_index[i] > 1)
1418
goto out_of_range;
1419
break;
1420
case SOF1:
1421
case SOF2:
1422
if (dc_index[i] > 3 || ac_index[i] > 3)
1423
goto out_of_range;
1424
break;
1425
case SOF3:
1426
if (dc_index[i] > 3 || ac_index[i] != 0)
1427
goto out_of_range;
1428
break;
1429
}
1430
#endif
1431
}
1432
1433
predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1434
skip_bits(&s->gb, 8); /* Se */
1435
skip_bits(&s->gb, 4); /* Ah */
1436
point_transform= get_bits(&s->gb, 4); /* Al */
1437
1438
for(i=0;i<nb_components;i++)
1439
s->last_dc[i] = 1024;
1440
1441
if (nb_components > 1) {
1442
/* interleaved stream */
1443
s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1444
s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1445
} else {
1446
h = s->h_max / s->h_scount[s->comp_index[0]];
1447
v = s->v_max / s->v_scount[s->comp_index[0]];
1448
s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1449
s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1450
s->nb_blocks[0] = 1;
1451
s->h_scount[0] = 1;
1452
s->v_scount[0] = 1;
1453
}
1454
1455
if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1456
printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1457
1458
if(s->lossless){
1459
if(s->rgb){
1460
if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1461
return -1;
1462
}else{
1463
if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1464
return -1;
1465
}
1466
}else{
1467
if(mjpeg_decode_scan(s) < 0)
1468
return -1;
1469
}
1470
emms_c();
1471
return 0;
1472
out_of_range:
1473
dprintf("decode_sos: ac/dc index out of range\n");
1474
return -1;
1475
}
1476
1477
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1478
{
1479
if (get_bits(&s->gb, 16) != 4)
1480
return -1;
1481
s->restart_interval = get_bits(&s->gb, 16);
1482
dprintf("restart interval: %d\n", s->restart_interval);
1483
1484
return 0;
1485
}
1486
1487
static int mjpeg_decode_app(MJpegDecodeContext *s)
1488
{
1489
int len, id;
1490
1491
/* XXX: verify len field validity */
1492
len = get_bits(&s->gb, 16);
1493
if (len < 5)
1494
return -1;
1495
1496
id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1497
id = be2me_32(id);
1498
len -= 6;
1499
1500
if(s->avctx->debug & FF_DEBUG_STARTCODE){
1501
printf("APPx %8X\n", id);
1502
}
1503
1504
/* buggy AVID, it puts EOI only at every 10th frame */
1505
/* also this fourcc is used by non-avid files too, it holds some
1506
informations, but it's always present in AVID creates files */
1507
if (id == ff_get_fourcc("AVI1"))
1508
{
1509
/* structure:
1510
4bytes AVI1
1511
1bytes polarity
1512
1bytes always zero
1513
4bytes field_size
1514
4bytes field_size_less_padding
1515
*/
1516
s->buggy_avid = 1;
1517
// if (s->first_picture)
1518
// printf("mjpeg: workarounding buggy AVID\n");
1519
s->interlace_polarity = get_bits(&s->gb, 8);
1520
#if 0
1521
skip_bits(&s->gb, 8);
1522
skip_bits(&s->gb, 32);
1523
skip_bits(&s->gb, 32);
1524
len -= 10;
1525
#endif
1526
// if (s->interlace_polarity)
1527
// printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1528
goto out;
1529
}
1530
1531
// len -= 2;
1532
1533
if (id == ff_get_fourcc("JFIF"))
1534
{
1535
int t_w, t_h;
1536
skip_bits(&s->gb, 8); /* the trailing zero-byte */
1537
printf("mjpeg: JFIF header found (version: %x.%x)\n",
1538
get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1539
if (get_bits(&s->gb, 8) == 0)
1540
{
1541
int x_density, y_density;
1542
x_density = get_bits(&s->gb, 16);
1543
y_density = get_bits(&s->gb, 16);
1544
1545
dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1546
(float)x_density, y_density, (float)y_density);
1547
#if 0
1548
//MN: needs to be checked
1549
if(x_density)
1550
// s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1551
s->avctx->aspect_ratio = (float)x_density/y_density;
1552
/* it's better, but every JFIF I have seen stores 1:1 */
1553
else
1554
s->avctx->aspect_ratio= 0.0;
1555
#endif
1556
}
1557
else
1558
{
1559
skip_bits(&s->gb, 16);
1560
skip_bits(&s->gb, 16);
1561
}
1562
1563
t_w = get_bits(&s->gb, 8);
1564
t_h = get_bits(&s->gb, 8);
1565
if (t_w && t_h)
1566
{
1567
/* skip thumbnail */
1568
if (len-10-(t_w*t_h*3) > 0)
1569
len -= t_w*t_h*3;
1570
}
1571
len -= 10;
1572
goto out;
1573
}
1574
1575
if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1576
{
1577
printf("mjpeg: Adobe header found\n");
1578
skip_bits(&s->gb, 16); /* version */
1579
skip_bits(&s->gb, 16); /* flags0 */
1580
skip_bits(&s->gb, 16); /* flags1 */
1581
skip_bits(&s->gb, 8); /* transform */
1582
len -= 7;
1583
goto out;
1584
}
1585
1586
if (id == ff_get_fourcc("LJIF")){
1587
printf("Pegasus lossless jpeg header found\n");
1588
skip_bits(&s->gb, 16); /* version ? */
1589
skip_bits(&s->gb, 16); /* unknwon always 0? */
1590
skip_bits(&s->gb, 16); /* unknwon always 0? */
1591
skip_bits(&s->gb, 16); /* unknwon always 0? */
1592
switch( get_bits(&s->gb, 8)){
1593
case 1:
1594
s->rgb= 1;
1595
s->pegasus_rct=0;
1596
break;
1597
case 2:
1598
s->rgb= 1;
1599
s->pegasus_rct=1;
1600
break;
1601
default:
1602
printf("unknown colorspace\n");
1603
}
1604
len -= 9;
1605
goto out;
1606
}
1607
1608
/* Apple MJPEG-A */
1609
if ((s->start_code == APP1) && (len > (0x28 - 8)))
1610
{
1611
id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1612
id = be2me_32(id);
1613
len -= 4;
1614
if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1615
{
1616
#if 0
1617
skip_bits(&s->gb, 32); /* field size */
1618
skip_bits(&s->gb, 32); /* pad field size */
1619
skip_bits(&s->gb, 32); /* next off */
1620
skip_bits(&s->gb, 32); /* quant off */
1621
skip_bits(&s->gb, 32); /* huff off */
1622
skip_bits(&s->gb, 32); /* image off */
1623
skip_bits(&s->gb, 32); /* scan off */
1624
skip_bits(&s->gb, 32); /* data off */
1625
#endif
1626
if (s->first_picture)
1627
printf("mjpeg: Apple MJPEG-A header found\n");
1628
}
1629
}
1630
1631
out:
1632
/* slow but needed for extreme adobe jpegs */
1633
if (len < 0)
1634
printf("mjpeg: error, decode_app parser read over the end\n");
1635
while(--len > 0)
1636
skip_bits(&s->gb, 8);
1637
1638
return 0;
1639
}
1640
1641
static int mjpeg_decode_com(MJpegDecodeContext *s)
1642
{
1643
/* XXX: verify len field validity */
1644
int len = get_bits(&s->gb, 16);
1645
if (len >= 2 && len < 32768) {
1646
/* XXX: any better upper bound */
1647
uint8_t *cbuf = av_malloc(len - 1);
1648
if (cbuf) {
1649
int i;
1650
for (i = 0; i < len - 2; i++)
1651
cbuf[i] = get_bits(&s->gb, 8);
1652
if (i > 0 && cbuf[i-1] == '\n')
1653
cbuf[i-1] = 0;
1654
else
1655
cbuf[i] = 0;
1656
1657
printf("mjpeg comment: '%s'\n", cbuf);
1658
1659
/* buggy avid, it puts EOI only at every 10th frame */
1660
if (!strcmp(cbuf, "AVID"))
1661
{
1662
s->buggy_avid = 1;
1663
// if (s->first_picture)
1664
// printf("mjpeg: workarounding buggy AVID\n");
1665
}
1666
1667
av_free(cbuf);
1668
}
1669
}
1670
1671
return 0;
1672
}
1673
1674
#if 0
1675
static int valid_marker_list[] =
1676
{
1677
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1678
/* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679
/* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680
/* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681
/* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682
/* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683
/* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684
/* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685
/* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686
/* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687
/* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688
/* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689
/* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690
/* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1691
/* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1692
/* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1693
/* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1694
}
1695
#endif
1696
1697
/* return the 8 bit start code value and update the search
1698
state. Return -1 if no start code found */
1699
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1700
{
1701
uint8_t *buf_ptr;
1702
unsigned int v, v2;
1703
int val;
1704
#ifdef DEBUG
1705
int skipped=0;
1706
#endif
1707
1708
buf_ptr = *pbuf_ptr;
1709
while (buf_ptr < buf_end) {
1710
v = *buf_ptr++;
1711
v2 = *buf_ptr;
1712
if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1713
val = *buf_ptr++;
1714
goto found;
1715
}
1716
#ifdef DEBUG
1717
skipped++;
1718
#endif
1719
}
1720
val = -1;
1721
found:
1722
#ifdef DEBUG
1723
dprintf("find_marker skipped %d bytes\n", skipped);
1724
#endif
1725
*pbuf_ptr = buf_ptr;
1726
return val;
1727
}
1728
1729
static int mjpeg_decode_frame(AVCodecContext *avctx,
1730
void *data, int *data_size,
1731
uint8_t *buf, int buf_size)
1732
{
1733
MJpegDecodeContext *s = avctx->priv_data;
1734
uint8_t *buf_end, *buf_ptr;
1735
int i, start_code;
1736
AVFrame *picture = data;
1737
1738
*data_size = 0;
1739
1740
/* no supplementary picture */
1741
if (buf_size == 0)
1742
return 0;
1743
1744
buf_ptr = buf;
1745
buf_end = buf + buf_size;
1746
while (buf_ptr < buf_end) {
1747
/* find start next marker */
1748
start_code = find_marker(&buf_ptr, buf_end);
1749
{
1750
/* EOF */
1751
if (start_code < 0) {
1752
goto the_end;
1753
} else {
1754
dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1755
1756
if ((buf_end - buf_ptr) > s->buffer_size)
1757
{
1758
av_free(s->buffer);
1759
s->buffer_size = buf_end-buf_ptr;
1760
s->buffer = av_malloc(s->buffer_size);
1761
dprintf("buffer too small, expanding to %d bytes\n",
1762
s->buffer_size);
1763
}
1764
1765
/* unescape buffer of SOS */
1766
if (start_code == SOS)
1767
{
1768
uint8_t *src = buf_ptr;
1769
uint8_t *dst = s->buffer;
1770
1771
while (src<buf_end)
1772
{
1773
uint8_t x = *(src++);
1774
1775
*(dst++) = x;
1776
if (x == 0xff)
1777
{
1778
while(*src == 0xff) src++;
1779
1780
x = *(src++);
1781
if (x >= 0xd0 && x <= 0xd7)
1782
*(dst++) = x;
1783
else if (x)
1784
break;
1785
}
1786
}
1787
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1788
1789
dprintf("escaping removed %d bytes\n",
1790
(buf_end - buf_ptr) - (dst - s->buffer));
1791
}
1792
else
1793
init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1794
1795
s->start_code = start_code;
1796
if(s->avctx->debug & FF_DEBUG_STARTCODE){
1797
printf("startcode: %X\n", start_code);
1798
}
1799
1800
/* process markers */
1801
if (start_code >= 0xd0 && start_code <= 0xd7) {
1802
dprintf("restart marker: %d\n", start_code&0x0f);
1803
} else if (s->first_picture) {
1804
/* APP fields */
1805
if (start_code >= 0xe0 && start_code <= 0xef)
1806
mjpeg_decode_app(s);
1807
/* Comment */
1808
else if (start_code == COM)
1809
mjpeg_decode_com(s);
1810
}
1811
1812
switch(start_code) {
1813
case SOI:
1814
s->restart_interval = 0;
1815
/* nothing to do on SOI */
1816
break;
1817
case DQT:
1818
mjpeg_decode_dqt(s);
1819
break;
1820
case DHT:
1821
if(mjpeg_decode_dht(s) < 0){
1822
fprintf(stderr, "huffman table decode error\n");
1823
return -1;
1824
}
1825
break;
1826
case SOF0:
1827
s->lossless=0;
1828
if (mjpeg_decode_sof(s) < 0)
1829
return -1;
1830
break;
1831
case SOF3:
1832
s->lossless=1;
1833
if (mjpeg_decode_sof(s) < 0)
1834
return -1;
1835
break;
1836
case EOI:
1837
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1838
break;
1839
eoi_parser:
1840
{
1841
if (s->interlaced) {
1842
s->bottom_field ^= 1;
1843
/* if not bottom field, do not output image yet */
1844
if (s->bottom_field)
1845
goto not_the_end;
1846
}
1847
for(i=0;i<3;i++) {
1848
picture->data[i] = s->current_picture[i];
1849
picture->linesize[i] = (s->interlaced) ?
1850
s->linesize[i] >> 1 : s->linesize[i];
1851
}
1852
*data_size = sizeof(AVFrame);
1853
avctx->height = s->height;
1854
if (s->interlaced)
1855
avctx->height *= 2;
1856
avctx->width = s->width;
1857
/* XXX: not complete test ! */
1858
switch((s->h_count[0] << 4) | s->v_count[0]) {
1859
case 0x11:
1860
if(s->rgb){
1861
avctx->pix_fmt = PIX_FMT_RGBA32;
1862
}else
1863
avctx->pix_fmt = PIX_FMT_YUV444P;
1864
break;
1865
case 0x21:
1866
avctx->pix_fmt = PIX_FMT_YUV422P;
1867
break;
1868
default:
1869
case 0x22:
1870
avctx->pix_fmt = PIX_FMT_YUV420P;
1871
break;
1872
}
1873
1874
if(!s->lossless){
1875
picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1876
picture->qstride= 0;
1877
picture->qscale_table= s->qscale_table;
1878
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1879
if(avctx->debug & FF_DEBUG_QP)
1880
printf("QP: %d\n", (int)picture->quality);
1881
}
1882
1883
goto the_end;
1884
}
1885
break;
1886
case SOS:
1887
mjpeg_decode_sos(s);
1888
/* buggy avid puts EOI every 10-20th frame */
1889
/* if restart period is over process EOI */
1890
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1891
goto eoi_parser;
1892
break;
1893
case DRI:
1894
mjpeg_decode_dri(s);
1895
break;
1896
case SOF1:
1897
case SOF2:
1898
case SOF5:
1899
case SOF6:
1900
case SOF7:
1901
case SOF9:
1902
case SOF10:
1903
case SOF11:
1904
case SOF13:
1905
case SOF14:
1906
case SOF15:
1907
case JPG:
1908
printf("mjpeg: unsupported coding type (%x)\n", start_code);
1909
break;
1910
// default:
1911
// printf("mjpeg: unsupported marker (%x)\n", start_code);
1912
// break;
1913
}
1914
1915
not_the_end:
1916
/* eof process start code */
1917
buf_ptr += (get_bits_count(&s->gb)+7)/8;
1918
dprintf("marker parser used %d bytes (%d bits)\n",
1919
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1920
}
1921
}
1922
}
1923
the_end:
1924
dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1925
// return buf_end - buf_ptr;
1926
return buf_ptr - buf;
1927
}
1928
1929
static int mjpegb_decode_frame(AVCodecContext *avctx,
1930
void *data, int *data_size,
1931
uint8_t *buf, int buf_size)
1932
{
1933
MJpegDecodeContext *s = avctx->priv_data;
1934
uint8_t *buf_end, *buf_ptr;
1935
int i;
1936
AVFrame *picture = data;
1937
GetBitContext hgb; /* for the header */
1938
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1939
uint32_t field_size;
1940
1941
*data_size = 0;
1942
1943
/* no supplementary picture */
1944
if (buf_size == 0)
1945
return 0;
1946
1947
buf_ptr = buf;
1948
buf_end = buf + buf_size;
1949
1950
read_header:
1951
/* reset on every SOI */
1952
s->restart_interval = 0;
1953
1954
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1955
1956
skip_bits(&hgb, 32); /* reserved zeros */
1957
1958
if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1959
{
1960
dprintf("not mjpeg-b (bad fourcc)\n");
1961
return 0;
1962
}
1963
1964
field_size = get_bits(&hgb, 32); /* field size */
1965
dprintf("field size: 0x%x\n", field_size);
1966
skip_bits(&hgb, 32); /* padded field size */
1967
second_field_offs = get_bits(&hgb, 32);
1968
dprintf("second field offs: 0x%x\n", second_field_offs);
1969
if (second_field_offs)
1970
s->interlaced = 1;
1971
1972
dqt_offs = get_bits(&hgb, 32);
1973
dprintf("dqt offs: 0x%x\n", dqt_offs);
1974
if (dqt_offs)
1975
{
1976
init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1977
s->start_code = DQT;
1978
mjpeg_decode_dqt(s);
1979
}
1980
1981
dht_offs = get_bits(&hgb, 32);
1982
dprintf("dht offs: 0x%x\n", dht_offs);
1983
if (dht_offs)
1984
{
1985
init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1986
s->start_code = DHT;
1987
mjpeg_decode_dht(s);
1988
}
1989
1990
sof_offs = get_bits(&hgb, 32);
1991
dprintf("sof offs: 0x%x\n", sof_offs);
1992
if (sof_offs)
1993
{
1994
init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1995
s->start_code = SOF0;
1996
if (mjpeg_decode_sof(s) < 0)
1997
return -1;
1998
}
1999
2000
sos_offs = get_bits(&hgb, 32);
2001
dprintf("sos offs: 0x%x\n", sos_offs);
2002
if (sos_offs)
2003
{
2004
// init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2005
init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2006
s->start_code = SOS;
2007
mjpeg_decode_sos(s);
2008
}
2009
2010
skip_bits(&hgb, 32); /* start of data offset */
2011
2012
if (s->interlaced) {
2013
s->bottom_field ^= 1;
2014
/* if not bottom field, do not output image yet */
2015
if (s->bottom_field && second_field_offs)
2016
{
2017
buf_ptr = buf + second_field_offs;
2018
second_field_offs = 0;
2019
goto read_header;
2020
}
2021
}
2022
2023
//XXX FIXME factorize, this looks very similar to the EOI code
2024
2025
for(i=0;i<3;i++) {
2026
picture->data[i] = s->current_picture[i];
2027
picture->linesize[i] = (s->interlaced) ?
2028
s->linesize[i] >> 1 : s->linesize[i];
2029
}
2030
*data_size = sizeof(AVFrame);
2031
avctx->height = s->height;
2032
if (s->interlaced)
2033
avctx->height *= 2;
2034
avctx->width = s->width;
2035
/* XXX: not complete test ! */
2036
switch((s->h_count[0] << 4) | s->v_count[0]) {
2037
case 0x11:
2038
avctx->pix_fmt = PIX_FMT_YUV444P;
2039
break;
2040
case 0x21:
2041
avctx->pix_fmt = PIX_FMT_YUV422P;
2042
break;
2043
default:
2044
case 0x22:
2045
avctx->pix_fmt = PIX_FMT_YUV420P;
2046
break;
2047
}
2048
2049
if(!s->lossless){
2050
picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2051
picture->qstride= 0;
2052
picture->qscale_table= s->qscale_table;
2053
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2054
if(avctx->debug & FF_DEBUG_QP)
2055
printf("QP: %f\n", picture->quality);
2056
}
2057
2058
return buf_ptr - buf;
2059
}
2060
2061
2062
static int mjpeg_decode_end(AVCodecContext *avctx)
2063
{
2064
MJpegDecodeContext *s = avctx->priv_data;
2065
int i, j;
2066
2067
av_free(s->buffer);
2068
av_free(s->qscale_table);
2069
for(i=0;i<MAX_COMPONENTS;i++)
2070
av_free(s->current_picture[i]);
2071
for(i=0;i<2;i++) {
2072
for(j=0;j<4;j++)
2073
free_vlc(&s->vlcs[i][j]);
2074
}
2075
return 0;
2076
}
2077
2078
AVCodec mjpeg_decoder = {
2079
"mjpeg",
2080
CODEC_TYPE_VIDEO,
2081
CODEC_ID_MJPEG,
2082
sizeof(MJpegDecodeContext),
2083
mjpeg_decode_init,
2084
NULL,
2085
mjpeg_decode_end,
2086
mjpeg_decode_frame,
2087
0,
2088
NULL
2089
};
2090
2091
AVCodec mjpegb_decoder = {
2092
"mjpegb",
2093
CODEC_TYPE_VIDEO,
2094
CODEC_ID_MJPEGB,
2095
sizeof(MJpegDecodeContext),
2096
mjpeg_decode_init,
2097
NULL,
2098
mjpeg_decode_end,
2099
mjpegb_decode_frame,
2100
0,
2101
NULL
2102
};
2103
2104
#ifdef CONFIG_ENCODERS
2105
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2106
"ljpeg",
2107
CODEC_TYPE_VIDEO,
2108
CODEC_ID_LJPEG,
2109
sizeof(MpegEncContext),
2110
MPV_encode_init,
2111
encode_picture_lossless,
2112
MPV_encode_end,
2113
};
2114
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1