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.
3984 Commits
32 Branches
293MB
Tree: 21d7e2ff40
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '21d7e2ff40'
${ noResults }
FFmpeg/libavcodec/mjpeg.c

2307 lines
68KB
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 library is free software; you can redistribute it and/or

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

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

  10.  * version 2 of the License, or (at your option) any later version.

  11.  *

  12.  * This library is distributed in the hope that it will be useful,

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

  18.  * License along with this library; if not, write to the Free Software

  19.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  20.  *

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

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

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

  24.  */

  25. 

  26. /**

  27.  * @file mjpeg.c

  28.  * MJPEG encoder and decoder.

  29.  */

  30.  

  31. //#define DEBUG

  32. #include <assert.h>

  33. 

  34. #include "avcodec.h"

  35. #include "dsputil.h"

  36. #include "mpegvideo.h"

  37. 

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

  39. /* not yet working */

  40. #undef TWOMATRIXES

  41. 

  42. typedef struct MJpegContext {

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

  44.     uint16_t huff_code_dc_luminance[12];

  45.     uint8_t huff_size_dc_chrominance[12];

  46.     uint16_t huff_code_dc_chrominance[12];

  47. 

  48.     uint8_t huff_size_ac_luminance[256];

  49.     uint16_t huff_code_ac_luminance[256];

  50.     uint8_t huff_size_ac_chrominance[256];

  51.     uint16_t huff_code_ac_chrominance[256];

  52. } MJpegContext;

  53. 

  54. /* JPEG marker codes */

  55. typedef enum {

  56.     /* start of frame */

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

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

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

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

  61. 

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

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

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

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

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

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

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

  69. 

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

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

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

  73. 

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

  75. 

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

  77. 

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

  79.     RST0  = 0xd0,

  80.     RST1  = 0xd1,

  81.     RST2  = 0xd2,

  82.     RST3  = 0xd3,

  83.     RST4  = 0xd4,

  84.     RST5  = 0xd5,

  85.     RST6  = 0xd6,

  86.     RST7  = 0xd7,

  87. 

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

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

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

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

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

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

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

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

  96. 

  97.     APP0  = 0xe0,

  98.     APP1  = 0xe1,

  99.     APP2  = 0xe2,

  100.     APP3  = 0xe3,

  101.     APP4  = 0xe4,

  102.     APP5  = 0xe5,

  103.     APP6  = 0xe6,

  104.     APP7  = 0xe7,

  105.     APP8  = 0xe8,

  106.     APP9  = 0xe9,

  107.     APP10 = 0xea,

  108.     APP11 = 0xeb,

  109.     APP12 = 0xec,

  110.     APP13 = 0xed,

  111.     APP14 = 0xee,

  112.     APP15 = 0xef,

  113. 

  114.     JPG0  = 0xf0,

  115.     JPG1  = 0xf1,

  116.     JPG2  = 0xf2,

  117.     JPG3  = 0xf3,

  118.     JPG4  = 0xf4,

  119.     JPG5  = 0xf5,

  120.     JPG6  = 0xf6,

  121.     JPG7  = 0xf7,

  122.     JPG8  = 0xf8,

  123.     JPG9  = 0xf9,

  124.     JPG10 = 0xfa,

  125.     JPG11 = 0xfb,

  126.     JPG12 = 0xfc,

  127.     JPG13 = 0xfd,

  128. 

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

  130. 

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

  132. 

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

  134. } JPEG_MARKER;

  135. 

  136. #if 0

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

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

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

  140.  */

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

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

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

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

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

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

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

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

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

  150. };

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

  152.     17,  18,  24,  47,  99,  99,  99,  99,

  153.     18,  21,  26,  66,  99,  99,  99,  99,

  154.     24,  26,  56,  99,  99,  99,  99,  99,

  155.     47,  66,  99,  99,  99,  99,  99,  99,

  156.     99,  99,  99,  99,  99,  99,  99,  99,

  157.     99,  99,  99,  99,  99,  99,  99,  99,

  158.     99,  99,  99,  99,  99,  99,  99,  99,

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

  160. };

  161. #endif

  162. 

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

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

  165. static const uint8_t bits_dc_luminance[17] =

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

  167. static const uint8_t val_dc_luminance[] =

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

  169. 

  170. static const uint8_t bits_dc_chrominance[17] =

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

  172. static const uint8_t val_dc_chrominance[] =

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

  174. 

  175. static const uint8_t bits_ac_luminance[17] =

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

  177. static const uint8_t val_ac_luminance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  198.   0xf9, 0xfa 

  199. };

  200. 

  201. static const uint8_t bits_ac_chrominance[17] =

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

  203. 

  204. static const uint8_t val_ac_chrominance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  225.   0xf9, 0xfa 

  226. };

  227. 

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

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

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

  231. {

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

  233. 

  234.     code = 0;

  235.     k = 0;

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

  237.         nb = bits_table[i];

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

  239.             sym = val_table[k++];

  240.             huff_size[sym] = i;

  241.             huff_code[sym] = code;

  242.             code++;

  243.         }

  244.         code <<= 1;

  245.     }

  246. }

  247. 

  248. #ifdef CONFIG_ENCODERS

  249. int mjpeg_init(MpegEncContext *s)

  250. {

  251.     MJpegContext *m;

  252.     

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

  254.     if (!m)

  255.         return -1;

  256.     

  257.     s->min_qcoeff=-1023;

  258.     s->max_qcoeff= 1023;

  259. 

  260.     /* build all the huffman tables */

  261.     build_huffman_codes(m->huff_size_dc_luminance,

  262.                         m->huff_code_dc_luminance,

  263.                         bits_dc_luminance,

  264.                         val_dc_luminance);

  265.     build_huffman_codes(m->huff_size_dc_chrominance,

  266.                         m->huff_code_dc_chrominance,

  267.                         bits_dc_chrominance,

  268.                         val_dc_chrominance);

  269.     build_huffman_codes(m->huff_size_ac_luminance,

  270.                         m->huff_code_ac_luminance,

  271.                         bits_ac_luminance,

  272.                         val_ac_luminance);

  273.     build_huffman_codes(m->huff_size_ac_chrominance,

  274.                         m->huff_code_ac_chrominance,

  275.                         bits_ac_chrominance,

  276.                         val_ac_chrominance);

  277.     

  278.     s->mjpeg_ctx = m;

  279.     return 0;

  280. }

  281. 

  282. void mjpeg_close(MpegEncContext *s)

  283. {

  284.     av_free(s->mjpeg_ctx);

  285. }

  286. #endif //CONFIG_ENCODERS

  287. 

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

  289.     switch(predictor){\

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

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

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

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

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

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

  296.         default:\

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

  298.     }

  299. 

  300. #ifdef CONFIG_ENCODERS

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

  302. {

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

  304.     put_bits(p, 8, code);

  305. }

  306. 

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

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

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

  310. {

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

  312.     int n, i;

  313. 

  314.     put_bits(p, 4, table_class);

  315.     put_bits(p, 4, table_id);

  316. 

  317.     n = 0;

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

  319.         n += bits_table[i];

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

  321.     }

  322. 

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

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

  325. 

  326.     return n + 17;

  327. }

  328. 

  329. static void jpeg_table_header(MpegEncContext *s)

  330. {

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

  332.     int i, j, size;

  333.     uint8_t *ptr;

  334. 

  335.     /* quant matrixes */

  336.     put_marker(p, DQT);

  337. #ifdef TWOMATRIXES

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

  339. #else

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

  341. #endif

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

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

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

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

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

  347.     }

  348. #ifdef TWOMATRIXES

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

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

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

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

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

  354.     }

  355. #endif

  356. 

  357.     /* huffman table */

  358.     put_marker(p, DHT);

  359.     flush_put_bits(p);

  360.     ptr = pbBufPtr(p);

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

  362.     size = 2;

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

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

  365.     

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

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

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

  369.     ptr[1] = size;

  370. }

  371. 

  372. static void jpeg_put_comments(MpegEncContext *s)

  373. {

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

  375.     int size;

  376.     uint8_t *ptr;

  377. 

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

  379.     {

  380.     /* JFIF header */

  381.     put_marker(p, APP0);

  382.     put_bits(p, 16, 16);

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

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

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

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

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

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

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

  390.     }

  391. 

  392.     /* comment */

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

  394.         put_marker(p, COM);

  395.         flush_put_bits(p);

  396.         ptr = pbBufPtr(p);

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

  398.         put_string(p, LIBAVCODEC_IDENT, 1);

  399.         size = strlen(LIBAVCODEC_IDENT)+3;

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

  401.         ptr[1] = size;

  402.     }

  403. }

  404. 

  405. void mjpeg_picture_header(MpegEncContext *s)

  406. {

  407.     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;

  408. 

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

  410. 

  411.     if (!s->mjpeg_data_only_frames)

  412.     {

  413.     jpeg_put_comments(s);    

  414. 

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

  416. 

  417.     put_marker(&s->pb, lossless ? SOF3 : SOF0);

  418. 

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

  420.     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)

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

  422.     else

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

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

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

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

  427.     

  428.     /* Y component */

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

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

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

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

  433.     

  434.     /* Cb component */

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

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

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

  438. #ifdef TWOMATRIXES

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

  440. #else

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

  442. #endif

  443. 

  444.     /* Cr component */

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

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

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

  448. #ifdef TWOMATRIXES

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

  450. #else

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

  452. #endif

  453.     }

  454. 

  455.     /* scan header */

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

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

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

  459.     

  460.     /* Y component */

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

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

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

  464.     

  465.     /* Cb component */

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

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

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

  469.     

  470.     /* Cr component */

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

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

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

  474. 

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

  476.     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */

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

  478. }

  479. 

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

  481. {

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

  483.     int i, ff_count;

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

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

  486.     

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

  488.     size >>= 3;

  489.     

  490.     ff_count=0;

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

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

  493.     }

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

  495.         int acc, v;

  496. 

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

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

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

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

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

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

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

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

  505. 

  506.         acc>>=4;

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

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

  509.         ff_count+= acc&0xFF;

  510.     }

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

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

  513.     }

  514. 

  515.     if(ff_count==0) return;

  516.     

  517.     /* skip put bits */

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

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

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

  521.     flush_put_bits(&s->pb); 

  522. 

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

  524.         int v= buf[i];

  525. 

  526.         if(v==0xFF){

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

  528.             buf[i+ff_count]= 0;

  529.             ff_count--;

  530.         }

  531. 

  532.         buf[i+ff_count]= v;

  533.     }

  534. }

  535. 

  536. void ff_mjpeg_stuffing(PutBitContext * pbc)

  537. {

  538.     int length;

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

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

  541. }

  542. 

  543. void mjpeg_picture_trailer(MpegEncContext *s)

  544. {

  545.     ff_mjpeg_stuffing(&s->pb);

  546.     flush_put_bits(&s->pb);

  547. 

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

  549.     

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

  551. 

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

  553. }

  554. 

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

  556. 				   uint8_t *huff_size, uint16_t *huff_code)

  557. {

  558.     int mant, nbits;

  559. 

  560.     if (val == 0) {

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

  562.     } else {

  563.         mant = val;

  564.         if (val < 0) {

  565.             val = -val;

  566.             mant--;

  567.         }

  568.         

  569.         nbits= av_log2_16bit(val) + 1;

  570.             

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

  572.         

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

  574.     }

  575. }

  576. 

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

  578. {

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

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

  581.     MJpegContext *m = s->mjpeg_ctx;

  582.     uint8_t *huff_size_ac;

  583.     uint16_t *huff_code_ac;

  584.     

  585.     /* DC coef */

  586.     component = (n <= 3 ? 0 : n - 4 + 1);

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

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

  589.     if (n < 4) {

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

  591.         huff_size_ac = m->huff_size_ac_luminance;

  592.         huff_code_ac = m->huff_code_ac_luminance;

  593.     } else {

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

  595.         huff_size_ac = m->huff_size_ac_chrominance;

  596.         huff_code_ac = m->huff_code_ac_chrominance;

  597.     }

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

  599.     

  600.     /* AC coefs */

  601.     

  602.     run = 0;

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

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

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

  606.         val = block[j];

  607.         if (val == 0) {

  608.             run++;

  609.         } else {

  610.             while (run >= 16) {

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

  612.                 run -= 16;

  613.             }

  614.             mant = val;

  615.             if (val < 0) {

  616.                 val = -val;

  617.                 mant--;

  618.             }

  619.             

  620.             nbits= av_log2(val) + 1;

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

  622. 

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

  624.         

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

  626.             run = 0;

  627.         }

  628.     }

  629. 

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

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

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

  633. }

  634. 

  635. void mjpeg_encode_mb(MpegEncContext *s, 

  636.                      DCTELEM block[6][64])

  637. {

  638.     int i;

  639.     for(i=0;i<6;i++) {

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

  641.     }

  642. }

  643. 

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

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

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

  647.     AVFrame *pict = data;

  648.     const int width= s->width;

  649.     const int height= s->height;

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

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

  652. 

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

  654. 

  655.     *p = *pict;

  656.     p->pict_type= FF_I_TYPE;

  657.     p->key_frame= 1;

  658.     

  659.     mjpeg_picture_header(s);

  660. 

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

  662. 

  663.     if(avctx->pix_fmt == PIX_FMT_RGBA32){

  664.         int x, y, i;

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

  666.         uint16_t buffer[2048][4];

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

  668. 

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

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

  671.         }

  672. 

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

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

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

  676. 

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

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

  679.             }

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

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

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

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

  684. 

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

  686.                     int pred, diff;

  687. 

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

  689.                         

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

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

  692.                     

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

  694. 

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

  696.                     

  697.                     if(i==0)

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

  699.                     else

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

  701.                 }

  702.             }

  703.         }

  704.     }else{

  705.         int mb_x, mb_y, i;

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

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

  708.         

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

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

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

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

  713.                         uint8_t *ptr;

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

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

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

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

  718. 

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

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

  721.                                 int pred;

  722. 

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

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

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

  726.                                         pred= 128;

  727.                                     }else{

  728.                                         pred= ptr[-1];

  729.                                     }

  730.                                 }else{

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

  732.                                         pred= ptr[-linesize];

  733.                                     }else{

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

  735.                                     }

  736.                                 }

  737.                                 

  738.                                 if(i==0)

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

  740.                                 else

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

  742.                             }

  743.                         }

  744.                     }

  745.                 }else{

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

  747.                         uint8_t *ptr;

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

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

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

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

  752.                              

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

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

  755.                                 int pred;

  756. 

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

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

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

  760. 

  761.                                 if(i==0)

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

  763.                                 else

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

  765.                             }

  766.                         }

  767.                     }

  768.                 }

  769.             }

  770.         }

  771.     }

  772. 

  773.     emms_c();

  774.     

  775.     mjpeg_picture_trailer(s);

  776.     s->picture_number++;

  777. 

  778.     flush_put_bits(&s->pb);

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

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

  781. }

  782. 

  783. #endif //CONFIG_ENCODERS

  784. 

  785. /******************************************/

  786. /* decoding */

  787. 

  788. #define MAX_COMPONENTS 4

  789. 

  790. typedef struct MJpegDecodeContext {

  791.     AVCodecContext *avctx;

  792.     GetBitContext gb;

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

  794. 

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

  796.     int buffer_size;

  797.     uint8_t *buffer;

  798. 

  799.     int16_t quant_matrixes[4][64];

  800.     VLC vlcs[2][4];

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

  802. 

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

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

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

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

  807.     int lossless;

  808.     int rgb;

  809.     int rct;            /* standard rct */  

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

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

  812. 

  813.     int width, height;

  814.     int mb_width, mb_height;

  815.     int nb_components;

  816.     int component_id[MAX_COMPONENTS];

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

  818.     int v_count[MAX_COMPONENTS];

  819.     int comp_index[MAX_COMPONENTS];

  820.     int dc_index[MAX_COMPONENTS];

  821.     int ac_index[MAX_COMPONENTS];

  822.     int nb_blocks[MAX_COMPONENTS];

  823.     int h_scount[MAX_COMPONENTS];

  824.     int v_scount[MAX_COMPONENTS];

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

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

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

  828.     AVFrame picture; /* picture structure */

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

  830.     int8_t *qscale_table;

  831.     DCTELEM block[64] __align8;

  832.     ScanTable scantable;

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

  834. 

  835.     int restart_interval;

  836.     int restart_count;

  837. 

  838.     int buggy_avid;

  839.     int interlace_polarity;

  840. 

  841.     int mjpb_skiptosod;

  842. } MJpegDecodeContext;

  843. 

  844. static int mjpeg_decode_dht(MJpegDecodeContext *s);

  845. 

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

  847.                       int nb_codes)

  848. {

  849.     uint8_t huff_size[256];

  850.     uint16_t huff_code[256];

  851. 

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

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

  854.     

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

  856. }

  857. 

  858. static int mjpeg_decode_init(AVCodecContext *avctx)

  859. {

  860.     MJpegDecodeContext *s = avctx->priv_data;

  861.     MpegEncContext s2;

  862. 

  863.     s->avctx = avctx;

  864. 

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

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

  867.     s2.avctx= avctx;

  868. //    s2->out_format = FMT_MJPEG;

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

  870.     DCT_common_init(&s2);

  871. 

  872.     s->scantable= s2.intra_scantable;

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

  874. 

  875.     s->mpeg_enc_ctx_allocated = 0;

  876.     s->buffer_size = 102400; /* smaller buffer should be enough,

  877. 				but photojpg files could ahive bigger sizes */

  878.     s->buffer = av_malloc(s->buffer_size);

  879.     if (!s->buffer)

  880. 	return -1;

  881.     s->start_code = -1;

  882.     s->first_picture = 1;

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

  884.     

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

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

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

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

  889. 

  890.     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)

  891.     {

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

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

  894. 	mjpeg_decode_dht(s);

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

  896.     }

  897. 

  898.     return 0;

  899. }

  900. 

  901. 

  902. /**

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

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

  905.  */

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

  907.     int vop_found, i;

  908.     uint16_t state;

  909.     

  910.     vop_found= pc->frame_start_found;

  911.     state= pc->state;

  912.     

  913.     i=0;

  914.     if(!vop_found){

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

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

  917.             if(state == 0xFFD8){

  918.                 i++;

  919.                 vop_found=1;

  920.                 break;

  921.             }

  922.         }

  923.     }

  924. 

  925.     if(vop_found){

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

  927.         if (buf_size == 0)

  928.             return 0;

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

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

  931.             if(state == 0xFFD8){

  932.                 pc->frame_start_found=0;

  933.                 pc->state=0; 

  934.                 return i-1;

  935.             }

  936.         }

  937.     }

  938.     pc->frame_start_found= vop_found;

  939.     pc->state= state;

  940.     return END_NOT_FOUND;

  941. }

  942. 

  943. static int jpeg_parse(AVCodecParserContext *s,

  944.                            AVCodecContext *avctx,

  945.                            uint8_t **poutbuf, int *poutbuf_size, 

  946.                            const uint8_t *buf, int buf_size)

  947. {

  948.     ParseContext *pc = s->priv_data;

  949.     int next;

  950.     

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

  952. 

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

  954.         *poutbuf = NULL;

  955.         *poutbuf_size = 0;

  956.         return buf_size;

  957.     }

  958. 

  959.     *poutbuf = (uint8_t *)buf;

  960.     *poutbuf_size = buf_size;

  961.     return next;

  962. }

  963. 

  964. /* quantize tables */

  965. static int mjpeg_decode_dqt(MJpegDecodeContext *s)

  966. {

  967.     int len, index, i, j;

  968.     

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

  970. 

  971.     while (len >= 65) {

  972.         /* only 8 bit precision handled */

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

  974. 	{

  975. 	    dprintf("dqt: 16bit precision\n");

  976.             return -1;

  977. 	}

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

  979.         if (index >= 4)

  980.             return -1;

  981.         dprintf("index=%d\n", index);

  982.         /* read quant table */

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

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

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

  986.         }

  987. 

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

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

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

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

  992. 	dprintf("qscale[%d]: %d\n", index, s->qscale[index]);

  993.         len -= 65;

  994.     }

  995.     

  996.     return 0;

  997. }

  998. 

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

  1000. static int mjpeg_decode_dht(MJpegDecodeContext *s)

  1001. {

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

  1003.     uint8_t bits_table[17];

  1004.     uint8_t val_table[256];

  1005.     

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

  1007. 

  1008.     while (len > 0) {

  1009.         if (len < 17)

  1010.             return -1;

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

  1012.         if (class >= 2)

  1013.             return -1;

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

  1015.         if (index >= 4)

  1016.             return -1;

  1017.         n = 0;

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

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

  1020.             n += bits_table[i];

  1021.         }

  1022.         len -= 17;

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

  1024.             return -1;

  1025. 

  1026.         code_max = 0;

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

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

  1029.             if (v > code_max)

  1030.                 code_max = v;

  1031.             val_table[i] = v;

  1032.         }

  1033.         len -= n;

  1034. 

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

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

  1037.         dprintf("class=%d index=%d nb_codes=%d\n",

  1038.                class, index, code_max + 1);

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

  1040.             return -1;

  1041.         }

  1042.     }

  1043.     return 0;

  1044. }

  1045. 

  1046. static int mjpeg_decode_sof(MJpegDecodeContext *s)

  1047. {

  1048.     int len, nb_components, i, width, height;

  1049. 

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

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

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

  1053.     

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

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

  1056. 

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

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

  1059.         return -1;

  1060.     }

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

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

  1063.     dprintf("sof0: picture: %dx%d\n", width, height);

  1064. 

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

  1066.     if (nb_components <= 0 ||

  1067.         nb_components > MAX_COMPONENTS)

  1068.         return -1;

  1069.     s->nb_components = nb_components;

  1070.     s->h_max = 1;

  1071.     s->v_max = 1;

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

  1073.         /* component id */

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

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

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

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

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

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

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

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

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

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

  1084.             return -1;

  1085.         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],

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

  1087.     }

  1088.     

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

  1090. 

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

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

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

  1094.         av_freep(&s->qscale_table);

  1095.             

  1096.         s->width = width;

  1097.         s->height = height;

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

  1099. 

  1100.         /* test interlaced mode */

  1101.         if (s->first_picture &&

  1102.             s->org_height != 0 &&

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

  1104.             s->interlaced = 1;

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

  1106.             s->bottom_field = 0;

  1107.             s->avctx->height *= 2;

  1108.         }

  1109. 

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

  1111. 

  1112.         s->first_picture = 0;

  1113.     }

  1114.     

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

  1116.         return 0;

  1117.  

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

  1119.     switch((s->h_count[0] << 4) | s->v_count[0]) {

  1120.     case 0x11:

  1121.         if(s->rgb){

  1122.             s->avctx->pix_fmt = PIX_FMT_RGBA32;

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

  1124.             s->avctx->pix_fmt = PIX_FMT_YUV444P;

  1125.         else

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

  1127.         break;

  1128.     case 0x21:

  1129.         s->avctx->pix_fmt = PIX_FMT_YUV422P;

  1130.         break;

  1131.     default:

  1132.     case 0x22:

  1133.         s->avctx->pix_fmt = PIX_FMT_YUV420P;

  1134.         break;

  1135.     }

  1136. 

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

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

  1139. 

  1140.     s->picture.reference= 0;

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

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

  1143.         return -1;

  1144.     }

  1145.     s->picture.pict_type= I_TYPE;

  1146.     s->picture.key_frame= 1;

  1147.     

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

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

  1150.     }

  1151. 

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

  1153.     

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

  1155.     {

  1156. 	dprintf("decode_sof0: error, len(%d) mismatch\n", len);

  1157.     }

  1158.     

  1159.     return 0;

  1160. }

  1161. 

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

  1163. {

  1164.     int code;

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

  1166.     if (code < 0)

  1167.     {

  1168. 	dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,

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

  1170.         return 0xffff;

  1171.     }

  1172. 

  1173.     if(code)

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

  1175.     else

  1176.         return 0;

  1177. }

  1178. 

  1179. /* decode block and dequantize */

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

  1181.                         int component, int dc_index, int ac_index, int quant_index)

  1182. {

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

  1184.     VLC *ac_vlc;

  1185.     int16_t *quant_matrix;

  1186. 

  1187.     /* DC coef */

  1188.     val = mjpeg_decode_dc(s, dc_index);

  1189.     if (val == 0xffff) {

  1190.         dprintf("error dc\n");

  1191.         return -1;

  1192.     }

  1193.     quant_matrix = s->quant_matrixes[quant_index];

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

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

  1196.     block[0] = val;

  1197.     /* AC coefs */

  1198.     ac_vlc = &s->vlcs[1][ac_index];

  1199.     i = 1;

  1200.     for(;;) {

  1201. 	code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);

  1202. 

  1203.         if (code < 0) {

  1204.             dprintf("error ac\n");

  1205.             return -1;

  1206.         }

  1207.         /* EOB */

  1208.         if (code == 0)

  1209.             break;

  1210.         if (code == 0xf0) {

  1211.             i += 16;

  1212.         } else {

  1213.             level = get_xbits(&s->gb, code & 0xf);

  1214.             i += code >> 4;

  1215.             if (i >= 64) {

  1216.                 dprintf("error count: %d\n", i);

  1217.                 return -1;

  1218.             }

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

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

  1221.             i++;

  1222.             if (i >= 64)

  1223.                 break;

  1224.         }

  1225.     }

  1226.     return 0;

  1227. }

  1228. 

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

  1230.     int i, mb_x, mb_y;

  1231.     uint16_t buffer[2048][4];

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

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

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

  1235.     

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

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

  1238.     }

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

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

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

  1242. 

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

  1244.             ptr += linesize >> 1;

  1245. 

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

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

  1248.         }

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

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

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

  1252. 

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

  1254.                 int pred;

  1255. 

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

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

  1258. 

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

  1260.                 

  1261.                 left[i]= 

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

  1263.             }

  1264. 

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

  1266.                 align_get_bits(&s->gb);

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

  1268.             }

  1269.         }

  1270. 

  1271.         if(s->rct){

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

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

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

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

  1276.             }

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

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

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

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

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

  1282.             }

  1283.         }else{

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

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

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

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

  1288.             }

  1289.         }

  1290.     }

  1291.     return 0;

  1292. }

  1293. 

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

  1295.     int i, mb_x, mb_y;

  1296.     const int nb_components=3;

  1297. 

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

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

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

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

  1302. 

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

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

  1305.                     uint8_t *ptr;

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

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

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

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

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

  1311.                     x = 0;

  1312.                     y = 0;

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

  1314.                     

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

  1316.                         int pred;

  1317. 

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

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

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

  1321.                                 pred= 128 << point_transform;

  1322.                             }else{

  1323.                                 pred= ptr[-1];

  1324.                             }

  1325.                         }else{

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

  1327.                                 pred= ptr[-linesize];

  1328.                             }else{

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

  1330.                             }

  1331.                         }

  1332.                         

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

  1334.                             ptr += linesize >> 1;

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

  1336. 

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

  1338.                             x = 0;

  1339.                             y++;

  1340.                         }

  1341.                     }

  1342.                 }

  1343.             }else{

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

  1345.                     uint8_t *ptr;

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

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

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

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

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

  1351.                     x = 0;

  1352.                     y = 0;

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

  1354.                     

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

  1356.                         int pred;

  1357. 

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

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

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

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

  1362.                             x = 0;

  1363.                             y++;

  1364.                         }

  1365.                     }

  1366.                 }

  1367.             }

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

  1369.                 align_get_bits(&s->gb);

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

  1371.             }

  1372.         }

  1373.     }

  1374.     return 0;

  1375. }

  1376. 

  1377. static int mjpeg_decode_scan(MJpegDecodeContext *s){

  1378.     int i, mb_x, mb_y;

  1379.     const int nb_components=3;

  1380. 

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

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

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

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

  1385. 

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

  1387.                 uint8_t *ptr;

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

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

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

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

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

  1393.                 x = 0;

  1394.                 y = 0;

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

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

  1397.                     if (decode_block(s, s->block, i, 

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

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

  1400.                         dprintf("error y=%d x=%d\n", mb_y, mb_x);

  1401.                         return -1;

  1402.                     }

  1403. //		    dprintf("mb: %d %d processed\n", mb_y, mb_x);

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

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

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

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

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

  1409. //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);

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

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

  1412.                         x = 0;

  1413.                         y++;

  1414.                     }

  1415.                 }

  1416.             }

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

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

  1419.                 !--s->restart_count) {

  1420.                 align_get_bits(&s->gb);

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

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

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

  1424.             }

  1425.         }

  1426.     }

  1427.     return 0;

  1428. }

  1429. 

  1430. static int mjpeg_decode_sos(MJpegDecodeContext *s)

  1431. {

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

  1433.     int vmax, hmax, index, id;

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

  1435. 

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

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

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

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

  1440.     {

  1441. 	dprintf("decode_sos: invalid len (%d)\n", len);

  1442. 	return -1;

  1443.     }

  1444.     /* XXX: only interleaved scan accepted */

  1445.     if (nb_components != s->nb_components)

  1446.     {

  1447. 	dprintf("decode_sos: components(%d) mismatch\n", nb_components);

  1448.         return -1;

  1449.     }

  1450.     vmax = 0;

  1451.     hmax = 0;

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

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

  1454. 	dprintf("component: %d\n", id);

  1455.         /* find component index */

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

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

  1458.                 break;

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

  1460. 	{

  1461. 	    dprintf("decode_sos: index(%d) out of components\n", index);

  1462.             return -1;

  1463. 	}

  1464. 

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

  1466. 

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

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

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

  1470. 

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

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

  1473. 

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

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

  1476. 	    goto out_of_range;

  1477. #if 0 //buggy

  1478. 	switch(s->start_code)

  1479. 	{

  1480. 	    case SOF0:

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

  1482. 		    goto out_of_range;

  1483. 		break;

  1484. 	    case SOF1:

  1485. 	    case SOF2:

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

  1487. 		    goto out_of_range;

  1488. 		break;

  1489. 	    case SOF3:

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

  1491. 		    goto out_of_range;

  1492. 		break;	

  1493. 	}

  1494. #endif

  1495.     }

  1496. 

  1497.     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */

  1498.     skip_bits(&s->gb, 8); /* Se */

  1499.     skip_bits(&s->gb, 4); /* Ah */

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

  1501. 

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

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

  1504. 

  1505.     if (nb_components > 1) {

  1506.         /* interleaved stream */

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

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

  1509.     } else {

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

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

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

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

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

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

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

  1517.     }

  1518. 

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

  1520.         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);

  1521.     

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

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

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

  1525. 

  1526.     if(s->lossless){

  1527.             if(s->rgb){

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

  1529.                     return -1;

  1530.             }else{

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

  1532.                     return -1;

  1533.             }

  1534.     }else{

  1535.         if(mjpeg_decode_scan(s) < 0)

  1536.             return -1;

  1537.     }

  1538.     emms_c();

  1539.     return 0;

  1540.  out_of_range:

  1541.     dprintf("decode_sos: ac/dc index out of range\n");

  1542.     return -1;

  1543. }

  1544. 

  1545. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1546. {

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

  1548. 	return -1;

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

  1550.     dprintf("restart interval: %d\n", s->restart_interval);

  1551. 

  1552.     return 0;

  1553. }

  1554. 

  1555. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1556. {

  1557.     int len, id;

  1558. 

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

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

  1561.     if (len < 5)

  1562. 	return -1;

  1563. 

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

  1565.     id = be2me_32(id);

  1566.     len -= 6;

  1567. 

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

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

  1570.     }

  1571.     

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

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

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

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

  1576.     {

  1577. 	/* structure:

  1578. 	    4bytes	AVI1

  1579. 	    1bytes	polarity

  1580. 	    1bytes	always zero

  1581. 	    4bytes	field_size

  1582. 	    4bytes	field_size_less_padding

  1583. 	*/

  1584.     	s->buggy_avid = 1;

  1585. //	if (s->first_picture)

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

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

  1588. #if 0

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

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

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

  1592. 	len -= 10;

  1593. #endif

  1594. //	if (s->interlace_polarity)

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

  1596. 	goto out;

  1597.     }

  1598.     

  1599. //    len -= 2;

  1600.     

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

  1602.     {

  1603. 	int t_w, t_h, v1, v2;

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

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

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

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

  1608. 

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

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

  1611. 

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

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

  1614.                 v1, v2,

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

  1616.                 s->avctx->sample_aspect_ratio.den

  1617.             );

  1618. 

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

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

  1621. 	if (t_w && t_h)

  1622. 	{

  1623. 	    /* skip thumbnail */

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

  1625. 		len -= t_w*t_h*3;

  1626. 	}

  1627. 	len -= 10;

  1628. 	goto out;

  1629.     }

  1630.     

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

  1632.     {

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

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

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

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

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

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

  1639. 	len -= 7;

  1640. 	goto out;

  1641.     }

  1642. 

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

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

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

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

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

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

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

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

  1651.         case 1:

  1652.             s->rgb= 1;

  1653.             s->pegasus_rct=0;

  1654.             break;

  1655.         case 2:

  1656.             s->rgb= 1;

  1657.             s->pegasus_rct=1;

  1658.             break;

  1659.         default:

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

  1661.         }

  1662.         len -= 9;

  1663.         goto out;

  1664.     }

  1665.     

  1666.     /* Apple MJPEG-A */

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

  1668.     {

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

  1670. 	id = be2me_32(id);

  1671. 	len -= 4;

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

  1673. 	{

  1674. #if 0

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

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

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

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

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

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

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

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

  1683. #endif

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

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

  1686. 	}

  1687.     }

  1688. 

  1689. out:

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

  1691.     if (len < 0)

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

  1693.     while(--len > 0)

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

  1695. 

  1696.     return 0;

  1697. }

  1698. 

  1699. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1700. {

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

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

  1703.     if (len >= 2 && len < 32768) {

  1704. 	/* XXX: any better upper bound */

  1705. 	uint8_t *cbuf = av_malloc(len - 1);

  1706. 	if (cbuf) {

  1707. 	    int i;

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

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

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

  1711. 		cbuf[i-1] = 0;

  1712. 	    else

  1713. 		cbuf[i] = 0;

  1714. 

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

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

  1717. 

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

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

  1720. 	    {

  1721. 		s->buggy_avid = 1;

  1722. 		//	if (s->first_picture)

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

  1724. 	    }

  1725. 

  1726. 	    av_free(cbuf);

  1727. 	}

  1728.     }

  1729. 

  1730.     return 0;

  1731. }

  1732. 

  1733. #if 0

  1734. static int valid_marker_list[] =

  1735. {

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

  1737. /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1738. /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1739. /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1740. /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1741. /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1742. /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1743. /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1744. /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1745. /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1746. /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1747. /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1748. /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1749. /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1750. /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1751. /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1752. /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

  1753. }

  1754. #endif

  1755. 

  1756. /* return the 8 bit start code value and update the search

  1757.    state. Return -1 if no start code found */

  1758. static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)

  1759. {

  1760.     uint8_t *buf_ptr;

  1761.     unsigned int v, v2;

  1762.     int val;

  1763. #ifdef DEBUG

  1764.     int skipped=0;

  1765. #endif

  1766. 

  1767.     buf_ptr = *pbuf_ptr;

  1768.     while (buf_ptr < buf_end) {

  1769.         v = *buf_ptr++;

  1770. 	v2 = *buf_ptr;

  1771.         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {

  1772. 	    val = *buf_ptr++;

  1773. 	    goto found;

  1774.         }

  1775. #ifdef DEBUG

  1776. 	skipped++;

  1777. #endif

  1778.     }

  1779.     val = -1;

  1780. found:

  1781. #ifdef DEBUG

  1782.     dprintf("find_marker skipped %d bytes\n", skipped);

  1783. #endif

  1784.     *pbuf_ptr = buf_ptr;

  1785.     return val;

  1786. }

  1787. 

  1788. static int mjpeg_decode_frame(AVCodecContext *avctx, 

  1789.                               void *data, int *data_size,

  1790.                               uint8_t *buf, int buf_size)

  1791. {

  1792.     MJpegDecodeContext *s = avctx->priv_data;

  1793.     uint8_t *buf_end, *buf_ptr;

  1794.     int start_code;

  1795.     AVFrame *picture = data;

  1796. 

  1797.     /* no supplementary picture */

  1798.     if (buf_size == 0)

  1799.         return 0;

  1800. 

  1801.     buf_ptr = buf;

  1802.     buf_end = buf + buf_size;

  1803.     while (buf_ptr < buf_end) {

  1804.         /* find start next marker */

  1805.         start_code = find_marker(&buf_ptr, buf_end);

  1806. 	{

  1807. 	    /* EOF */

  1808.             if (start_code < 0) {

  1809. 		goto the_end;

  1810.             } else {

  1811.                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);

  1812. 		

  1813. 		if ((buf_end - buf_ptr) > s->buffer_size)

  1814. 		{

  1815. 		    av_free(s->buffer);

  1816. 		    s->buffer_size = buf_end-buf_ptr;

  1817. 		    s->buffer = av_malloc(s->buffer_size);

  1818. 		    dprintf("buffer too small, expanding to %d bytes\n",

  1819. 			s->buffer_size);

  1820. 		}

  1821. 		

  1822. 		/* unescape buffer of SOS */

  1823. 		if (start_code == SOS)

  1824. 		{

  1825. 		    uint8_t *src = buf_ptr;

  1826. 		    uint8_t *dst = s->buffer;

  1827. 

  1828. 		    while (src<buf_end)

  1829. 		    {

  1830. 			uint8_t x = *(src++);

  1831. 

  1832. 			*(dst++) = x;

  1833. 			if (x == 0xff)

  1834. 			{

  1835.                             while(src<buf_end && x == 0xff)

  1836.                                 x = *(src++);

  1837. 

  1838. 			    if (x >= 0xd0 && x <= 0xd7)

  1839. 				*(dst++) = x;

  1840. 			    else if (x)

  1841. 				break;

  1842. 			}

  1843. 		    }

  1844. 		    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);

  1845. 		    

  1846. 		    dprintf("escaping removed %d bytes\n",

  1847. 			(buf_end - buf_ptr) - (dst - s->buffer));

  1848. 		}

  1849. 		else

  1850. 		    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);

  1851. 		

  1852. 		s->start_code = start_code;

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

  1854.                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);

  1855.                 }

  1856. 

  1857. 		/* process markers */

  1858. 		if (start_code >= 0xd0 && start_code <= 0xd7) {

  1859. 		    dprintf("restart marker: %d\n", start_code&0x0f);

  1860. 		    /* APP fields */

  1861. 		} else if (start_code >= APP0 && start_code <= APP15) {

  1862. 		    mjpeg_decode_app(s);

  1863. 		    /* Comment */

  1864. 		} else if (start_code == COM){

  1865. 		    mjpeg_decode_com(s);

  1866. 		}

  1867. 

  1868.                 switch(start_code) {

  1869.                 case SOI:

  1870. 		    s->restart_interval = 0;

  1871.                     /* nothing to do on SOI */

  1872.                     break;

  1873.                 case DQT:

  1874.                     mjpeg_decode_dqt(s);

  1875.                     break;

  1876.                 case DHT:

  1877.                     if(mjpeg_decode_dht(s) < 0){

  1878.                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");

  1879.                         return -1;

  1880.                     }

  1881.                     break;

  1882.                 case SOF0:

  1883.                     s->lossless=0;

  1884.                     if (mjpeg_decode_sof(s) < 0) 

  1885. 			return -1;

  1886.                     break;

  1887.                 case SOF3:

  1888.                     s->lossless=1;

  1889.                     if (mjpeg_decode_sof(s) < 0) 

  1890. 			return -1;

  1891.                     break;

  1892. 		case EOI:

  1893. 		    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 

  1894.                         break;

  1895. eoi_parser:

  1896. 		    {

  1897.                         if (s->interlaced) {

  1898.                             s->bottom_field ^= 1;

  1899.                             /* if not bottom field, do not output image yet */

  1900.                             if (s->bottom_field)

  1901.                                 goto not_the_end;

  1902.                         }

  1903.                         *picture = s->picture;

  1904.                         *data_size = sizeof(AVFrame);

  1905. 

  1906.                         if(!s->lossless){

  1907.                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 

  1908.                             picture->qstride= 0;

  1909.                             picture->qscale_table= s->qscale_table;

  1910.                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);

  1911.                             if(avctx->debug & FF_DEBUG_QP)

  1912.                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);

  1913.                             picture->quality*= FF_QP2LAMBDA;

  1914.                         }

  1915.                         

  1916.                         goto the_end;

  1917.                     }

  1918. 		    break;

  1919.                 case SOS:

  1920.                     mjpeg_decode_sos(s);

  1921. 		    /* buggy avid puts EOI every 10-20th frame */

  1922. 		    /* if restart period is over process EOI */

  1923. 		    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)

  1924. 			goto eoi_parser;

  1925.                     break;

  1926. 		case DRI:

  1927. 		    mjpeg_decode_dri(s);

  1928. 		    break;

  1929. 		case SOF1:

  1930. 		case SOF2:

  1931. 		case SOF5:

  1932. 		case SOF6:

  1933. 		case SOF7:

  1934. 		case SOF9:

  1935. 		case SOF10:

  1936. 		case SOF11:

  1937. 		case SOF13:

  1938. 		case SOF14:

  1939. 		case SOF15:

  1940. 		case JPG:

  1941. 		    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);

  1942. 		    break;

  1943. //		default:

  1944. //		    printf("mjpeg: unsupported marker (%x)\n", start_code);

  1945. //		    break;

  1946.                 }

  1947. 

  1948. not_the_end:

  1949. 		/* eof process start code */

  1950. 		buf_ptr += (get_bits_count(&s->gb)+7)/8;

  1951. 		dprintf("marker parser used %d bytes (%d bits)\n",

  1952. 		    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));

  1953.             }

  1954.         }

  1955.     }

  1956. the_end:

  1957.     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);

  1958. //    return buf_end - buf_ptr;

  1959.     return buf_ptr - buf;

  1960. }

  1961. 

  1962. static int mjpegb_decode_frame(AVCodecContext *avctx, 

  1963.                               void *data, int *data_size,

  1964.                               uint8_t *buf, int buf_size)

  1965. {

  1966.     MJpegDecodeContext *s = avctx->priv_data;

  1967.     uint8_t *buf_end, *buf_ptr;

  1968.     AVFrame *picture = data;

  1969.     GetBitContext hgb; /* for the header */

  1970.     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;

  1971.     uint32_t field_size, sod_offs;

  1972. 

  1973.     /* no supplementary picture */

  1974.     if (buf_size == 0)

  1975.         return 0;

  1976. 

  1977.     buf_ptr = buf;

  1978.     buf_end = buf + buf_size;

  1979.     

  1980. read_header:

  1981.     /* reset on every SOI */

  1982.     s->restart_interval = 0;

  1983.     s->mjpb_skiptosod = 0;

  1984. 

  1985.     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);

  1986. 

  1987.     skip_bits(&hgb, 32); /* reserved zeros */

  1988.     

  1989.     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))

  1990.     {

  1991. 	dprintf("not mjpeg-b (bad fourcc)\n");

  1992. 	return 0;

  1993.     }

  1994. 

  1995.     field_size = get_bits_long(&hgb, 32); /* field size */

  1996.     dprintf("field size: 0x%x\n", field_size);

  1997.     skip_bits(&hgb, 32); /* padded field size */

  1998.     second_field_offs = get_bits_long(&hgb, 32);

  1999.     dprintf("second field offs: 0x%x\n", second_field_offs);

  2000.     if (second_field_offs)

  2001. 	s->interlaced = 1;

  2002. 

  2003.     dqt_offs = get_bits_long(&hgb, 32);

  2004.     dprintf("dqt offs: 0x%x\n", dqt_offs);

  2005.     if (dqt_offs)

  2006.     {

  2007. 	init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);

  2008. 	s->start_code = DQT;

  2009. 	mjpeg_decode_dqt(s);

  2010.     }

  2011.     

  2012.     dht_offs = get_bits_long(&hgb, 32);

  2013.     dprintf("dht offs: 0x%x\n", dht_offs);

  2014.     if (dht_offs)

  2015.     {

  2016. 	init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);

  2017. 	s->start_code = DHT;

  2018. 	mjpeg_decode_dht(s);

  2019.     }

  2020. 

  2021.     sof_offs = get_bits_long(&hgb, 32);

  2022.     dprintf("sof offs: 0x%x\n", sof_offs);

  2023.     if (sof_offs)

  2024.     {

  2025. 	init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);

  2026. 	s->start_code = SOF0;

  2027. 	if (mjpeg_decode_sof(s) < 0)

  2028. 	    return -1;

  2029.     }

  2030. 

  2031.     sos_offs = get_bits_long(&hgb, 32);

  2032.     dprintf("sos offs: 0x%x\n", sos_offs);

  2033.     sod_offs = get_bits_long(&hgb, 32);

  2034.     dprintf("sod offs: 0x%x\n", sod_offs);

  2035.     if (sos_offs)

  2036.     {

  2037. //	init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);

  2038. 	init_get_bits(&s->gb, buf+sos_offs, field_size*8);

  2039. 	s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));

  2040. 	s->start_code = SOS;

  2041. 	mjpeg_decode_sos(s);

  2042.     }

  2043. 

  2044.     if (s->interlaced) {

  2045.         s->bottom_field ^= 1;

  2046.         /* if not bottom field, do not output image yet */

  2047.         if (s->bottom_field && second_field_offs)

  2048. 	{

  2049. 	    buf_ptr = buf + second_field_offs;

  2050. 	    second_field_offs = 0;

  2051. 	    goto read_header;

  2052.     	}

  2053.     }

  2054. 

  2055.     //XXX FIXME factorize, this looks very similar to the EOI code

  2056. 

  2057.     *picture= s->picture;

  2058.     *data_size = sizeof(AVFrame);

  2059.     

  2060.     if(!s->lossless){

  2061.         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 

  2062.         picture->qstride= 0;

  2063.         picture->qscale_table= s->qscale_table;

  2064.         memset(picture->qscale_table, picture->quality, (s->width+15)/16);

  2065.         if(avctx->debug & FF_DEBUG_QP)

  2066.             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);

  2067.         picture->quality*= FF_QP2LAMBDA;

  2068.     }

  2069. 

  2070.     return buf_ptr - buf;

  2071. }

  2072. 

  2073. #include "sp5x.h"

  2074. 

  2075. static int sp5x_decode_frame(AVCodecContext *avctx, 

  2076.                               void *data, int *data_size,

  2077.                               uint8_t *buf, int buf_size)

  2078. {

  2079. #if 0

  2080.     MJpegDecodeContext *s = avctx->priv_data;

  2081. #endif

  2082.     const int qscale = 5;

  2083.     uint8_t *buf_ptr, *buf_end, *recoded;

  2084.     int i = 0, j = 0;

  2085. 

  2086.     /* no supplementary picture */

  2087.     if (buf_size == 0)

  2088.         return 0;

  2089. 

  2090.     if (!avctx->width || !avctx->height)

  2091. 	return -1;

  2092. 

  2093.     buf_ptr = buf;

  2094.     buf_end = buf + buf_size;

  2095. 

  2096. #if 1

  2097.     recoded = av_mallocz(buf_size + 1024);

  2098.     if (!recoded)

  2099. 	return -1;

  2100. 

  2101.     /* SOI */

  2102.     recoded[j++] = 0xFF;

  2103.     recoded[j++] = 0xD8;

  2104. 

  2105.     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));

  2106.     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);

  2107.     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);

  2108.     j += sizeof(sp5x_data_dqt);

  2109. 

  2110.     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));

  2111.     j += sizeof(sp5x_data_dht);

  2112. 

  2113.     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));

  2114.     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;

  2115.     recoded[j+6] = avctx->coded_height & 0xFF;

  2116.     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;

  2117.     recoded[j+8] = avctx->coded_width & 0xFF;

  2118.     j += sizeof(sp5x_data_sof);

  2119. 

  2120.     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));

  2121.     j += sizeof(sp5x_data_sos);

  2122. 

  2123.     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)

  2124.     {

  2125. 	recoded[j++] = buf[i];

  2126. 	if (buf[i] == 0xff)

  2127. 	    recoded[j++] = 0;

  2128.     }

  2129. 

  2130.     /* EOI */

  2131.     recoded[j++] = 0xFF;

  2132.     recoded[j++] = 0xD9;

  2133. 

  2134.     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);

  2135. 

  2136.     av_free(recoded);

  2137. 

  2138. #else

  2139.     /* SOF */

  2140.     s->bits = 8;

  2141.     s->width  = avctx->coded_width;

  2142.     s->height = avctx->coded_height;

  2143.     s->nb_components = 3;

  2144.     s->component_id[0] = 0;

  2145.     s->h_count[0] = 2;

  2146.     s->v_count[0] = 2;

  2147.     s->quant_index[0] = 0;

  2148.     s->component_id[1] = 1;

  2149.     s->h_count[1] = 1;

  2150.     s->v_count[1] = 1;

  2151.     s->quant_index[1] = 1;

  2152.     s->component_id[2] = 2;

  2153.     s->h_count[2] = 1;

  2154.     s->v_count[2] = 1;

  2155.     s->quant_index[2] = 1;

  2156.     s->h_max = 2;

  2157.     s->v_max = 2;

  2158.     

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

  2160.     avctx->pix_fmt = PIX_FMT_YUV420P;

  2161.     s->interlaced = 0;

  2162.     

  2163.     s->picture.reference = 0;

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

  2165.     {

  2166. 	fprintf(stderr, "get_buffer() failed\n");

  2167. 	return -1;

  2168.     }

  2169. 

  2170.     s->picture.pict_type = I_TYPE;

  2171.     s->picture.key_frame = 1;

  2172. 

  2173.     for (i = 0; i < 3; i++)

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

  2175. 

  2176.     /* DQT */

  2177.     for (i = 0; i < 64; i++)

  2178.     {

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

  2180. 	s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];

  2181.     }

  2182.     s->qscale[0] = FFMAX(

  2183. 	s->quant_matrixes[0][s->scantable.permutated[1]],

  2184. 	s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;

  2185. 

  2186.     for (i = 0; i < 64; i++)

  2187.     {

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

  2189. 	s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];

  2190.     }

  2191.     s->qscale[1] = FFMAX(

  2192. 	s->quant_matrixes[1][s->scantable.permutated[1]],

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

  2194. 

  2195.     /* DHT */

  2196. 

  2197.     /* SOS */

  2198.     s->comp_index[0] = 0;

  2199.     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];

  2200.     s->h_scount[0] = s->h_count[0];

  2201.     s->v_scount[0] = s->v_count[0];

  2202.     s->dc_index[0] = 0;

  2203.     s->ac_index[0] = 0;

  2204. 

  2205.     s->comp_index[1] = 1;

  2206.     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];

  2207.     s->h_scount[1] = s->h_count[1];

  2208.     s->v_scount[1] = s->v_count[1];

  2209.     s->dc_index[1] = 1;

  2210.     s->ac_index[1] = 1;

  2211. 

  2212.     s->comp_index[2] = 2;

  2213.     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];

  2214.     s->h_scount[2] = s->h_count[2];

  2215.     s->v_scount[2] = s->v_count[2];

  2216.     s->dc_index[2] = 1;

  2217.     s->ac_index[2] = 1;

  2218.     

  2219.     for (i = 0; i < 3; i++)

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

  2221. 

  2222.     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);

  2223.     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);

  2224. 

  2225.     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);

  2226.     

  2227.     return mjpeg_decode_scan(s);

  2228. #endif

  2229. 

  2230.     return i;

  2231. }

  2232. 

  2233. static int mjpeg_decode_end(AVCodecContext *avctx)

  2234. {

  2235.     MJpegDecodeContext *s = avctx->priv_data;

  2236.     int i, j;

  2237. 

  2238.     av_free(s->buffer);

  2239.     av_free(s->qscale_table);

  2240.     

  2241.     for(i=0;i<2;i++) {

  2242.         for(j=0;j<4;j++)

  2243.             free_vlc(&s->vlcs[i][j]);

  2244.     }

  2245.     return 0;

  2246. }

  2247. 

  2248. AVCodec mjpeg_decoder = {

  2249.     "mjpeg",

  2250.     CODEC_TYPE_VIDEO,

  2251.     CODEC_ID_MJPEG,

  2252.     sizeof(MJpegDecodeContext),

  2253.     mjpeg_decode_init,

  2254.     NULL,

  2255.     mjpeg_decode_end,

  2256.     mjpeg_decode_frame,

  2257.     CODEC_CAP_DR1,

  2258.     NULL

  2259. };

  2260. 

  2261. AVCodec mjpegb_decoder = {

  2262.     "mjpegb",

  2263.     CODEC_TYPE_VIDEO,

  2264.     CODEC_ID_MJPEGB,

  2265.     sizeof(MJpegDecodeContext),

  2266.     mjpeg_decode_init,

  2267.     NULL,

  2268.     mjpeg_decode_end,

  2269.     mjpegb_decode_frame,

  2270.     CODEC_CAP_DR1,

  2271.     NULL

  2272. };

  2273. 

  2274. AVCodec sp5x_decoder = {

  2275.     "sp5x",

  2276.     CODEC_TYPE_VIDEO,

  2277.     CODEC_ID_SP5X,

  2278.     sizeof(MJpegDecodeContext),

  2279.     mjpeg_decode_init,

  2280.     NULL,

  2281.     mjpeg_decode_end,

  2282.     sp5x_decode_frame,

  2283.     CODEC_CAP_DR1,

  2284.     NULL

  2285. };

  2286. 

  2287. #ifdef CONFIG_ENCODERS

  2288. AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them

  2289.     "ljpeg",

  2290.     CODEC_TYPE_VIDEO,

  2291.     CODEC_ID_LJPEG,

  2292.     sizeof(MpegEncContext),

  2293.     MPV_encode_init,

  2294.     encode_picture_lossless,

  2295.     MPV_encode_end,

  2296. };

  2297. #endif

  2298. 

  2299. AVCodecParser mjpeg_parser = {

  2300.     { CODEC_ID_MJPEG },

  2301.     sizeof(ParseContext),

  2302.     NULL,

  2303.     jpeg_parse,

  2304.     ff_parse_close,

  2305. };