falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8381 Commits
32 Branches
821MB
Tree: cc58300e30
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cc58300e30'
${ noResults }
FFmpeg/libavcodec/mjpeg.c

2626 lines
83KB
Raw Blame History 

  1. /*

  2.  * MJPEG encoder and decoder

  3.  * Copyright (c) 2000, 2001 Fabrice Bellard.

  4.  * Copyright (c) 2003 Alex Beregszaszi

  5.  * Copyright (c) 2003-2004 Michael Niedermayer

  6.  *

  7.  * This file is part of FFmpeg.

  8.  *

  9.  * FFmpeg is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * FFmpeg is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with FFmpeg; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  *

  23.  * Support for external huffman table, various fixes (AVID workaround),

  24.  * aspecting, new decode_frame mechanism and apple mjpeg-b support

  25.  *                                  by Alex Beregszaszi <alex@naxine.org>

  26.  */

  27. 

  28. /**

  29.  * @file mjpeg.c

  30.  * MJPEG encoder and decoder.

  31.  */

  32. 

  33. //#define DEBUG

  34. #include <assert.h>

  35. 

  36. #include "avcodec.h"

  37. #include "dsputil.h"

  38. #include "mpegvideo.h"

  39. #include "bytestream.h"

  40. 

  41. /* use two quantizer tables (one for luminance and one for chrominance) */

  42. /* not yet working */

  43. #undef TWOMATRIXES

  44. 

  45. typedef struct MJpegContext {

  46.     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing

  47.     uint16_t huff_code_dc_luminance[12];

  48.     uint8_t huff_size_dc_chrominance[12];

  49.     uint16_t huff_code_dc_chrominance[12];

  50. 

  51.     uint8_t huff_size_ac_luminance[256];

  52.     uint16_t huff_code_ac_luminance[256];

  53.     uint8_t huff_size_ac_chrominance[256];

  54.     uint16_t huff_code_ac_chrominance[256];

  55. } MJpegContext;

  56. 

  57. /* JPEG marker codes */

  58. typedef enum {

  59.     /* start of frame */

  60.     SOF0  = 0xc0,       /* baseline */

  61.     SOF1  = 0xc1,       /* extended sequential, huffman */

  62.     SOF2  = 0xc2,       /* progressive, huffman */

  63.     SOF3  = 0xc3,       /* lossless, huffman */

  64. 

  65.     SOF5  = 0xc5,       /* differential sequential, huffman */

  66.     SOF6  = 0xc6,       /* differential progressive, huffman */

  67.     SOF7  = 0xc7,       /* differential lossless, huffman */

  68.     JPG   = 0xc8,       /* reserved for JPEG extension */

  69.     SOF9  = 0xc9,       /* extended sequential, arithmetic */

  70.     SOF10 = 0xca,       /* progressive, arithmetic */

  71.     SOF11 = 0xcb,       /* lossless, arithmetic */

  72. 

  73.     SOF13 = 0xcd,       /* differential sequential, arithmetic */

  74.     SOF14 = 0xce,       /* differential progressive, arithmetic */

  75.     SOF15 = 0xcf,       /* differential lossless, arithmetic */

  76. 

  77.     DHT   = 0xc4,       /* define huffman tables */

  78. 

  79.     DAC   = 0xcc,       /* define arithmetic-coding conditioning */

  80. 

  81.     /* restart with modulo 8 count "m" */

  82.     RST0  = 0xd0,

  83.     RST1  = 0xd1,

  84.     RST2  = 0xd2,

  85.     RST3  = 0xd3,

  86.     RST4  = 0xd4,

  87.     RST5  = 0xd5,

  88.     RST6  = 0xd6,

  89.     RST7  = 0xd7,

  90. 

  91.     SOI   = 0xd8,       /* start of image */

  92.     EOI   = 0xd9,       /* end of image */

  93.     SOS   = 0xda,       /* start of scan */

  94.     DQT   = 0xdb,       /* define quantization tables */

  95.     DNL   = 0xdc,       /* define number of lines */

  96.     DRI   = 0xdd,       /* define restart interval */

  97.     DHP   = 0xde,       /* define hierarchical progression */

  98.     EXP   = 0xdf,       /* expand reference components */

  99. 

  100.     APP0  = 0xe0,

  101.     APP1  = 0xe1,

  102.     APP2  = 0xe2,

  103.     APP3  = 0xe3,

  104.     APP4  = 0xe4,

  105.     APP5  = 0xe5,

  106.     APP6  = 0xe6,

  107.     APP7  = 0xe7,

  108.     APP8  = 0xe8,

  109.     APP9  = 0xe9,

  110.     APP10 = 0xea,

  111.     APP11 = 0xeb,

  112.     APP12 = 0xec,

  113.     APP13 = 0xed,

  114.     APP14 = 0xee,

  115.     APP15 = 0xef,

  116. 

  117.     JPG0  = 0xf0,

  118.     JPG1  = 0xf1,

  119.     JPG2  = 0xf2,

  120.     JPG3  = 0xf3,

  121.     JPG4  = 0xf4,

  122.     JPG5  = 0xf5,

  123.     JPG6  = 0xf6,

  124.     SOF48 = 0xf7,       ///< JPEG-LS

  125.     LSE   = 0xf8,       ///< JPEG-LS extension parameters

  126.     JPG9  = 0xf9,

  127.     JPG10 = 0xfa,

  128.     JPG11 = 0xfb,

  129.     JPG12 = 0xfc,

  130.     JPG13 = 0xfd,

  131. 

  132.     COM   = 0xfe,       /* comment */

  133. 

  134.     TEM   = 0x01,       /* temporary private use for arithmetic coding */

  135. 

  136.     /* 0x02 -> 0xbf reserved */

  137. } JPEG_MARKER;

  138. 

  139. #if 0

  140. /* These are the sample quantization tables given in JPEG spec section K.1.

  141.  * The spec says that the values given produce "good" quality, and

  142.  * when divided by 2, "very good" quality.

  143.  */

  144. static const unsigned char std_luminance_quant_tbl[64] = {

  145.     16,  11,  10,  16,  24,  40,  51,  61,

  146.     12,  12,  14,  19,  26,  58,  60,  55,

  147.     14,  13,  16,  24,  40,  57,  69,  56,

  148.     14,  17,  22,  29,  51,  87,  80,  62,

  149.     18,  22,  37,  56,  68, 109, 103,  77,

  150.     24,  35,  55,  64,  81, 104, 113,  92,

  151.     49,  64,  78,  87, 103, 121, 120, 101,

  152.     72,  92,  95,  98, 112, 100, 103,  99

  153. };

  154. static const unsigned char std_chrominance_quant_tbl[64] = {

  155.     17,  18,  24,  47,  99,  99,  99,  99,

  156.     18,  21,  26,  66,  99,  99,  99,  99,

  157.     24,  26,  56,  99,  99,  99,  99,  99,

  158.     47,  66,  99,  99,  99,  99,  99,  99,

  159.     99,  99,  99,  99,  99,  99,  99,  99,

  160.     99,  99,  99,  99,  99,  99,  99,  99,

  161.     99,  99,  99,  99,  99,  99,  99,  99,

  162.     99,  99,  99,  99,  99,  99,  99,  99

  163. };

  164. #endif

  165. 

  166. /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */

  167. /* IMPORTANT: these are only valid for 8-bit data precision! */

  168. static const uint8_t bits_dc_luminance[17] =

  169. { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };

  170. static const uint8_t val_dc_luminance[] =

  171. { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

  172. 

  173. static const uint8_t bits_dc_chrominance[17] =

  174. { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

  175. static const uint8_t val_dc_chrominance[] =

  176. { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

  177. 

  178. static const uint8_t bits_ac_luminance[17] =

  179. { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };

  180. static const uint8_t val_ac_luminance[] =

  181. { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

  182.   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

  183.   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,

  184.   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,

  185.   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,

  186.   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,

  187.   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,

  188.   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,

  189.   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,

  190.   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

  191.   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,

  192.   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,

  193.   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,

  194.   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,

  195.   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,

  196.   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,

  197.   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,

  198.   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,

  199.   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,

  200.   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

  201.   0xf9, 0xfa

  202. };

  203. 

  204. static const uint8_t bits_ac_chrominance[17] =

  205. { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };

  206. 

  207. static const uint8_t val_ac_chrominance[] =

  208. { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,

  209.   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

  210.   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

  211.   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,

  212.   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,

  213.   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,

  214.   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,

  215.   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,

  216.   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,

  217.   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,

  218.   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,

  219.   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

  220.   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,

  221.   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,

  222.   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,

  223.   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,

  224.   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,

  225.   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,

  226.   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,

  227.   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

  228.   0xf9, 0xfa

  229. };

  230. 

  231. /* isn't this function nicer than the one in the libjpeg ? */

  232. static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,

  233.                                 const uint8_t *bits_table, const uint8_t *val_table)

  234. {

  235.     int i, j, k,nb, code, sym;

  236. 

  237.     code = 0;

  238.     k = 0;

  239.     for(i=1;i<=16;i++) {

  240.         nb = bits_table[i];

  241.         for(j=0;j<nb;j++) {

  242.             sym = val_table[k++];

  243.             huff_size[sym] = i;

  244.             huff_code[sym] = code;

  245.             code++;

  246.         }

  247.         code <<= 1;

  248.     }

  249. }

  250. 

  251. #ifdef CONFIG_ENCODERS

  252. int mjpeg_init(MpegEncContext *s)

  253. {

  254.     MJpegContext *m;

  255. 

  256.     m = av_malloc(sizeof(MJpegContext));

  257.     if (!m)

  258.         return -1;

  259. 

  260.     s->min_qcoeff=-1023;

  261.     s->max_qcoeff= 1023;

  262. 

  263.     /* build all the huffman tables */

  264.     build_huffman_codes(m->huff_size_dc_luminance,

  265.                         m->huff_code_dc_luminance,

  266.                         bits_dc_luminance,

  267.                         val_dc_luminance);

  268.     build_huffman_codes(m->huff_size_dc_chrominance,

  269.                         m->huff_code_dc_chrominance,

  270.                         bits_dc_chrominance,

  271.                         val_dc_chrominance);

  272.     build_huffman_codes(m->huff_size_ac_luminance,

  273.                         m->huff_code_ac_luminance,

  274.                         bits_ac_luminance,

  275.                         val_ac_luminance);

  276.     build_huffman_codes(m->huff_size_ac_chrominance,

  277.                         m->huff_code_ac_chrominance,

  278.                         bits_ac_chrominance,

  279.                         val_ac_chrominance);

  280. 

  281.     s->mjpeg_ctx = m;

  282.     return 0;

  283. }

  284. 

  285. void mjpeg_close(MpegEncContext *s)

  286. {

  287.     av_free(s->mjpeg_ctx);

  288. }

  289. #endif //CONFIG_ENCODERS

  290. 

  291. #define PREDICT(ret, topleft, top, left, predictor)\

  292.     switch(predictor){\

  293.         case 1: ret= left; break;\

  294.         case 2: ret= top; break;\

  295.         case 3: ret= topleft; break;\

  296.         case 4: ret= left   +   top - topleft; break;\

  297.         case 5: ret= left   + ((top - topleft)>>1); break;\

  298.         case 6: ret= top + ((left   - topleft)>>1); break;\

  299.         default:\

  300.         case 7: ret= (left + top)>>1; break;\

  301.     }

  302. 

  303. #ifdef CONFIG_ENCODERS

  304. static inline void put_marker(PutBitContext *p, int code)

  305. {

  306.     put_bits(p, 8, 0xff);

  307.     put_bits(p, 8, code);

  308. }

  309. 

  310. /* table_class: 0 = DC coef, 1 = AC coefs */

  311. static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,

  312.                              const uint8_t *bits_table, const uint8_t *value_table)

  313. {

  314.     PutBitContext *p = &s->pb;

  315.     int n, i;

  316. 

  317.     put_bits(p, 4, table_class);

  318.     put_bits(p, 4, table_id);

  319. 

  320.     n = 0;

  321.     for(i=1;i<=16;i++) {

  322.         n += bits_table[i];

  323.         put_bits(p, 8, bits_table[i]);

  324.     }

  325. 

  326.     for(i=0;i<n;i++)

  327.         put_bits(p, 8, value_table[i]);

  328. 

  329.     return n + 17;

  330. }

  331. 

  332. static void jpeg_table_header(MpegEncContext *s)

  333. {

  334.     PutBitContext *p = &s->pb;

  335.     int i, j, size;

  336.     uint8_t *ptr;

  337. 

  338.     /* quant matrixes */

  339.     put_marker(p, DQT);

  340. #ifdef TWOMATRIXES

  341.     put_bits(p, 16, 2 + 2 * (1 + 64));

  342. #else

  343.     put_bits(p, 16, 2 + 1 * (1 + 64));

  344. #endif

  345.     put_bits(p, 4, 0); /* 8 bit precision */

  346.     put_bits(p, 4, 0); /* table 0 */

  347.     for(i=0;i<64;i++) {

  348.         j = s->intra_scantable.permutated[i];

  349.         put_bits(p, 8, s->intra_matrix[j]);

  350.     }

  351. #ifdef TWOMATRIXES

  352.     put_bits(p, 4, 0); /* 8 bit precision */

  353.     put_bits(p, 4, 1); /* table 1 */

  354.     for(i=0;i<64;i++) {

  355.         j = s->intra_scantable.permutated[i];

  356.         put_bits(p, 8, s->chroma_intra_matrix[j]);

  357.     }

  358. #endif

  359. 

  360.     /* huffman table */

  361.     put_marker(p, DHT);

  362.     flush_put_bits(p);

  363.     ptr = pbBufPtr(p);

  364.     put_bits(p, 16, 0); /* patched later */

  365.     size = 2;

  366.     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);

  367.     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);

  368. 

  369.     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);

  370.     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);

  371.     ptr[0] = size >> 8;

  372.     ptr[1] = size;

  373. }

  374. 

  375. static void jpeg_put_comments(MpegEncContext *s)

  376. {

  377.     PutBitContext *p = &s->pb;

  378.     int size;

  379.     uint8_t *ptr;

  380. 

  381.     if (s->aspect_ratio_info /* && !lossless */)

  382.     {

  383.     /* JFIF header */

  384.     put_marker(p, APP0);

  385.     put_bits(p, 16, 16);

  386.     ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */

  387.     put_bits(p, 16, 0x0201); /* v 1.02 */

  388.     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */

  389.     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);

  390.     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);

  391.     put_bits(p, 8, 0); /* thumbnail width */

  392.     put_bits(p, 8, 0); /* thumbnail height */

  393.     }

  394. 

  395.     /* comment */

  396.     if(!(s->flags & CODEC_FLAG_BITEXACT)){

  397.         put_marker(p, COM);

  398.         flush_put_bits(p);

  399.         ptr = pbBufPtr(p);

  400.         put_bits(p, 16, 0); /* patched later */

  401.         ff_put_string(p, LIBAVCODEC_IDENT, 1);

  402.         size = strlen(LIBAVCODEC_IDENT)+3;

  403.         ptr[0] = size >> 8;

  404.         ptr[1] = size;

  405.     }

  406. 

  407.     if(  s->avctx->pix_fmt == PIX_FMT_YUV420P

  408.        ||s->avctx->pix_fmt == PIX_FMT_YUV422P

  409.        ||s->avctx->pix_fmt == PIX_FMT_YUV444P){

  410.         put_marker(p, COM);

  411.         flush_put_bits(p);

  412.         ptr = pbBufPtr(p);

  413.         put_bits(p, 16, 0); /* patched later */

  414.         ff_put_string(p, "CS=ITU601", 1);

  415.         size = strlen("CS=ITU601")+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_MJPEG;

  424.     const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;

  425. 

  426.     assert(!(ls && s->mjpeg_write_tables));

  427. 

  428.     put_marker(&s->pb, SOI);

  429. 

  430.     if (!s->mjpeg_data_only_frames)

  431.     {

  432.     jpeg_put_comments(s);

  433. 

  434.     if (s->mjpeg_write_tables) jpeg_table_header(s);

  435. 

  436.     switch(s->avctx->codec_id){

  437.     case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;

  438.     case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;

  439.     case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;

  440.     default: assert(0);

  441.     }

  442. 

  443.     put_bits(&s->pb, 16, 17);

  444.     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)

  445.         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */

  446.     else

  447.         put_bits(&s->pb, 8, 8); /* 8 bits/component */

  448.     put_bits(&s->pb, 16, s->height);

  449.     put_bits(&s->pb, 16, s->width);

  450.     put_bits(&s->pb, 8, 3); /* 3 components */

  451. 

  452.     /* Y component */

  453.     put_bits(&s->pb, 8, 1); /* component number */

  454.     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */

  455.     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */

  456.     put_bits(&s->pb, 8, 0); /* select matrix */

  457. 

  458.     /* Cb component */

  459.     put_bits(&s->pb, 8, 2); /* component number */

  460.     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */

  461.     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */

  462. #ifdef TWOMATRIXES

  463.     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */

  464. #else

  465.     put_bits(&s->pb, 8, 0); /* select matrix */

  466. #endif

  467. 

  468.     /* Cr component */

  469.     put_bits(&s->pb, 8, 3); /* component number */

  470.     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */

  471.     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */

  472. #ifdef TWOMATRIXES

  473.     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */

  474. #else

  475.     put_bits(&s->pb, 8, 0); /* select matrix */

  476. #endif

  477.     }

  478. 

  479.     /* scan header */

  480.     put_marker(&s->pb, SOS);

  481.     put_bits(&s->pb, 16, 12); /* length */

  482.     put_bits(&s->pb, 8, 3); /* 3 components */

  483. 

  484.     /* Y component */

  485.     put_bits(&s->pb, 8, 1); /* index */

  486.     put_bits(&s->pb, 4, 0); /* DC huffman table index */

  487.     put_bits(&s->pb, 4, 0); /* AC huffman table index */

  488. 

  489.     /* Cb component */

  490.     put_bits(&s->pb, 8, 2); /* index */

  491.     put_bits(&s->pb, 4, 1); /* DC huffman table index */

  492.     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */

  493. 

  494.     /* Cr component */

  495.     put_bits(&s->pb, 8, 3); /* index */

  496.     put_bits(&s->pb, 4, 1); /* DC huffman table index */

  497.     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */

  498. 

  499.     put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */

  500. 

  501.     switch(s->avctx->codec_id){

  502.     case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */

  503.     case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */

  504.     case CODEC_ID_JPEGLS: put_bits(&s->pb, 8,  1); break; /* ILV = line interleaved */

  505.     default: assert(0);

  506.     }

  507. 

  508.     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */

  509. 

  510.     //FIXME DC/AC entropy table selectors stuff in jpegls

  511. }

  512. 

  513. static void escape_FF(MpegEncContext *s, int start)

  514. {

  515.     int size= put_bits_count(&s->pb) - start*8;

  516.     int i, ff_count;

  517.     uint8_t *buf= s->pb.buf + start;

  518.     int align= (-(size_t)(buf))&3;

  519. 

  520.     assert((size&7) == 0);

  521.     size >>= 3;

  522. 

  523.     ff_count=0;

  524.     for(i=0; i<size && i<align; i++){

  525.         if(buf[i]==0xFF) ff_count++;

  526.     }

  527.     for(; i<size-15; i+=16){

  528.         int acc, v;

  529. 

  530.         v= *(uint32_t*)(&buf[i]);

  531.         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

  532.         v= *(uint32_t*)(&buf[i+4]);

  533.         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

  534.         v= *(uint32_t*)(&buf[i+8]);

  535.         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

  536.         v= *(uint32_t*)(&buf[i+12]);

  537.         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

  538. 

  539.         acc>>=4;

  540.         acc+= (acc>>16);

  541.         acc+= (acc>>8);

  542.         ff_count+= acc&0xFF;

  543.     }

  544.     for(; i<size; i++){

  545.         if(buf[i]==0xFF) ff_count++;

  546.     }

  547. 

  548.     if(ff_count==0) return;

  549. 

  550.     /* skip put bits */

  551.     for(i=0; i<ff_count-3; i+=4)

  552.         put_bits(&s->pb, 32, 0);

  553.     put_bits(&s->pb, (ff_count-i)*8, 0);

  554.     flush_put_bits(&s->pb);

  555. 

  556.     for(i=size-1; ff_count; i--){

  557.         int v= buf[i];

  558. 

  559.         if(v==0xFF){

  560. //printf("%d %d\n", i, ff_count);

  561.             buf[i+ff_count]= 0;

  562.             ff_count--;

  563.         }

  564. 

  565.         buf[i+ff_count]= v;

  566.     }

  567. }

  568. 

  569. void ff_mjpeg_stuffing(PutBitContext * pbc)

  570. {

  571.     int length;

  572.     length= (-put_bits_count(pbc))&7;

  573.     if(length) put_bits(pbc, length, (1<<length)-1);

  574. }

  575. 

  576. void mjpeg_picture_trailer(MpegEncContext *s)

  577. {

  578.     ff_mjpeg_stuffing(&s->pb);

  579.     flush_put_bits(&s->pb);

  580. 

  581.     assert((s->header_bits&7)==0);

  582. 

  583.     escape_FF(s, s->header_bits>>3);

  584. 

  585.     put_marker(&s->pb, EOI);

  586. }

  587. 

  588. static inline void mjpeg_encode_dc(MpegEncContext *s, int val,

  589.                                    uint8_t *huff_size, uint16_t *huff_code)

  590. {

  591.     int mant, nbits;

  592. 

  593.     if (val == 0) {

  594.         put_bits(&s->pb, huff_size[0], huff_code[0]);

  595.     } else {

  596.         mant = val;

  597.         if (val < 0) {

  598.             val = -val;

  599.             mant--;

  600.         }

  601. 

  602.         nbits= av_log2_16bit(val) + 1;

  603. 

  604.         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);

  605. 

  606.         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));

  607.     }

  608. }

  609. 

  610. static void encode_block(MpegEncContext *s, DCTELEM *block, int n)

  611. {

  612.     int mant, nbits, code, i, j;

  613.     int component, dc, run, last_index, val;

  614.     MJpegContext *m = s->mjpeg_ctx;

  615.     uint8_t *huff_size_ac;

  616.     uint16_t *huff_code_ac;

  617. 

  618.     /* DC coef */

  619.     component = (n <= 3 ? 0 : (n&1) + 1);

  620.     dc = block[0]; /* overflow is impossible */

  621.     val = dc - s->last_dc[component];

  622.     if (n < 4) {

  623.         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);

  624.         huff_size_ac = m->huff_size_ac_luminance;

  625.         huff_code_ac = m->huff_code_ac_luminance;

  626.     } else {

  627.         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);

  628.         huff_size_ac = m->huff_size_ac_chrominance;

  629.         huff_code_ac = m->huff_code_ac_chrominance;

  630.     }

  631.     s->last_dc[component] = dc;

  632. 

  633.     /* AC coefs */

  634. 

  635.     run = 0;

  636.     last_index = s->block_last_index[n];

  637.     for(i=1;i<=last_index;i++) {

  638.         j = s->intra_scantable.permutated[i];

  639.         val = block[j];

  640.         if (val == 0) {

  641.             run++;

  642.         } else {

  643.             while (run >= 16) {

  644.                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);

  645.                 run -= 16;

  646.             }

  647.             mant = val;

  648.             if (val < 0) {

  649.                 val = -val;

  650.                 mant--;

  651.             }

  652. 

  653.             nbits= av_log2(val) + 1;

  654.             code = (run << 4) | nbits;

  655. 

  656.             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);

  657. 

  658.             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));

  659.             run = 0;

  660.         }

  661.     }

  662. 

  663.     /* output EOB only if not already 64 values */

  664.     if (last_index < 63 || run != 0)

  665.         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);

  666. }

  667. 

  668. void mjpeg_encode_mb(MpegEncContext *s,

  669.                      DCTELEM block[6][64])

  670. {

  671.     int i;

  672.     for(i=0;i<5;i++) {

  673.         encode_block(s, block[i], i);

  674.     }

  675.     if (s->chroma_format == CHROMA_420) {

  676.         encode_block(s, block[5], 5);

  677.     } else {

  678.         encode_block(s, block[6], 6);

  679.         encode_block(s, block[5], 5);

  680.         encode_block(s, block[7], 7);

  681.     }

  682. }

  683. 

  684. static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

  685.     MpegEncContext * const s = avctx->priv_data;

  686.     MJpegContext * const m = s->mjpeg_ctx;

  687.     AVFrame *pict = data;

  688.     const int width= s->width;

  689.     const int height= s->height;

  690.     AVFrame * const p= (AVFrame*)&s->current_picture;

  691.     const int predictor= avctx->prediction_method+1;

  692. 

  693.     init_put_bits(&s->pb, buf, buf_size);

  694. 

  695.     *p = *pict;

  696.     p->pict_type= FF_I_TYPE;

  697.     p->key_frame= 1;

  698. 

  699.     mjpeg_picture_header(s);

  700. 

  701.     s->header_bits= put_bits_count(&s->pb);

  702. 

  703.     if(avctx->pix_fmt == PIX_FMT_RGB32){

  704.         int x, y, i;

  705.         const int linesize= p->linesize[0];

  706.         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;

  707.         int left[3], top[3], topleft[3];

  708. 

  709.         for(i=0; i<3; i++){

  710.             buffer[0][i]= 1 << (9 - 1);

  711.         }

  712. 

  713.         for(y = 0; y < height; y++) {

  714.             const int modified_predictor= y ? predictor : 1;

  715.             uint8_t *ptr = p->data[0] + (linesize * y);

  716. 

  717.             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){

  718.                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  719.                 return -1;

  720.             }

  721. 

  722.             for(i=0; i<3; i++){

  723.                 top[i]= left[i]= topleft[i]= buffer[0][i];

  724.             }

  725.             for(x = 0; x < width; x++) {

  726.                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;

  727.                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;

  728.                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;

  729. 

  730.                 for(i=0;i<3;i++) {

  731.                     int pred, diff;

  732. 

  733.                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);

  734. 

  735.                     topleft[i]= top[i];

  736.                     top[i]= buffer[x+1][i];

  737. 

  738.                     left[i]= buffer[x][i];

  739. 

  740.                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;

  741. 

  742.                     if(i==0)

  743.                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly

  744.                     else

  745.                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);

  746.                 }

  747.             }

  748.         }

  749.     }else{

  750.         int mb_x, mb_y, i;

  751.         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];

  752.         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];

  753. 

  754.         for(mb_y = 0; mb_y < mb_height; mb_y++) {

  755.             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){

  756.                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  757.                 return -1;

  758.             }

  759.             for(mb_x = 0; mb_x < mb_width; mb_x++) {

  760.                 if(mb_x==0 || mb_y==0){

  761.                     for(i=0;i<3;i++) {

  762.                         uint8_t *ptr;

  763.                         int x, y, h, v, linesize;

  764.                         h = s->mjpeg_hsample[i];

  765.                         v = s->mjpeg_vsample[i];

  766.                         linesize= p->linesize[i];

  767. 

  768.                         for(y=0; y<v; y++){

  769.                             for(x=0; x<h; x++){

  770.                                 int pred;

  771. 

  772.                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

  773.                                 if(y==0 && mb_y==0){

  774.                                     if(x==0 && mb_x==0){

  775.                                         pred= 128;

  776.                                     }else{

  777.                                         pred= ptr[-1];

  778.                                     }

  779.                                 }else{

  780.                                     if(x==0 && mb_x==0){

  781.                                         pred= ptr[-linesize];

  782.                                     }else{

  783.                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  784.                                     }

  785.                                 }

  786. 

  787.                                 if(i==0)

  788.                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly

  789.                                 else

  790.                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);

  791.                             }

  792.                         }

  793.                     }

  794.                 }else{

  795.                     for(i=0;i<3;i++) {

  796.                         uint8_t *ptr;

  797.                         int x, y, h, v, linesize;

  798.                         h = s->mjpeg_hsample[i];

  799.                         v = s->mjpeg_vsample[i];

  800.                         linesize= p->linesize[i];

  801. 

  802.                         for(y=0; y<v; y++){

  803.                             for(x=0; x<h; x++){

  804.                                 int pred;

  805. 

  806.                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

  807. //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);

  808.                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  809. 

  810.                                 if(i==0)

  811.                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly

  812.                                 else

  813.                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);

  814.                             }

  815.                         }

  816.                     }

  817.                 }

  818.             }

  819.         }

  820.     }

  821. 

  822.     emms_c();

  823. 

  824.     mjpeg_picture_trailer(s);

  825.     s->picture_number++;

  826. 

  827.     flush_put_bits(&s->pb);

  828.     return pbBufPtr(&s->pb) - s->pb.buf;

  829. //    return (put_bits_count(&f->pb)+7)/8;

  830. }

  831. 

  832. #endif //CONFIG_ENCODERS

  833. 

  834. /******************************************/

  835. /* decoding */

  836. 

  837. #define MAX_COMPONENTS 4

  838. 

  839. typedef struct MJpegDecodeContext {

  840.     AVCodecContext *avctx;

  841.     GetBitContext gb;

  842.     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */

  843. 

  844.     int start_code; /* current start code */

  845.     int buffer_size;

  846.     uint8_t *buffer;

  847. 

  848.     int16_t quant_matrixes[4][64];

  849.     VLC vlcs[2][4];

  850.     int qscale[4];      ///< quantizer scale calculated from quant_matrixes

  851. 

  852.     int org_height;  /* size given at codec init */

  853.     int first_picture;    /* true if decoding first picture */

  854.     int interlaced;     /* true if interlaced */

  855.     int bottom_field;   /* true if bottom field */

  856.     int lossless;

  857.     int ls;

  858.     int progressive;

  859.     int rgb;

  860.     int rct;            /* standard rct */

  861.     int pegasus_rct;    /* pegasus reversible colorspace transform */

  862.     int bits;           /* bits per component */

  863. 

  864.     int maxval;

  865.     int near;         ///< near lossless bound (si 0 for lossless)

  866.     int t1,t2,t3;

  867.     int reset;        ///< context halfing intervall ?rename

  868. 

  869.     int width, height;

  870.     int mb_width, mb_height;

  871.     int nb_components;

  872.     int component_id[MAX_COMPONENTS];

  873.     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */

  874.     int v_count[MAX_COMPONENTS];

  875.     int comp_index[MAX_COMPONENTS];

  876.     int dc_index[MAX_COMPONENTS];

  877.     int ac_index[MAX_COMPONENTS];

  878.     int nb_blocks[MAX_COMPONENTS];

  879.     int h_scount[MAX_COMPONENTS];

  880.     int v_scount[MAX_COMPONENTS];

  881.     int h_max, v_max; /* maximum h and v counts */

  882.     int quant_index[4];   /* quant table index for each component */

  883.     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */

  884.     AVFrame picture; /* picture structure */

  885.     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced

  886.     int8_t *qscale_table;

  887.     DECLARE_ALIGNED_8(DCTELEM, block[64]);

  888.     ScanTable scantable;

  889.     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);

  890.     void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);

  891. 

  892.     int restart_interval;

  893.     int restart_count;

  894. 

  895.     int buggy_avid;

  896.     int cs_itu601;

  897.     int interlace_polarity;

  898. 

  899.     int mjpb_skiptosod;

  900. 

  901.     int cur_scan; /* current scan, used by JPEG-LS */

  902. } MJpegDecodeContext;

  903. 

  904. #include "jpeg_ls.c" //FIXME make jpeg-ls more independant

  905. 

  906. static int mjpeg_decode_dht(MJpegDecodeContext *s);

  907. 

  908. static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,

  909.                       int nb_codes, int use_static, int is_ac)

  910. {

  911.     uint8_t huff_size[256+16];

  912.     uint16_t huff_code[256+16];

  913. 

  914.     assert(nb_codes <= 256);

  915. 

  916.     memset(huff_size, 0, sizeof(huff_size));

  917.     build_huffman_codes(huff_size, huff_code, bits_table, val_table);

  918. 

  919.     if(is_ac){

  920.         memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);

  921.         memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);

  922.         memset(huff_size, 0, sizeof(uint8_t)*16);

  923.         memset(huff_code, 0, sizeof(uint16_t)*16);

  924.         nb_codes += 16;

  925.     }

  926. 

  927.     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);

  928. }

  929. 

  930. static int mjpeg_decode_init(AVCodecContext *avctx)

  931. {

  932.     MJpegDecodeContext *s = avctx->priv_data;

  933.     MpegEncContext s2;

  934.     memset(s, 0, sizeof(MJpegDecodeContext));

  935. 

  936.     s->avctx = avctx;

  937. 

  938.     /* ugly way to get the idct & scantable FIXME */

  939.     memset(&s2, 0, sizeof(MpegEncContext));

  940.     s2.avctx= avctx;

  941. //    s2->out_format = FMT_MJPEG;

  942.     dsputil_init(&s2.dsp, avctx);

  943.     DCT_common_init(&s2);

  944. 

  945.     s->scantable= s2.intra_scantable;

  946.     s->idct_put= s2.dsp.idct_put;

  947.     s->idct_add= s2.dsp.idct_add;

  948. 

  949.     s->mpeg_enc_ctx_allocated = 0;

  950.     s->buffer_size = 0;

  951.     s->buffer = NULL;

  952.     s->start_code = -1;

  953.     s->first_picture = 1;

  954.     s->org_height = avctx->coded_height;

  955. 

  956.     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);

  957.     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);

  958.     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);

  959.     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);

  960. 

  961.     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)

  962.     {

  963.         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");

  964.         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);

  965.         mjpeg_decode_dht(s);

  966.         /* should check for error - but dunno */

  967.     }

  968. 

  969.     return 0;

  970. }

  971. 

  972. 

  973. /**

  974.  * finds the end of the current frame in the bitstream.

  975.  * @return the position of the first byte of the next frame, or -1

  976.  */

  977. static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){

  978.     int vop_found, i;

  979.     uint16_t state;

  980. 

  981.     vop_found= pc->frame_start_found;

  982.     state= pc->state;

  983. 

  984.     i=0;

  985.     if(!vop_found){

  986.         for(i=0; i<buf_size; i++){

  987.             state= (state<<8) | buf[i];

  988.             if(state == 0xFFD8){

  989.                 i++;

  990.                 vop_found=1;

  991.                 break;

  992.             }

  993.         }

  994.     }

  995. 

  996.     if(vop_found){

  997.         /* EOF considered as end of frame */

  998.         if (buf_size == 0)

  999.             return 0;

  1000.         for(; i<buf_size; i++){

  1001.             state= (state<<8) | buf[i];

  1002.             if(state == 0xFFD8){

  1003.                 pc->frame_start_found=0;

  1004.                 pc->state=0;

  1005.                 return i-1;

  1006.             }

  1007.         }

  1008.     }

  1009.     pc->frame_start_found= vop_found;

  1010.     pc->state= state;

  1011.     return END_NOT_FOUND;

  1012. }

  1013. 

  1014. static int jpeg_parse(AVCodecParserContext *s,

  1015.                            AVCodecContext *avctx,

  1016.                            uint8_t **poutbuf, int *poutbuf_size,

  1017.                            const uint8_t *buf, int buf_size)

  1018. {

  1019.     ParseContext *pc = s->priv_data;

  1020.     int next;

  1021. 

  1022.     next= find_frame_end(pc, buf, buf_size);

  1023. 

  1024.     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {

  1025.         *poutbuf = NULL;

  1026.         *poutbuf_size = 0;

  1027.         return buf_size;

  1028.     }

  1029. 

  1030.     *poutbuf = (uint8_t *)buf;

  1031.     *poutbuf_size = buf_size;

  1032.     return next;

  1033. }

  1034. 

  1035. /* quantize tables */

  1036. static int mjpeg_decode_dqt(MJpegDecodeContext *s)

  1037. {

  1038.     int len, index, i, j;

  1039. 

  1040.     len = get_bits(&s->gb, 16) - 2;

  1041. 

  1042.     while (len >= 65) {

  1043.         /* only 8 bit precision handled */

  1044.         if (get_bits(&s->gb, 4) != 0)

  1045.         {

  1046.             av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");

  1047.             return -1;

  1048.         }

  1049.         index = get_bits(&s->gb, 4);

  1050.         if (index >= 4)

  1051.             return -1;

  1052.         av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);

  1053.         /* read quant table */

  1054.         for(i=0;i<64;i++) {

  1055.             j = s->scantable.permutated[i];

  1056.             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);

  1057.         }

  1058. 

  1059.         //XXX FIXME finetune, and perhaps add dc too

  1060.         s->qscale[index]= FFMAX(

  1061.             s->quant_matrixes[index][s->scantable.permutated[1]],

  1062.             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;

  1063.         av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);

  1064.         len -= 65;

  1065.     }

  1066. 

  1067.     return 0;

  1068. }

  1069. 

  1070. /* decode huffman tables and build VLC decoders */

  1071. static int mjpeg_decode_dht(MJpegDecodeContext *s)

  1072. {

  1073.     int len, index, i, class, n, v, code_max;

  1074.     uint8_t bits_table[17];

  1075.     uint8_t val_table[256];

  1076. 

  1077.     len = get_bits(&s->gb, 16) - 2;

  1078. 

  1079.     while (len > 0) {

  1080.         if (len < 17)

  1081.             return -1;

  1082.         class = get_bits(&s->gb, 4);

  1083.         if (class >= 2)

  1084.             return -1;

  1085.         index = get_bits(&s->gb, 4);

  1086.         if (index >= 4)

  1087.             return -1;

  1088.         n = 0;

  1089.         for(i=1;i<=16;i++) {

  1090.             bits_table[i] = get_bits(&s->gb, 8);

  1091.             n += bits_table[i];

  1092.         }

  1093.         len -= 17;

  1094.         if (len < n || n > 256)

  1095.             return -1;

  1096. 

  1097.         code_max = 0;

  1098.         for(i=0;i<n;i++) {

  1099.             v = get_bits(&s->gb, 8);

  1100.             if (v > code_max)

  1101.                 code_max = v;

  1102.             val_table[i] = v;

  1103.         }

  1104.         len -= n;

  1105. 

  1106.         /* build VLC and flush previous vlc if present */

  1107.         free_vlc(&s->vlcs[class][index]);

  1108.         av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",

  1109.                class, index, code_max + 1);

  1110.         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){

  1111.             return -1;

  1112.         }

  1113.     }

  1114.     return 0;

  1115. }

  1116. 

  1117. static int mjpeg_decode_sof(MJpegDecodeContext *s)

  1118. {

  1119.     int len, nb_components, i, width, height, pix_fmt_id;

  1120. 

  1121.     /* XXX: verify len field validity */

  1122.     len = get_bits(&s->gb, 16);

  1123.     s->bits= get_bits(&s->gb, 8);

  1124. 

  1125.     if(s->pegasus_rct) s->bits=9;

  1126.     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly

  1127. 

  1128.     if (s->bits != 8 && !s->lossless){

  1129.         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");

  1130.         return -1;

  1131.     }

  1132. 

  1133.     height = get_bits(&s->gb, 16);

  1134.     width = get_bits(&s->gb, 16);

  1135. 

  1136.     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);

  1137.     if(avcodec_check_dimensions(s->avctx, width, height))

  1138.         return -1;

  1139. 

  1140.     nb_components = get_bits(&s->gb, 8);

  1141.     if (nb_components <= 0 ||

  1142.         nb_components > MAX_COMPONENTS)

  1143.         return -1;

  1144.     if (s->ls && !(s->bits <= 8 || nb_components == 1)){

  1145.         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");

  1146.         return -1;

  1147.     }

  1148.     s->nb_components = nb_components;

  1149.     s->h_max = 1;

  1150.     s->v_max = 1;

  1151.     for(i=0;i<nb_components;i++) {

  1152.         /* component id */

  1153.         s->component_id[i] = get_bits(&s->gb, 8) - 1;

  1154.         s->h_count[i] = get_bits(&s->gb, 4);

  1155.         s->v_count[i] = get_bits(&s->gb, 4);

  1156.         /* compute hmax and vmax (only used in interleaved case) */

  1157.         if (s->h_count[i] > s->h_max)

  1158.             s->h_max = s->h_count[i];

  1159.         if (s->v_count[i] > s->v_max)

  1160.             s->v_max = s->v_count[i];

  1161.         s->quant_index[i] = get_bits(&s->gb, 8);

  1162.         if (s->quant_index[i] >= 4)

  1163.             return -1;

  1164.         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],

  1165.                s->v_count[i], s->component_id[i], s->quant_index[i]);

  1166.     }

  1167. 

  1168.     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {

  1169.         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");

  1170.         return -1;

  1171.     }

  1172. 

  1173.     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;

  1174. 

  1175.     /* if different size, realloc/alloc picture */

  1176.     /* XXX: also check h_count and v_count */

  1177.     if (width != s->width || height != s->height) {

  1178.         av_freep(&s->qscale_table);

  1179. 

  1180.         s->width = width;

  1181.         s->height = height;

  1182. 

  1183.         /* test interlaced mode */

  1184.         if (s->first_picture &&

  1185.             s->org_height != 0 &&

  1186.             s->height < ((s->org_height * 3) / 4)) {

  1187.             s->interlaced = 1;

  1188. //            s->bottom_field = (s->interlace_polarity) ? 1 : 0;

  1189.             s->bottom_field = 0;

  1190.             height *= 2;

  1191.         }

  1192. 

  1193.         avcodec_set_dimensions(s->avctx, width, height);

  1194. 

  1195.         s->qscale_table= av_mallocz((s->width+15)/16);

  1196. 

  1197.         s->first_picture = 0;

  1198.     }

  1199. 

  1200.     if(s->interlaced && s->bottom_field)

  1201.         return 0;

  1202. 

  1203.     /* XXX: not complete test ! */

  1204.     pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |

  1205.                  (s->h_count[1] << 12) | (s->v_count[1] <<  8) |

  1206.                  (s->h_count[2] <<  4) |  s->v_count[2];

  1207.     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);

  1208.     switch(pix_fmt_id){

  1209.     case 0x222222:

  1210.     case 0x111111:

  1211.         if(s->rgb){

  1212.             s->avctx->pix_fmt = PIX_FMT_RGB32;

  1213.         }else if(s->nb_components==3)

  1214.             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;

  1215.         else

  1216.             s->avctx->pix_fmt = PIX_FMT_GRAY8;

  1217.         break;

  1218.     case 0x211111:

  1219.     case 0x221212:

  1220.         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;

  1221.         break;

  1222.     default:

  1223.     case 0x221111:

  1224.         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;

  1225.         break;

  1226.     }

  1227.     if(s->ls){

  1228.         if(s->nb_components > 1)

  1229.             s->avctx->pix_fmt = PIX_FMT_RGB24;

  1230.         else if(s->bits <= 8)

  1231.             s->avctx->pix_fmt = PIX_FMT_GRAY8;

  1232.         else

  1233.             s->avctx->pix_fmt = PIX_FMT_GRAY16;

  1234.     }

  1235. 

  1236.     if(s->picture.data[0])

  1237.         s->avctx->release_buffer(s->avctx, &s->picture);

  1238. 

  1239.     s->picture.reference= 0;

  1240.     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){

  1241.         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1242.         return -1;

  1243.     }

  1244.     s->picture.pict_type= I_TYPE;

  1245.     s->picture.key_frame= 1;

  1246. 

  1247.     for(i=0; i<3; i++){

  1248.         s->linesize[i]= s->picture.linesize[i] << s->interlaced;

  1249.     }

  1250. 

  1251. //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);

  1252. 

  1253.     if (len != (8+(3*nb_components)))

  1254.     {

  1255.         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);

  1256.     }

  1257. 

  1258.     /* totally blank picture as progressive JPEG will only add details to it */

  1259.     if(s->progressive){

  1260.         memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);

  1261.         memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));

  1262.         memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));

  1263.     }

  1264.     return 0;

  1265. }

  1266. 

  1267. static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)

  1268. {

  1269.     int code;

  1270.     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);

  1271.     if (code < 0)

  1272.     {

  1273.         av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,

  1274.                &s->vlcs[0][dc_index]);

  1275.         return 0xffff;

  1276.     }

  1277. 

  1278.     if(code)

  1279.         return get_xbits(&s->gb, code);

  1280.     else

  1281.         return 0;

  1282. }

  1283. 

  1284. /* decode block and dequantize */

  1285. static int decode_block(MJpegDecodeContext *s, DCTELEM *block,

  1286.                         int component, int dc_index, int ac_index, int16_t *quant_matrix)

  1287. {

  1288.     int code, i, j, level, val;

  1289. 

  1290.     /* DC coef */

  1291.     val = mjpeg_decode_dc(s, dc_index);

  1292.     if (val == 0xffff) {

  1293.         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");

  1294.         return -1;

  1295.     }

  1296.     val = val * quant_matrix[0] + s->last_dc[component];

  1297.     s->last_dc[component] = val;

  1298.     block[0] = val;

  1299.     /* AC coefs */

  1300.     i = 0;

  1301.     {OPEN_READER(re, &s->gb)

  1302.     for(;;) {

  1303.         UPDATE_CACHE(re, &s->gb);

  1304.         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)

  1305. 

  1306.         /* EOB */

  1307.         if (code == 0x10)

  1308.             break;

  1309.         i += ((unsigned)code) >> 4;

  1310.         if(code != 0x100){

  1311.             code &= 0xf;

  1312.             if(code > MIN_CACHE_BITS - 16){

  1313.                 UPDATE_CACHE(re, &s->gb)

  1314.             }

  1315.             {

  1316.                 int cache=GET_CACHE(re,&s->gb);

  1317.                 int sign=(~cache)>>31;

  1318.                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;

  1319.             }

  1320. 

  1321.             LAST_SKIP_BITS(re, &s->gb, code)

  1322. 

  1323.             if (i >= 63) {

  1324.                 if(i == 63){

  1325.                     j = s->scantable.permutated[63];

  1326.                     block[j] = level * quant_matrix[j];

  1327.                     break;

  1328.                 }

  1329.                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);

  1330.                 return -1;

  1331.             }

  1332.             j = s->scantable.permutated[i];

  1333.             block[j] = level * quant_matrix[j];

  1334.         }

  1335.     }

  1336.     CLOSE_READER(re, &s->gb)}

  1337. 

  1338.     return 0;

  1339. }

  1340. 

  1341. /* decode block and dequantize - progressive JPEG version */

  1342. static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,

  1343.                         int component, int dc_index, int ac_index, int16_t *quant_matrix,

  1344.                         int ss, int se, int Ah, int Al, int *EOBRUN)

  1345. {

  1346.     int code, i, j, level, val, run;

  1347. 

  1348.     /* DC coef */

  1349.     if(!ss){

  1350.         val = mjpeg_decode_dc(s, dc_index);

  1351.         if (val == 0xffff) {

  1352.             av_log(s->avctx, AV_LOG_ERROR, "error dc\n");

  1353.             return -1;

  1354.         }

  1355.         val = (val * quant_matrix[0] << Al) + s->last_dc[component];

  1356.     }else

  1357.         val = 0;

  1358.     s->last_dc[component] = val;

  1359.     block[0] = val;

  1360.     if(!se) return 0;

  1361.     /* AC coefs */

  1362.     if(*EOBRUN){

  1363.         (*EOBRUN)--;

  1364.         return 0;

  1365.     }

  1366.     {OPEN_READER(re, &s->gb)

  1367.     for(i=ss;;i++) {

  1368.         UPDATE_CACHE(re, &s->gb);

  1369.         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)

  1370.         /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */

  1371.         code -= 16;

  1372.         if(code & 0xF) {

  1373.             i += ((unsigned) code) >> 4;

  1374.             code &= 0xf;

  1375.             if(code > MIN_CACHE_BITS - 16){

  1376.                 UPDATE_CACHE(re, &s->gb)

  1377.             }

  1378.             {

  1379.                 int cache=GET_CACHE(re,&s->gb);

  1380.                 int sign=(~cache)>>31;

  1381.                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;

  1382.             }

  1383. 

  1384.             LAST_SKIP_BITS(re, &s->gb, code)

  1385. 

  1386.             if (i >= se) {

  1387.                 if(i == se){

  1388.                     j = s->scantable.permutated[se];

  1389.                     block[j] = level * quant_matrix[j] << Al;

  1390.                     break;

  1391.                 }

  1392.                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);

  1393.                 return -1;

  1394.             }

  1395.             j = s->scantable.permutated[i];

  1396.             block[j] = level * quant_matrix[j] << Al;

  1397.         }else{

  1398.             run = ((unsigned) code) >> 4;

  1399.             if(run == 0xF){// ZRL - skip 15 coefficients

  1400.                 i += 15;

  1401.             }else{

  1402.                 val = run;

  1403.                 run = (1 << run);

  1404.                 UPDATE_CACHE(re, &s->gb);

  1405.                 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);

  1406.                 if(val)

  1407.                     LAST_SKIP_BITS(re, &s->gb, val);

  1408.                 *EOBRUN = run - 1;

  1409.                 break;

  1410.             }

  1411.         }

  1412.     }

  1413.     CLOSE_READER(re, &s->gb)}

  1414. 

  1415.     return 0;

  1416. }

  1417. 

  1418. static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){

  1419.     int i, mb_x, mb_y;

  1420.     uint16_t buffer[32768][4];

  1421.     int left[3], top[3], topleft[3];

  1422.     const int linesize= s->linesize[0];

  1423.     const int mask= (1<<s->bits)-1;

  1424. 

  1425.     if((unsigned)s->mb_width > 32768) //dynamic alloc

  1426.         return -1;

  1427. 

  1428.     for(i=0; i<3; i++){

  1429.         buffer[0][i]= 1 << (s->bits + point_transform - 1);

  1430.     }

  1431.     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1432.         const int modified_predictor= mb_y ? predictor : 1;

  1433.         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);

  1434. 

  1435.         if (s->interlaced && s->bottom_field)

  1436.             ptr += linesize >> 1;

  1437. 

  1438.         for(i=0; i<3; i++){

  1439.             top[i]= left[i]= topleft[i]= buffer[0][i];

  1440.         }

  1441.         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1442.             if (s->restart_interval && !s->restart_count)

  1443.                 s->restart_count = s->restart_interval;

  1444. 

  1445.             for(i=0;i<3;i++) {

  1446.                 int pred;

  1447. 

  1448.                 topleft[i]= top[i];

  1449.                 top[i]= buffer[mb_x][i];

  1450. 

  1451.                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);

  1452. 

  1453.                 left[i]=

  1454.                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));

  1455.             }

  1456. 

  1457.             if (s->restart_interval && !--s->restart_count) {

  1458.                 align_get_bits(&s->gb);

  1459.                 skip_bits(&s->gb, 16); /* skip RSTn */

  1460.             }

  1461.         }

  1462. 

  1463.         if(s->rct){

  1464.             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1465.                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);

  1466.                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];

  1467.                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];

  1468.             }

  1469.         }else if(s->pegasus_rct){

  1470.             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1471.                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);

  1472.                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];

  1473.                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];

  1474.             }

  1475.         }else{

  1476.             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1477.                 ptr[4*mb_x+0] = buffer[mb_x][0];

  1478.                 ptr[4*mb_x+1] = buffer[mb_x][1];

  1479.                 ptr[4*mb_x+2] = buffer[mb_x][2];

  1480.             }

  1481.         }

  1482.     }

  1483.     return 0;

  1484. }

  1485. 

  1486. static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){

  1487.     int i, mb_x, mb_y;

  1488.     const int nb_components=3;

  1489. 

  1490.     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1491.         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1492.             if (s->restart_interval && !s->restart_count)

  1493.                 s->restart_count = s->restart_interval;

  1494. 

  1495.             if(mb_x==0 || mb_y==0 || s->interlaced){

  1496.                 for(i=0;i<nb_components;i++) {

  1497.                     uint8_t *ptr;

  1498.                     int n, h, v, x, y, c, j, linesize;

  1499.                     n = s->nb_blocks[i];

  1500.                     c = s->comp_index[i];

  1501.                     h = s->h_scount[i];

  1502.                     v = s->v_scount[i];

  1503.                     x = 0;

  1504.                     y = 0;

  1505.                     linesize= s->linesize[c];

  1506. 

  1507.                     for(j=0; j<n; j++) {

  1508.                         int pred;

  1509. 

  1510.                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

  1511.                         if(y==0 && mb_y==0){

  1512.                             if(x==0 && mb_x==0){

  1513.                                 pred= 128 << point_transform;

  1514.                             }else{

  1515.                                 pred= ptr[-1];

  1516.                             }

  1517.                         }else{

  1518.                             if(x==0 && mb_x==0){

  1519.                                 pred= ptr[-linesize];

  1520.                             }else{

  1521.                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  1522.                             }

  1523.                         }

  1524. 

  1525.                         if (s->interlaced && s->bottom_field)

  1526.                             ptr += linesize >> 1;

  1527.                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);

  1528. 

  1529.                         if (++x == h) {

  1530.                             x = 0;

  1531.                             y++;

  1532.                         }

  1533.                     }

  1534.                 }

  1535.             }else{

  1536.                 for(i=0;i<nb_components;i++) {

  1537.                     uint8_t *ptr;

  1538.                     int n, h, v, x, y, c, j, linesize;

  1539.                     n = s->nb_blocks[i];

  1540.                     c = s->comp_index[i];

  1541.                     h = s->h_scount[i];

  1542.                     v = s->v_scount[i];

  1543.                     x = 0;

  1544.                     y = 0;

  1545.                     linesize= s->linesize[c];

  1546. 

  1547.                     for(j=0; j<n; j++) {

  1548.                         int pred;

  1549. 

  1550.                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

  1551.                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);

  1552.                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);

  1553.                         if (++x == h) {

  1554.                             x = 0;

  1555.                             y++;

  1556.                         }

  1557.                     }

  1558.                 }

  1559.             }

  1560.             if (s->restart_interval && !--s->restart_count) {

  1561.                 align_get_bits(&s->gb);

  1562.                 skip_bits(&s->gb, 16); /* skip RSTn */

  1563.             }

  1564.         }

  1565.     }

  1566.     return 0;

  1567. }

  1568. 

  1569. static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){

  1570.     int i, mb_x, mb_y;

  1571.     int EOBRUN = 0;

  1572. 

  1573.     if(Ah) return 0; /* TODO decode refinement planes too */

  1574.     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {

  1575.         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {

  1576.             if (s->restart_interval && !s->restart_count)

  1577.                 s->restart_count = s->restart_interval;

  1578. 

  1579.             for(i=0;i<nb_components;i++) {

  1580.                 uint8_t *ptr;

  1581.                 int n, h, v, x, y, c, j;

  1582.                 n = s->nb_blocks[i];

  1583.                 c = s->comp_index[i];

  1584.                 h = s->h_scount[i];

  1585.                 v = s->v_scount[i];

  1586.                 x = 0;

  1587.                 y = 0;

  1588.                 for(j=0;j<n;j++) {

  1589.                     memset(s->block, 0, sizeof(s->block));

  1590.                     if (!s->progressive && decode_block(s, s->block, i,

  1591.                                      s->dc_index[i], s->ac_index[i],

  1592.                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {

  1593.                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);

  1594.                         return -1;

  1595.                     }

  1596.                     if (s->progressive && decode_block_progressive(s, s->block, i,

  1597.                                      s->dc_index[i], s->ac_index[i],

  1598.                                      s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {

  1599.                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);

  1600.                         return -1;

  1601.                     }

  1602. //                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);

  1603.                     ptr = s->picture.data[c] +

  1604.                         (((s->linesize[c] * (v * mb_y + y) * 8) +

  1605.                         (h * mb_x + x) * 8) >> s->avctx->lowres);

  1606.                     if (s->interlaced && s->bottom_field)

  1607.                         ptr += s->linesize[c] >> 1;

  1608. //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);

  1609.                     if(!s->progressive)

  1610.                         s->idct_put(ptr, s->linesize[c], s->block);

  1611.                     else

  1612.                         s->idct_add(ptr, s->linesize[c], s->block);

  1613.                     if (++x == h) {

  1614.                         x = 0;

  1615.                         y++;

  1616.                     }

  1617.                 }

  1618.             }

  1619.             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */

  1620.             if (s->restart_interval && (s->restart_interval < 1350) &&

  1621.                 !--s->restart_count) {

  1622.                 align_get_bits(&s->gb);

  1623.                 skip_bits(&s->gb, 16); /* skip RSTn */

  1624.                 for (i=0; i<nb_components; i++) /* reset dc */

  1625.                     s->last_dc[i] = 1024;

  1626.             }

  1627.         }

  1628.     }

  1629.     return 0;

  1630. }

  1631. 

  1632. static int mjpeg_decode_sos(MJpegDecodeContext *s)

  1633. {

  1634.     int len, nb_components, i, h, v, predictor, point_transform;

  1635.     int vmax, hmax, index, id;

  1636.     const int block_size= s->lossless ? 1 : 8;

  1637.     int ilv, prev_shift;

  1638. 

  1639.     /* XXX: verify len field validity */

  1640.     len = get_bits(&s->gb, 16);

  1641.     nb_components = get_bits(&s->gb, 8);

  1642.     if (len != 6+2*nb_components)

  1643.     {

  1644.         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);

  1645.         return -1;

  1646.     }

  1647.     vmax = 0;

  1648.     hmax = 0;

  1649.     for(i=0;i<nb_components;i++) {

  1650.         id = get_bits(&s->gb, 8) - 1;

  1651.         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);

  1652.         /* find component index */

  1653.         for(index=0;index<s->nb_components;index++)

  1654.             if (id == s->component_id[index])

  1655.                 break;

  1656.         if (index == s->nb_components)

  1657.         {

  1658.             av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);

  1659.             return -1;

  1660.         }

  1661. 

  1662.         s->comp_index[i] = index;

  1663. 

  1664.         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];

  1665.         s->h_scount[i] = s->h_count[index];

  1666.         s->v_scount[i] = s->v_count[index];

  1667. 

  1668.         s->dc_index[i] = get_bits(&s->gb, 4);

  1669.         s->ac_index[i] = get_bits(&s->gb, 4);

  1670. 

  1671.         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||

  1672.             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)

  1673.             goto out_of_range;

  1674. #if 0 //buggy

  1675.         switch(s->start_code)

  1676.         {

  1677.             case SOF0:

  1678.                 if (dc_index[i] > 1 || ac_index[i] > 1)

  1679.                     goto out_of_range;

  1680.                 break;

  1681.             case SOF1:

  1682.             case SOF2:

  1683.                 if (dc_index[i] > 3 || ac_index[i] > 3)

  1684.                     goto out_of_range;

  1685.                 break;

  1686.             case SOF3:

  1687.                 if (dc_index[i] > 3 || ac_index[i] != 0)

  1688.                     goto out_of_range;

  1689.                 break;

  1690.         }

  1691. #endif

  1692.     }

  1693. 

  1694.     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */

  1695.     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */

  1696.     prev_shift = get_bits(&s->gb, 4); /* Ah */

  1697.     point_transform= get_bits(&s->gb, 4); /* Al */

  1698. 

  1699.     for(i=0;i<nb_components;i++)

  1700.         s->last_dc[i] = 1024;

  1701. 

  1702.     if (nb_components > 1) {

  1703.         /* interleaved stream */

  1704.         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);

  1705.         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);

  1706.     } else if(!s->ls) { /* skip this for JPEG-LS */

  1707.         h = s->h_max / s->h_scount[0];

  1708.         v = s->v_max / s->v_scount[0];

  1709.         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);

  1710.         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);

  1711.         s->nb_blocks[0] = 1;

  1712.         s->h_scount[0] = 1;

  1713.         s->v_scount[0] = 1;

  1714.     }

  1715. 

  1716.     if(s->avctx->debug & FF_DEBUG_PICT_INFO)

  1717.         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",

  1718.                predictor, point_transform, ilv, s->bits,

  1719.                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));

  1720. 

  1721. 

  1722.     /* mjpeg-b can have padding bytes between sos and image data, skip them */

  1723.     for (i = s->mjpb_skiptosod; i > 0; i--)

  1724.         skip_bits(&s->gb, 8);

  1725. 

  1726.     if(s->lossless){

  1727.         if(s->ls){

  1728. //            for(){

  1729. //            reset_ls_coding_parameters(s, 0);

  1730. 

  1731.             ls_decode_picture(s, predictor, point_transform, ilv);

  1732.         }else{

  1733.             if(s->rgb){

  1734.                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)

  1735.                     return -1;

  1736.             }else{

  1737.                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)

  1738.                     return -1;

  1739.             }

  1740.         }

  1741.     }else{

  1742.         if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)

  1743.             return -1;

  1744.     }

  1745.     emms_c();

  1746.     return 0;

  1747.  out_of_range:

  1748.     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");

  1749.     return -1;

  1750. }

  1751. 

  1752. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1753. {

  1754.     if (get_bits(&s->gb, 16) != 4)

  1755.         return -1;

  1756.     s->restart_interval = get_bits(&s->gb, 16);

  1757.     s->restart_count = 0;

  1758.     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);

  1759. 

  1760.     return 0;

  1761. }

  1762. 

  1763. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1764. {

  1765.     int len, id;

  1766. 

  1767.     len = get_bits(&s->gb, 16);

  1768.     if (len < 5)

  1769.         return -1;

  1770.     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)

  1771.         return -1;

  1772. 

  1773.     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);

  1774.     id = be2me_32(id);

  1775.     len -= 6;

  1776. 

  1777.     if(s->avctx->debug & FF_DEBUG_STARTCODE){

  1778.         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);

  1779.     }

  1780. 

  1781.     /* buggy AVID, it puts EOI only at every 10th frame */

  1782.     /* also this fourcc is used by non-avid files too, it holds some

  1783.        informations, but it's always present in AVID creates files */

  1784.     if (id == ff_get_fourcc("AVI1"))

  1785.     {

  1786.         /* structure:

  1787.             4bytes      AVI1

  1788.             1bytes      polarity

  1789.             1bytes      always zero

  1790.             4bytes      field_size

  1791.             4bytes      field_size_less_padding

  1792.         */

  1793.             s->buggy_avid = 1;

  1794. //        if (s->first_picture)

  1795. //            printf("mjpeg: workarounding buggy AVID\n");

  1796.         s->interlace_polarity = get_bits(&s->gb, 8);

  1797. #if 0

  1798.         skip_bits(&s->gb, 8);

  1799.         skip_bits(&s->gb, 32);

  1800.         skip_bits(&s->gb, 32);

  1801.         len -= 10;

  1802. #endif

  1803. //        if (s->interlace_polarity)

  1804. //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);

  1805.         goto out;

  1806.     }

  1807. 

  1808. //    len -= 2;

  1809. 

  1810.     if (id == ff_get_fourcc("JFIF"))

  1811.     {

  1812.         int t_w, t_h, v1, v2;

  1813.         skip_bits(&s->gb, 8); /* the trailing zero-byte */

  1814.         v1= get_bits(&s->gb, 8);

  1815.         v2= get_bits(&s->gb, 8);

  1816.         skip_bits(&s->gb, 8);

  1817. 

  1818.         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);

  1819.         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);

  1820. 

  1821.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1822.             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",

  1823.                 v1, v2,

  1824.                 s->avctx->sample_aspect_ratio.num,

  1825.                 s->avctx->sample_aspect_ratio.den

  1826.             );

  1827. 

  1828.         t_w = get_bits(&s->gb, 8);

  1829.         t_h = get_bits(&s->gb, 8);

  1830.         if (t_w && t_h)

  1831.         {

  1832.             /* skip thumbnail */

  1833.             if (len-10-(t_w*t_h*3) > 0)

  1834.                 len -= t_w*t_h*3;

  1835.         }

  1836.         len -= 10;

  1837.         goto out;

  1838.     }

  1839. 

  1840.     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))

  1841.     {

  1842.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1843.             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");

  1844.         skip_bits(&s->gb, 16); /* version */

  1845.         skip_bits(&s->gb, 16); /* flags0 */

  1846.         skip_bits(&s->gb, 16); /* flags1 */

  1847.         skip_bits(&s->gb, 8);  /* transform */

  1848.         len -= 7;

  1849.         goto out;

  1850.     }

  1851. 

  1852.     if (id == ff_get_fourcc("LJIF")){

  1853.         if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1854.             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");

  1855.         skip_bits(&s->gb, 16); /* version ? */

  1856.         skip_bits(&s->gb, 16); /* unknwon always 0? */

  1857.         skip_bits(&s->gb, 16); /* unknwon always 0? */

  1858.         skip_bits(&s->gb, 16); /* unknwon always 0? */

  1859.         switch( get_bits(&s->gb, 8)){

  1860.         case 1:

  1861.             s->rgb= 1;

  1862.             s->pegasus_rct=0;

  1863.             break;

  1864.         case 2:

  1865.             s->rgb= 1;

  1866.             s->pegasus_rct=1;

  1867.             break;

  1868.         default:

  1869.             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");

  1870.         }

  1871.         len -= 9;

  1872.         goto out;

  1873.     }

  1874. 

  1875.     /* Apple MJPEG-A */

  1876.     if ((s->start_code == APP1) && (len > (0x28 - 8)))

  1877.     {

  1878.         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);

  1879.         id = be2me_32(id);

  1880.         len -= 4;

  1881.         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */

  1882.         {

  1883. #if 0

  1884.             skip_bits(&s->gb, 32); /* field size */

  1885.             skip_bits(&s->gb, 32); /* pad field size */

  1886.             skip_bits(&s->gb, 32); /* next off */

  1887.             skip_bits(&s->gb, 32); /* quant off */

  1888.             skip_bits(&s->gb, 32); /* huff off */

  1889.             skip_bits(&s->gb, 32); /* image off */

  1890.             skip_bits(&s->gb, 32); /* scan off */

  1891.             skip_bits(&s->gb, 32); /* data off */

  1892. #endif

  1893.             if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1894.                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");

  1895.         }

  1896.     }

  1897. 

  1898. out:

  1899.     /* slow but needed for extreme adobe jpegs */

  1900.     if (len < 0)

  1901.         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");

  1902.     while(--len > 0)

  1903.         skip_bits(&s->gb, 8);

  1904. 

  1905.     return 0;

  1906. }

  1907. 

  1908. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1909. {

  1910.     int len = get_bits(&s->gb, 16);

  1911.     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {

  1912.         char *cbuf = av_malloc(len - 1);

  1913.         if (cbuf) {

  1914.             int i;

  1915.             for (i = 0; i < len - 2; i++)

  1916.                 cbuf[i] = get_bits(&s->gb, 8);

  1917.             if (i > 0 && cbuf[i-1] == '\n')

  1918.                 cbuf[i-1] = 0;

  1919.             else

  1920.                 cbuf[i] = 0;

  1921. 

  1922.             if(s->avctx->debug & FF_DEBUG_PICT_INFO)

  1923.                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);

  1924. 

  1925.             /* buggy avid, it puts EOI only at every 10th frame */

  1926.             if (!strcmp(cbuf, "AVID"))

  1927.             {

  1928.                 s->buggy_avid = 1;

  1929.                 //        if (s->first_picture)

  1930.                 //            printf("mjpeg: workarounding buggy AVID\n");

  1931.             }

  1932.             else if(!strcmp(cbuf, "CS=ITU601")){

  1933.                 s->cs_itu601= 1;

  1934.             }

  1935. 

  1936.             av_free(cbuf);

  1937.         }

  1938.     }

  1939. 

  1940.     return 0;

  1941. }

  1942. 

  1943. #if 0

  1944. static int valid_marker_list[] =

  1945. {

  1946.         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */

  1947. /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1948. /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1949. /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1950. /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1951. /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1952. /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1953. /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1954. /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1955. /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1956. /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1957. /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1958. /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1959. /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1960. /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1961. /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1962. /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

  1963. }

  1964. #endif

  1965. 

  1966. /* return the 8 bit start code value and update the search

  1967.    state. Return -1 if no start code found */

  1968. static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)

  1969. {

  1970.     uint8_t *buf_ptr;

  1971.     unsigned int v, v2;

  1972.     int val;

  1973. #ifdef DEBUG

  1974.     int skipped=0;

  1975. #endif

  1976. 

  1977.     buf_ptr = *pbuf_ptr;

  1978.     while (buf_ptr < buf_end) {

  1979.         v = *buf_ptr++;

  1980.         v2 = *buf_ptr;

  1981.         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {

  1982.             val = *buf_ptr++;

  1983.             goto found;

  1984.         }

  1985. #ifdef DEBUG

  1986.         skipped++;

  1987. #endif

  1988.     }

  1989.     val = -1;

  1990. found:

  1991. #ifdef DEBUG

  1992.     av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);

  1993. #endif

  1994.     *pbuf_ptr = buf_ptr;

  1995.     return val;

  1996. }

  1997. 

  1998. static int mjpeg_decode_frame(AVCodecContext *avctx,

  1999.                               void *data, int *data_size,

  2000.                               uint8_t *buf, int buf_size)

  2001. {

  2002.     MJpegDecodeContext *s = avctx->priv_data;

  2003.     uint8_t *buf_end, *buf_ptr;

  2004.     int start_code;

  2005.     AVFrame *picture = data;

  2006. 

  2007.     buf_ptr = buf;

  2008.     buf_end = buf + buf_size;

  2009.     while (buf_ptr < buf_end) {

  2010.         /* find start next marker */

  2011.         start_code = find_marker(&buf_ptr, buf_end);

  2012.         {

  2013.             /* EOF */

  2014.             if (start_code < 0) {

  2015.                 goto the_end;

  2016.             } else {

  2017.                 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);

  2018. 

  2019.                 if ((buf_end - buf_ptr) > s->buffer_size)

  2020.                 {

  2021.                     av_free(s->buffer);

  2022.                     s->buffer_size = buf_end-buf_ptr;

  2023.                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);

  2024.                     av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",

  2025.                         s->buffer_size);

  2026.                 }

  2027. 

  2028.                 /* unescape buffer of SOS, use special treatment for JPEG-LS */

  2029.                 if (start_code == SOS && !s->ls)

  2030.                 {

  2031.                     uint8_t *src = buf_ptr;

  2032.                     uint8_t *dst = s->buffer;

  2033. 

  2034.                     while (src<buf_end)

  2035.                     {

  2036.                         uint8_t x = *(src++);

  2037. 

  2038.                         *(dst++) = x;

  2039.                         if (x == 0xff)

  2040.                         {

  2041.                             while(src<buf_end && x == 0xff)

  2042.                                 x = *(src++);

  2043. 

  2044.                             if (x >= 0xd0 && x <= 0xd7)

  2045.                                 *(dst++) = x;

  2046.                             else if (x)

  2047.                                 break;

  2048.                         }

  2049.                     }

  2050.                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);

  2051. 

  2052.                     av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",

  2053.                            (buf_end - buf_ptr) - (dst - s->buffer));

  2054.                 }

  2055.                 else if(start_code == SOS && s->ls){

  2056.                     uint8_t *src = buf_ptr;

  2057.                     uint8_t *dst = s->buffer;

  2058.                     int bit_count = 0;

  2059.                     int t = 0, b = 0;

  2060.                     PutBitContext pb;

  2061. 

  2062.                     s->cur_scan++;

  2063. 

  2064.                     /* find marker */

  2065.                     while (src + t < buf_end){

  2066.                         uint8_t x = src[t++];

  2067.                         if (x == 0xff){

  2068.                             while((src + t < buf_end) && x == 0xff)

  2069.                                 x = src[t++];

  2070.                             if (x & 0x80) {

  2071.                                 t -= 2;

  2072.                                 break;

  2073.                             }

  2074.                         }

  2075.                     }

  2076.                     bit_count = t * 8;

  2077. 

  2078.                     init_put_bits(&pb, dst, t);

  2079. 

  2080.                     /* unescape bitstream */

  2081.                     while(b < t){

  2082.                         uint8_t x = src[b++];

  2083.                         put_bits(&pb, 8, x);

  2084.                         if(x == 0xFF){

  2085.                             x = src[b++];

  2086.                             put_bits(&pb, 7, x);

  2087.                             bit_count--;

  2088.                         }

  2089.                     }

  2090.                     flush_put_bits(&pb);

  2091. 

  2092.                     init_get_bits(&s->gb, dst, bit_count);

  2093.                 }

  2094.                 else

  2095.                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);

  2096. 

  2097.                 s->start_code = start_code;

  2098.                 if(s->avctx->debug & FF_DEBUG_STARTCODE){

  2099.                     av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);

  2100.                 }

  2101. 

  2102.                 /* process markers */

  2103.                 if (start_code >= 0xd0 && start_code <= 0xd7) {

  2104.                     av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);

  2105.                     /* APP fields */

  2106.                 } else if (start_code >= APP0 && start_code <= APP15) {

  2107.                     mjpeg_decode_app(s);

  2108.                     /* Comment */

  2109.                 } else if (start_code == COM){

  2110.                     mjpeg_decode_com(s);

  2111.                 }

  2112. 

  2113.                 switch(start_code) {

  2114.                 case SOI:

  2115.                     s->restart_interval = 0;

  2116. 

  2117.                     s->restart_count = 0;

  2118.                     /* nothing to do on SOI */

  2119.                     break;

  2120.                 case DQT:

  2121.                     mjpeg_decode_dqt(s);

  2122.                     break;

  2123.                 case DHT:

  2124.                     if(mjpeg_decode_dht(s) < 0){

  2125.                         av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");

  2126.                         return -1;

  2127.                     }

  2128.                     break;

  2129.                 case SOF0:

  2130.                     s->lossless=0;

  2131.                     s->progressive=0;

  2132.                     if (mjpeg_decode_sof(s) < 0)

  2133.                         return -1;

  2134.                     break;

  2135.                 case SOF2:

  2136.                     s->lossless=0;

  2137.                     s->progressive=1;

  2138.                     if (mjpeg_decode_sof(s) < 0)

  2139.                         return -1;

  2140.                     break;

  2141.                 case SOF3:

  2142.                     s->lossless=1;

  2143.                     s->progressive=0;

  2144.                     if (mjpeg_decode_sof(s) < 0)

  2145.                         return -1;

  2146.                     break;

  2147.                 case SOF48:

  2148.                     s->lossless=1;

  2149.                     s->ls=1;

  2150.                     s->progressive=0;

  2151.                     if (mjpeg_decode_sof(s) < 0)

  2152.                         return -1;

  2153.                     break;

  2154.                 case LSE:

  2155.                     if (decode_lse(s) < 0)

  2156.                         return -1;

  2157.                     break;

  2158.                 case EOI:

  2159.                     s->cur_scan = 0;

  2160.                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)

  2161.                         break;

  2162. eoi_parser:

  2163.                     {

  2164.                         if (s->interlaced) {

  2165.                             s->bottom_field ^= 1;

  2166.                             /* if not bottom field, do not output image yet */

  2167.                             if (s->bottom_field)

  2168.                                 goto not_the_end;

  2169.                         }

  2170.                         *picture = s->picture;

  2171.                         *data_size = sizeof(AVFrame);

  2172. 

  2173.                         if(!s->lossless){

  2174.                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);

  2175.                             picture->qstride= 0;

  2176.                             picture->qscale_table= s->qscale_table;

  2177.                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);

  2178.                             if(avctx->debug & FF_DEBUG_QP)

  2179.                                 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);

  2180.                             picture->quality*= FF_QP2LAMBDA;

  2181.                         }

  2182. 

  2183.                         goto the_end;

  2184.                     }

  2185.                     break;

  2186.                 case SOS:

  2187.                     mjpeg_decode_sos(s);

  2188.                     /* buggy avid puts EOI every 10-20th frame */

  2189.                     /* if restart period is over process EOI */

  2190.                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)

  2191.                         goto eoi_parser;

  2192.                     break;

  2193.                 case DRI:

  2194.                     mjpeg_decode_dri(s);

  2195.                     break;

  2196.                 case SOF1:

  2197.                 case SOF5:

  2198.                 case SOF6:

  2199.                 case SOF7:

  2200.                 case SOF9:

  2201.                 case SOF10:

  2202.                 case SOF11:

  2203.                 case SOF13:

  2204.                 case SOF14:

  2205.                 case SOF15:

  2206.                 case JPG:

  2207.                     av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);

  2208.                     break;

  2209. //                default:

  2210. //                    printf("mjpeg: unsupported marker (%x)\n", start_code);

  2211. //                    break;

  2212.                 }

  2213. 

  2214. not_the_end:

  2215.                 /* eof process start code */

  2216.                 buf_ptr += (get_bits_count(&s->gb)+7)/8;

  2217.                 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",

  2218.                        (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));

  2219.             }

  2220.         }

  2221.     }

  2222. the_end:

  2223.     av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);

  2224. //    return buf_end - buf_ptr;

  2225.     return buf_ptr - buf;

  2226. }

  2227. 

  2228. static int mjpegb_decode_frame(AVCodecContext *avctx,

  2229.                               void *data, int *data_size,

  2230.                               uint8_t *buf, int buf_size)

  2231. {

  2232.     MJpegDecodeContext *s = avctx->priv_data;

  2233.     uint8_t *buf_end, *buf_ptr;

  2234.     AVFrame *picture = data;

  2235.     GetBitContext hgb; /* for the header */

  2236.     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;

  2237.     uint32_t field_size, sod_offs;

  2238. 

  2239.     buf_ptr = buf;

  2240.     buf_end = buf + buf_size;

  2241. 

  2242. read_header:

  2243.     /* reset on every SOI */

  2244.     s->restart_interval = 0;

  2245.     s->restart_count = 0;

  2246.     s->mjpb_skiptosod = 0;

  2247. 

  2248.     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);

  2249. 

  2250.     skip_bits(&hgb, 32); /* reserved zeros */

  2251. 

  2252.     if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))

  2253.     {

  2254.         av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");

  2255.         return 0;

  2256.     }

  2257. 

  2258.     field_size = get_bits_long(&hgb, 32); /* field size */

  2259.     av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);

  2260.     skip_bits(&hgb, 32); /* padded field size */

  2261.     second_field_offs = get_bits_long(&hgb, 32);

  2262.     av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);

  2263.     if (second_field_offs)

  2264.         s->interlaced = 1;

  2265. 

  2266.     dqt_offs = get_bits_long(&hgb, 32);

  2267.     av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);

  2268.     if (dqt_offs)

  2269.     {

  2270.         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);

  2271.         s->start_code = DQT;

  2272.         mjpeg_decode_dqt(s);

  2273.     }

  2274. 

  2275.     dht_offs = get_bits_long(&hgb, 32);

  2276.     av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);

  2277.     if (dht_offs)

  2278.     {

  2279.         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);

  2280.         s->start_code = DHT;

  2281.         mjpeg_decode_dht(s);

  2282.     }

  2283. 

  2284.     sof_offs = get_bits_long(&hgb, 32);

  2285.     av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);

  2286.     if (sof_offs)

  2287.     {

  2288.         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);

  2289.         s->start_code = SOF0;

  2290.         if (mjpeg_decode_sof(s) < 0)

  2291.             return -1;

  2292.     }

  2293. 

  2294.     sos_offs = get_bits_long(&hgb, 32);

  2295.     av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);

  2296.     sod_offs = get_bits_long(&hgb, 32);

  2297.     av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);

  2298.     if (sos_offs)

  2299.     {

  2300. //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);

  2301.         init_get_bits(&s->gb, buf+sos_offs, field_size*8);

  2302.         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));

  2303.         s->start_code = SOS;

  2304.         mjpeg_decode_sos(s);

  2305.     }

  2306. 

  2307.     if (s->interlaced) {

  2308.         s->bottom_field ^= 1;

  2309.         /* if not bottom field, do not output image yet */

  2310.         if (s->bottom_field && second_field_offs)

  2311.         {

  2312.             buf_ptr = buf + second_field_offs;

  2313.             second_field_offs = 0;

  2314.             goto read_header;

  2315.             }

  2316.     }

  2317. 

  2318.     //XXX FIXME factorize, this looks very similar to the EOI code

  2319. 

  2320.     *picture= s->picture;

  2321.     *data_size = sizeof(AVFrame);

  2322. 

  2323.     if(!s->lossless){

  2324.         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);

  2325.         picture->qstride= 0;

  2326.         picture->qscale_table= s->qscale_table;

  2327.         memset(picture->qscale_table, picture->quality, (s->width+15)/16);

  2328.         if(avctx->debug & FF_DEBUG_QP)

  2329.             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);

  2330.         picture->quality*= FF_QP2LAMBDA;

  2331.     }

  2332. 

  2333.     return buf_ptr - buf;

  2334. }

  2335. 

  2336. #include "sp5x.h"

  2337. 

  2338. static int sp5x_decode_frame(AVCodecContext *avctx,

  2339.                               void *data, int *data_size,

  2340.                               uint8_t *buf, int buf_size)

  2341. {

  2342. #if 0

  2343.     MJpegDecodeContext *s = avctx->priv_data;

  2344. #endif

  2345.     const int qscale = 5;

  2346.     uint8_t *buf_ptr, *buf_end, *recoded;

  2347.     int i = 0, j = 0;

  2348. 

  2349.     if (!avctx->width || !avctx->height)

  2350.         return -1;

  2351. 

  2352.     buf_ptr = buf;

  2353.     buf_end = buf + buf_size;

  2354. 

  2355. #if 1

  2356.     recoded = av_mallocz(buf_size + 1024);

  2357.     if (!recoded)

  2358.         return -1;

  2359. 

  2360.     /* SOI */

  2361.     recoded[j++] = 0xFF;

  2362.     recoded[j++] = 0xD8;

  2363. 

  2364.     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));

  2365.     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);

  2366.     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);

  2367.     j += sizeof(sp5x_data_dqt);

  2368. 

  2369.     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));

  2370.     j += sizeof(sp5x_data_dht);

  2371. 

  2372.     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));

  2373.     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;

  2374.     recoded[j+6] = avctx->coded_height & 0xFF;

  2375.     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;

  2376.     recoded[j+8] = avctx->coded_width & 0xFF;

  2377.     j += sizeof(sp5x_data_sof);

  2378. 

  2379.     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));

  2380.     j += sizeof(sp5x_data_sos);

  2381. 

  2382.     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)

  2383.     {

  2384.         recoded[j++] = buf[i];

  2385.         if (buf[i] == 0xff)

  2386.             recoded[j++] = 0;

  2387.     }

  2388. 

  2389.     /* EOI */

  2390.     recoded[j++] = 0xFF;

  2391.     recoded[j++] = 0xD9;

  2392. 

  2393.     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);

  2394. 

  2395.     av_free(recoded);

  2396. 

  2397. #else

  2398.     /* SOF */

  2399.     s->bits = 8;

  2400.     s->width  = avctx->coded_width;

  2401.     s->height = avctx->coded_height;

  2402.     s->nb_components = 3;

  2403.     s->component_id[0] = 0;

  2404.     s->h_count[0] = 2;

  2405.     s->v_count[0] = 2;

  2406.     s->quant_index[0] = 0;

  2407.     s->component_id[1] = 1;

  2408.     s->h_count[1] = 1;

  2409.     s->v_count[1] = 1;

  2410.     s->quant_index[1] = 1;

  2411.     s->component_id[2] = 2;

  2412.     s->h_count[2] = 1;

  2413.     s->v_count[2] = 1;

  2414.     s->quant_index[2] = 1;

  2415.     s->h_max = 2;

  2416.     s->v_max = 2;

  2417. 

  2418.     s->qscale_table = av_mallocz((s->width+15)/16);

  2419.     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;

  2420.     s->interlaced = 0;

  2421. 

  2422.     s->picture.reference = 0;

  2423.     if (avctx->get_buffer(avctx, &s->picture) < 0)

  2424.     {

  2425.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  2426.         return -1;

  2427.     }

  2428. 

  2429.     s->picture.pict_type = I_TYPE;

  2430.     s->picture.key_frame = 1;

  2431. 

  2432.     for (i = 0; i < 3; i++)

  2433.         s->linesize[i] = s->picture.linesize[i] << s->interlaced;

  2434. 

  2435.     /* DQT */

  2436.     for (i = 0; i < 64; i++)

  2437.     {

  2438.         j = s->scantable.permutated[i];

  2439.         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];

  2440.     }

  2441.     s->qscale[0] = FFMAX(

  2442.         s->quant_matrixes[0][s->scantable.permutated[1]],

  2443.         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;

  2444. 

  2445.     for (i = 0; i < 64; i++)

  2446.     {

  2447.         j = s->scantable.permutated[i];

  2448.         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];

  2449.     }

  2450.     s->qscale[1] = FFMAX(

  2451.         s->quant_matrixes[1][s->scantable.permutated[1]],

  2452.         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;

  2453. 

  2454.     /* DHT */

  2455. 

  2456.     /* SOS */

  2457.     s->comp_index[0] = 0;

  2458.     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];

  2459.     s->h_scount[0] = s->h_count[0];

  2460.     s->v_scount[0] = s->v_count[0];

  2461.     s->dc_index[0] = 0;

  2462.     s->ac_index[0] = 0;

  2463. 

  2464.     s->comp_index[1] = 1;

  2465.     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];

  2466.     s->h_scount[1] = s->h_count[1];

  2467.     s->v_scount[1] = s->v_count[1];

  2468.     s->dc_index[1] = 1;

  2469.     s->ac_index[1] = 1;

  2470. 

  2471.     s->comp_index[2] = 2;

  2472.     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];

  2473.     s->h_scount[2] = s->h_count[2];

  2474.     s->v_scount[2] = s->v_count[2];

  2475.     s->dc_index[2] = 1;

  2476.     s->ac_index[2] = 1;

  2477. 

  2478.     for (i = 0; i < 3; i++)

  2479.         s->last_dc[i] = 1024;

  2480. 

  2481.     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);

  2482.     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);

  2483. 

  2484.     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);

  2485. 

  2486.     return mjpeg_decode_scan(s);

  2487. #endif

  2488. 

  2489.     return i;

  2490. }

  2491. 

  2492. static int mjpeg_decode_end(AVCodecContext *avctx)

  2493. {

  2494.     MJpegDecodeContext *s = avctx->priv_data;

  2495.     int i, j;

  2496. 

  2497.     av_free(s->buffer);

  2498.     av_free(s->qscale_table);

  2499. 

  2500.     for(i=0;i<2;i++) {

  2501.         for(j=0;j<4;j++)

  2502.             free_vlc(&s->vlcs[i][j]);

  2503.     }

  2504.     return 0;

  2505. }

  2506. 

  2507. static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,

  2508.                               uint8_t **poutbuf, int *poutbuf_size,

  2509.                               const uint8_t *buf, int buf_size, int keyframe)

  2510. {

  2511.     uint8_t *poutbufp;

  2512.     int i;

  2513. 

  2514.     if (avctx->codec_id != CODEC_ID_MJPEG) {

  2515.         av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");

  2516.         return 0;

  2517.     }

  2518. 

  2519.     *poutbuf_size = 0;

  2520.     *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);

  2521.     poutbufp = *poutbuf;

  2522.     bytestream_put_byte(&poutbufp, 0xff);

  2523.     bytestream_put_byte(&poutbufp, SOI);

  2524.     bytestream_put_byte(&poutbufp, 0xff);

  2525.     bytestream_put_byte(&poutbufp, APP1);

  2526.     bytestream_put_be16(&poutbufp, 42); /* size */

  2527.     bytestream_put_be32(&poutbufp, 0);

  2528.     bytestream_put_buffer(&poutbufp, "mjpg", 4);

  2529.     bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */

  2530.     bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */

  2531.     bytestream_put_be32(&poutbufp, 0);             /* next ptr */

  2532. 

  2533.     for (i = 0; i < buf_size - 1; i++) {

  2534.         if (buf[i] == 0xff) {

  2535.             switch (buf[i + 1]) {

  2536.             case DQT:  /* quant off */

  2537.             case DHT:  /* huff  off */

  2538.             case SOF0: /* image off */

  2539.                 bytestream_put_be32(&poutbufp, i + 46);

  2540.                 break;

  2541.             case SOS:

  2542.                 bytestream_put_be32(&poutbufp, i + 46); /* scan off */

  2543.                 bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */

  2544.                 bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */

  2545.                 *poutbuf_size = poutbufp - *poutbuf;

  2546.                 return 1;

  2547.             case APP1:

  2548.                 if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {

  2549.                     av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");

  2550.                     memcpy(*poutbuf, buf, buf_size);

  2551.                     *poutbuf_size = buf_size;

  2552.                     return 1;

  2553.                 }

  2554.             }

  2555.         }

  2556.     }

  2557.     av_freep(poutbuf);

  2558.     av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");

  2559.     return 0;

  2560. }

  2561. 

  2562. AVCodec mjpeg_decoder = {

  2563.     "mjpeg",

  2564.     CODEC_TYPE_VIDEO,

  2565.     CODEC_ID_MJPEG,

  2566.     sizeof(MJpegDecodeContext),

  2567.     mjpeg_decode_init,

  2568.     NULL,

  2569.     mjpeg_decode_end,

  2570.     mjpeg_decode_frame,

  2571.     CODEC_CAP_DR1,

  2572.     NULL

  2573. };

  2574. 

  2575. AVCodec mjpegb_decoder = {

  2576.     "mjpegb",

  2577.     CODEC_TYPE_VIDEO,

  2578.     CODEC_ID_MJPEGB,

  2579.     sizeof(MJpegDecodeContext),

  2580.     mjpeg_decode_init,

  2581.     NULL,

  2582.     mjpeg_decode_end,

  2583.     mjpegb_decode_frame,

  2584.     CODEC_CAP_DR1,

  2585.     NULL

  2586. };

  2587. 

  2588. AVCodec sp5x_decoder = {

  2589.     "sp5x",

  2590.     CODEC_TYPE_VIDEO,

  2591.     CODEC_ID_SP5X,

  2592.     sizeof(MJpegDecodeContext),

  2593.     mjpeg_decode_init,

  2594.     NULL,

  2595.     mjpeg_decode_end,

  2596.     sp5x_decode_frame,

  2597.     CODEC_CAP_DR1,

  2598.     NULL

  2599. };

  2600. 

  2601. #ifdef CONFIG_ENCODERS

  2602. AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them

  2603.     "ljpeg",

  2604.     CODEC_TYPE_VIDEO,

  2605.     CODEC_ID_LJPEG,

  2606.     sizeof(MpegEncContext),

  2607.     MPV_encode_init,

  2608.     encode_picture_lossless,

  2609.     MPV_encode_end,

  2610. };

  2611. #endif

  2612. 

  2613. AVCodecParser mjpeg_parser = {

  2614.     { CODEC_ID_MJPEG },

  2615.     sizeof(ParseContext),

  2616.     NULL,

  2617.     jpeg_parse,

  2618.     ff_parse_close,

  2619. };

  2620. 

  2621. AVBitStreamFilter mjpega_dump_header_bsf = {

  2622.     "mjpegadump",

  2623.     0,

  2624.     mjpega_dump_header,

  2625. };