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

2115 lines
63KB
Raw Blame History 

  1. /*

  2.  * MJPEG encoder and decoder

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

  4.  *

  5.  * This library is free software; you can redistribute it and/or

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

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

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

  9.  *

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

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

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

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

  18.  *

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

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

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

  22.  */

  23. 

  24. /**

  25.  * @file mjpeg.c

  26.  * MJPEG encoder and decoder.

  27.  */

  28.  

  29. //#define DEBUG

  30. #include <assert.h>

  31. 

  32. #include "avcodec.h"

  33. #include "dsputil.h"

  34. #include "mpegvideo.h"

  35. 

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

  37. /* not yet working */

  38. #undef TWOMATRIXES

  39. 

  40. typedef struct MJpegContext {

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

  42.     uint16_t huff_code_dc_luminance[12];

  43.     uint8_t huff_size_dc_chrominance[12];

  44.     uint16_t huff_code_dc_chrominance[12];

  45. 

  46.     uint8_t huff_size_ac_luminance[256];

  47.     uint16_t huff_code_ac_luminance[256];

  48.     uint8_t huff_size_ac_chrominance[256];

  49.     uint16_t huff_code_ac_chrominance[256];

  50. } MJpegContext;

  51. 

  52. /* JPEG marker codes */

  53. typedef enum {

  54.     /* start of frame */

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

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

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

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

  59. 

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

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

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

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

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

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

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

  67. 

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

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

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

  71. 

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

  73. 

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

  75. 

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

  77.     RST0  = 0xd0,

  78.     RST1  = 0xd1,

  79.     RST2  = 0xd2,

  80.     RST3  = 0xd3,

  81.     RST4  = 0xd4,

  82.     RST5  = 0xd5,

  83.     RST6  = 0xd6,

  84.     RST7  = 0xd7,

  85. 

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

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

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

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

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

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

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

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

  94. 

  95.     APP0  = 0xe0,

  96.     APP1  = 0xe1,

  97.     APP2  = 0xe2,

  98.     APP3  = 0xe3,

  99.     APP4  = 0xe4,

  100.     APP5  = 0xe5,

  101.     APP6  = 0xe6,

  102.     APP7  = 0xe7,

  103.     APP8  = 0xe8,

  104.     APP9  = 0xe9,

  105.     APP10 = 0xea,

  106.     APP11 = 0xeb,

  107.     APP12 = 0xec,

  108.     APP13 = 0xed,

  109.     APP14 = 0xee,

  110.     APP15 = 0xef,

  111. 

  112.     JPG0  = 0xf0,

  113.     JPG1  = 0xf1,

  114.     JPG2  = 0xf2,

  115.     JPG3  = 0xf3,

  116.     JPG4  = 0xf4,

  117.     JPG5  = 0xf5,

  118.     JPG6  = 0xf6,

  119.     JPG7  = 0xf7,

  120.     JPG8  = 0xf8,

  121.     JPG9  = 0xf9,

  122.     JPG10 = 0xfa,

  123.     JPG11 = 0xfb,

  124.     JPG12 = 0xfc,

  125.     JPG13 = 0xfd,

  126. 

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

  128. 

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

  130. 

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

  132. } JPEG_MARKER;

  133. 

  134. #if 0

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

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

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

  138.  */

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

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

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

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

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

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

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

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

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

  148. };

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

  150.     17,  18,  24,  47,  99,  99,  99,  99,

  151.     18,  21,  26,  66,  99,  99,  99,  99,

  152.     24,  26,  56,  99,  99,  99,  99,  99,

  153.     47,  66,  99,  99,  99,  99,  99,  99,

  154.     99,  99,  99,  99,  99,  99,  99,  99,

  155.     99,  99,  99,  99,  99,  99,  99,  99,

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

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

  158. };

  159. #endif

  160. 

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

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

  163. static const uint8_t bits_dc_luminance[17] =

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

  165. static const uint8_t val_dc_luminance[] =

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

  167. 

  168. static const uint8_t bits_dc_chrominance[17] =

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

  170. static const uint8_t val_dc_chrominance[] =

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

  172. 

  173. static const uint8_t bits_ac_luminance[17] =

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

  175. static const uint8_t val_ac_luminance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  196.   0xf9, 0xfa 

  197. };

  198. 

  199. static const uint8_t bits_ac_chrominance[17] =

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

  201. 

  202. static const uint8_t val_ac_chrominance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  223.   0xf9, 0xfa 

  224. };

  225. 

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

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

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

  229. {

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

  231. 

  232.     code = 0;

  233.     k = 0;

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

  235.         nb = bits_table[i];

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

  237.             sym = val_table[k++];

  238.             huff_size[sym] = i;

  239.             huff_code[sym] = code;

  240.             code++;

  241.         }

  242.         code <<= 1;

  243.     }

  244. }

  245. 

  246. int mjpeg_init(MpegEncContext *s)

  247. {

  248.     MJpegContext *m;

  249.     

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

  251.     if (!m)

  252.         return -1;

  253.     

  254.     s->min_qcoeff=-1023;

  255.     s->max_qcoeff= 1023;

  256. 

  257.     /* build all the huffman tables */

  258.     build_huffman_codes(m->huff_size_dc_luminance,

  259.                         m->huff_code_dc_luminance,

  260.                         bits_dc_luminance,

  261.                         val_dc_luminance);

  262.     build_huffman_codes(m->huff_size_dc_chrominance,

  263.                         m->huff_code_dc_chrominance,

  264.                         bits_dc_chrominance,

  265.                         val_dc_chrominance);

  266.     build_huffman_codes(m->huff_size_ac_luminance,

  267.                         m->huff_code_ac_luminance,

  268.                         bits_ac_luminance,

  269.                         val_ac_luminance);

  270.     build_huffman_codes(m->huff_size_ac_chrominance,

  271.                         m->huff_code_ac_chrominance,

  272.                         bits_ac_chrominance,

  273.                         val_ac_chrominance);

  274.     

  275.     s->mjpeg_ctx = m;

  276.     return 0;

  277. }

  278. 

  279. void mjpeg_close(MpegEncContext *s)

  280. {

  281.     av_free(s->mjpeg_ctx);

  282. }

  283. 

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

  285.     switch(predictor){\

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

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

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

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

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

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

  292.         default:\

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

  294.     }

  295. 

  296. #ifdef CONFIG_ENCODERS

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

  298. {

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

  300.     put_bits(p, 8, code);

  301. }

  302. 

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

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

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

  306. {

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

  308.     int n, i;

  309. 

  310.     put_bits(p, 4, table_class);

  311.     put_bits(p, 4, table_id);

  312. 

  313.     n = 0;

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

  315.         n += bits_table[i];

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

  317.     }

  318. 

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

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

  321. 

  322.     return n + 17;

  323. }

  324. 

  325. static void jpeg_table_header(MpegEncContext *s)

  326. {

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

  328.     int i, j, size;

  329.     uint8_t *ptr;

  330. 

  331.     /* quant matrixes */

  332.     put_marker(p, DQT);

  333. #ifdef TWOMATRIXES

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

  335. #else

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

  337. #endif

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

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

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

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

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

  343.     }

  344. #ifdef TWOMATRIXES

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

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

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

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

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

  350.     }

  351. #endif

  352. 

  353.     /* huffman table */

  354.     put_marker(p, DHT);

  355.     flush_put_bits(p);

  356.     ptr = pbBufPtr(p);

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

  358.     size = 2;

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

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

  361.     

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

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

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

  365.     ptr[1] = size;

  366. }

  367. 

  368. static void jpeg_put_comments(MpegEncContext *s)

  369. {

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

  371.     int size;

  372.     uint8_t *ptr;

  373. 

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

  375.     {

  376.     /* JFIF header */

  377.     put_marker(p, APP0);

  378.     put_bits(p, 16, 16);

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

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

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

  382.     switch(s->aspect_ratio_info)

  383.     {

  384. 	case FF_ASPECT_4_3_625:

  385. 	case FF_ASPECT_4_3_525:

  386. 	    put_bits(p, 16, 4); 

  387. 	    put_bits(p, 16, 3);

  388. 	    break;

  389. 	case FF_ASPECT_16_9_625:

  390. 	case FF_ASPECT_16_9_525:

  391. 	    put_bits(p, 16, 16); 

  392. 	    put_bits(p, 16, 9);

  393. 	    break;

  394. 	case FF_ASPECT_EXTENDED:

  395. 	    put_bits(p, 16, s->aspected_width);

  396. 	    put_bits(p, 16, s->aspected_height);

  397. 	    break;

  398. 	case FF_ASPECT_SQUARE:

  399. 	default:

  400. 	    put_bits(p, 16, 1); /* aspect: 1:1 */

  401. 	    put_bits(p, 16, 1);

  402. 	    break;

  403.     }

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

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

  406.     }

  407. 

  408.     /* comment */

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

  410.         put_marker(p, COM);

  411.         flush_put_bits(p);

  412.         ptr = pbBufPtr(p);

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

  414.         put_string(p, LIBAVCODEC_IDENT);

  415.         size = strlen(LIBAVCODEC_IDENT)+3;

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

  417.         ptr[1] = size;

  418.     }

  419. }

  420. 

  421. void mjpeg_picture_header(MpegEncContext *s)

  422. {

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

  424. 

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

  426. 

  427.     if (!s->mjpeg_data_only_frames)

  428.     {

  429.     jpeg_put_comments(s);    

  430. 

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

  432. 

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

  434. 

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

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

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

  438.     else

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

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

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

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

  443.     

  444.     /* Y component */

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

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

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

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

  449.     

  450.     /* Cb component */

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

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

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

  454. #ifdef TWOMATRIXES

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

  456. #else

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

  458. #endif

  459. 

  460.     /* Cr component */

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

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

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

  464. #ifdef TWOMATRIXES

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

  466. #else

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

  468. #endif

  469.     }

  470. 

  471.     /* scan header */

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

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

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

  475.     

  476.     /* Y component */

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

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

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

  480.     

  481.     /* Cb component */

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

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

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

  485.     

  486.     /* Cr component */

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

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

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

  490. 

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

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

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

  494. }

  495. 

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

  497. {

  498.     int size= get_bit_count(&s->pb) - start*8;

  499.     int i, ff_count;

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

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

  502.     

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

  504.     size >>= 3;

  505.     

  506.     ff_count=0;

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

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

  509.     }

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

  511.         int acc, v;

  512. 

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

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

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

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

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

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

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

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

  521. 

  522.         acc>>=4;

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

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

  525.         ff_count+= acc&0xFF;

  526.     }

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

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

  529.     }

  530. 

  531.     if(ff_count==0) return;

  532.     

  533.     /* skip put bits */

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

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

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

  537.     flush_put_bits(&s->pb); 

  538. 

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

  540.         int v= buf[i];

  541. 

  542.         if(v==0xFF){

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

  544.             buf[i+ff_count]= 0;

  545.             ff_count--;

  546.         }

  547. 

  548.         buf[i+ff_count]= v;

  549.     }

  550. }

  551. 

  552. void mjpeg_picture_trailer(MpegEncContext *s)

  553. {

  554.     int pad= (-get_bit_count(&s->pb))&7;

  555.     

  556.     put_bits(&s->pb, pad,0xFF>>(8-pad));

  557.     flush_put_bits(&s->pb);

  558. 

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

  560.     

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

  562. 

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

  564. }

  565. 

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

  567. 				   uint8_t *huff_size, uint16_t *huff_code)

  568. {

  569.     int mant, nbits;

  570. 

  571.     if (val == 0) {

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

  573.     } else {

  574.         mant = val;

  575.         if (val < 0) {

  576.             val = -val;

  577.             mant--;

  578.         }

  579.         

  580.         nbits= av_log2_16bit(val) + 1;

  581.             

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

  583.         

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

  585.     }

  586. }

  587. 

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

  589. {

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

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

  592.     MJpegContext *m = s->mjpeg_ctx;

  593.     uint8_t *huff_size_ac;

  594.     uint16_t *huff_code_ac;

  595.     

  596.     /* DC coef */

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

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

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

  600.     if (n < 4) {

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

  602.         huff_size_ac = m->huff_size_ac_luminance;

  603.         huff_code_ac = m->huff_code_ac_luminance;

  604.     } else {

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

  606.         huff_size_ac = m->huff_size_ac_chrominance;

  607.         huff_code_ac = m->huff_code_ac_chrominance;

  608.     }

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

  610.     

  611.     /* AC coefs */

  612.     

  613.     run = 0;

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

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

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

  617.         val = block[j];

  618.         if (val == 0) {

  619.             run++;

  620.         } else {

  621.             while (run >= 16) {

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

  623.                 run -= 16;

  624.             }

  625.             mant = val;

  626.             if (val < 0) {

  627.                 val = -val;

  628.                 mant--;

  629.             }

  630.             

  631.             nbits= av_log2(val) + 1;

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

  633. 

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

  635.         

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

  637.             run = 0;

  638.         }

  639.     }

  640. 

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

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

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

  644. }

  645. 

  646. void mjpeg_encode_mb(MpegEncContext *s, 

  647.                      DCTELEM block[6][64])

  648. {

  649.     int i;

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

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

  652.     }

  653. }

  654. 

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

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

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

  658.     AVFrame *pict = data;

  659.     const int width= s->width;

  660.     const int height= s->height;

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

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

  663. 

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

  665. 

  666.     *p = *pict;

  667.     p->pict_type= FF_I_TYPE;

  668.     p->key_frame= 1;

  669.     

  670.     mjpeg_picture_header(s);

  671. 

  672.     s->header_bits= get_bit_count(&s->pb);

  673. 

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

  675.         int x, y, i;

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

  677.         uint16_t buffer[2048][4];

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

  679. 

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

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

  682.         }

  683. 

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

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

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

  687. 

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

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

  690.             }

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

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

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

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

  695. 

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

  697.                     int pred, diff;

  698. 

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

  700.                         

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

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

  703.                     

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

  705. 

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

  707.                     

  708.                     if(i==0)

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

  710.                     else

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

  712.                 }

  713.             }

  714.         }

  715.     }else{

  716.         int mb_x, mb_y, i;

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

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

  719.         

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

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

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

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

  724.                         uint8_t *ptr;

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

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

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

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

  729. 

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

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

  732.                                 int pred;

  733. 

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

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

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

  737.                                         pred= 128;

  738.                                     }else{

  739.                                         pred= ptr[-1];

  740.                                     }

  741.                                 }else{

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

  743.                                         pred= ptr[-linesize];

  744.                                     }else{

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

  746.                                     }

  747.                                 }

  748.                                 

  749.                                 if(i==0)

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

  751.                                 else

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

  753.                             }

  754.                         }

  755.                     }

  756.                 }else{

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

  758.                         uint8_t *ptr;

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

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

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

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

  763.                              

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

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

  766.                                 int pred;

  767. 

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

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

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

  771. 

  772.                                 if(i==0)

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

  774.                                 else

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

  776.                             }

  777.                         }

  778.                     }

  779.                 }

  780.             }

  781.         }

  782.     }

  783. 

  784.     emms_c();

  785.     

  786.     mjpeg_picture_trailer(s);

  787.     s->picture_number++;

  788. 

  789.     flush_put_bits(&s->pb);

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

  791. //    return (get_bit_count(&f->pb)+7)/8;

  792. }

  793. 

  794. #endif //CONFIG_ENCODERS

  795. 

  796. /******************************************/

  797. /* decoding */

  798. 

  799. #define MAX_COMPONENTS 4

  800. 

  801. typedef struct MJpegDecodeContext {

  802.     AVCodecContext *avctx;

  803.     GetBitContext gb;

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

  805. 

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

  807.     int buffer_size;

  808.     uint8_t *buffer;

  809. 

  810.     int16_t quant_matrixes[4][64];

  811.     VLC vlcs[2][4];

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

  813. 

  814.     int org_width, org_height;  /* size given at codec init */

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

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

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

  818.     int lossless;

  819.     int rgb;

  820.     int rct;            /* standard rct */  

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

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

  823. 

  824.     int width, height;

  825.     int mb_width, mb_height;

  826.     int nb_components;

  827.     int component_id[MAX_COMPONENTS];

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

  829.     int v_count[MAX_COMPONENTS];

  830.     int comp_index[MAX_COMPONENTS];

  831.     int dc_index[MAX_COMPONENTS];

  832.     int ac_index[MAX_COMPONENTS];

  833.     int nb_blocks[MAX_COMPONENTS];

  834.     int h_scount[MAX_COMPONENTS];

  835.     int v_scount[MAX_COMPONENTS];

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

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

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

  839.     uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */

  840.     int linesize[MAX_COMPONENTS];

  841.     uint8_t *qscale_table;

  842.     DCTELEM block[64] __align8;

  843.     ScanTable scantable;

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

  845. 

  846.     int restart_interval;

  847.     int restart_count;

  848. 

  849.     int buggy_avid;

  850.     int interlace_polarity;

  851. } MJpegDecodeContext;

  852. 

  853. static int mjpeg_decode_dht(MJpegDecodeContext *s);

  854. 

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

  856.                       int nb_codes)

  857. {

  858.     uint8_t huff_size[256];

  859.     uint16_t huff_code[256];

  860. 

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

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

  863.     

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

  865. }

  866. 

  867. static int mjpeg_decode_init(AVCodecContext *avctx)

  868. {

  869.     MJpegDecodeContext *s = avctx->priv_data;

  870.     MpegEncContext s2;

  871. 

  872.     s->avctx = avctx;

  873. 

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

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

  876.     s2.flags= avctx->flags;

  877.     s2.avctx= avctx;

  878. //    s2->out_format = FMT_MJPEG;

  879.     s2.width = 8;

  880.     s2.height = 8;

  881.     if (MPV_common_init(&s2) < 0)

  882.        return -1;

  883.     s->scantable= s2.intra_scantable;

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

  885.     MPV_common_end(&s2);

  886. 

  887.     s->mpeg_enc_ctx_allocated = 0;

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

  889. 				but photojpg files could ahive bigger sizes */

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

  891.     if (!s->buffer)

  892. 	return -1;

  893.     s->start_code = -1;

  894.     s->first_picture = 1;

  895.     s->org_width = avctx->width;

  896.     s->org_height = avctx->height;

  897.     

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

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

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

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

  902. 

  903.     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)

  904.     {

  905. 	printf("mjpeg: using external huffman table\n");

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

  907. 	mjpeg_decode_dht(s);

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

  909.     }

  910. 

  911.     return 0;

  912. }

  913. 

  914. /* quantize tables */

  915. static int mjpeg_decode_dqt(MJpegDecodeContext *s)

  916. {

  917.     int len, index, i, j;

  918.     

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

  920. 

  921.     while (len >= 65) {

  922.         /* only 8 bit precision handled */

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

  924. 	{

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

  926.             return -1;

  927. 	}

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

  929.         if (index >= 4)

  930.             return -1;

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

  932.         /* read quant table */

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

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

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

  936.         }

  937. 

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

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

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

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

  942.         len -= 65;

  943.     }

  944.     

  945.     return 0;

  946. }

  947. 

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

  949. static int mjpeg_decode_dht(MJpegDecodeContext *s)

  950. {

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

  952.     uint8_t bits_table[17];

  953.     uint8_t val_table[256];

  954.     

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

  956. 

  957.     while (len > 0) {

  958.         if (len < 17)

  959.             return -1;

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

  961.         if (class >= 2)

  962.             return -1;

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

  964.         if (index >= 4)

  965.             return -1;

  966.         n = 0;

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

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

  969.             n += bits_table[i];

  970.         }

  971.         len -= 17;

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

  973.             return -1;

  974. 

  975.         code_max = 0;

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

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

  978.             if (v > code_max)

  979.                 code_max = v;

  980.             val_table[i] = v;

  981.         }

  982.         len -= n;

  983. 

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

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

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

  987.                class, index, code_max + 1);

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

  989.             return -1;

  990.         }

  991.     }

  992.     return 0;

  993. }

  994. 

  995. static int mjpeg_decode_sof(MJpegDecodeContext *s)

  996. {

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

  998. 

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

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

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

  1002.     

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

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

  1005. 

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

  1007.         printf("only 8 bits/component accepted\n");

  1008.         return -1;

  1009.     }

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

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

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

  1013. 

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

  1015.     if (nb_components <= 0 ||

  1016.         nb_components > MAX_COMPONENTS)

  1017.         return -1;

  1018.     s->nb_components = nb_components;

  1019.     s->h_max = 1;

  1020.     s->v_max = 1;

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

  1022.         /* component id */

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

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

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

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

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

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

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

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

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

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

  1033.             return -1;

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

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

  1036.     }

  1037.     

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

  1039. 

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

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

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

  1043.         for(i=0;i<MAX_COMPONENTS;i++)

  1044.             av_freep(&s->current_picture[i]);

  1045.             

  1046.         av_freep(&s->qscale_table);

  1047.             

  1048.         s->width = width;

  1049.         s->height = height;

  1050.         /* test interlaced mode */

  1051.         if (s->first_picture &&

  1052.             s->org_height != 0 &&

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

  1054.             s->interlaced = 1;

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

  1056. 	    s->bottom_field = 0;

  1057.         }

  1058. 

  1059.         if(s->rgb){

  1060.             int w, h;

  1061.             w = s->width;

  1062.             h = s->height;

  1063.             if (s->interlaced)

  1064.                 w *= 2;

  1065.             s->linesize[0] = 4*w;

  1066.             s->current_picture[0] = av_mallocz(4*w * h);

  1067.             s->current_picture[1] = s->current_picture[2] = NULL;

  1068.         }else{

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

  1070.             int w, h;

  1071.             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);

  1072.             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);

  1073.             w = w * 8 * s->h_count[i];

  1074.             h = h * 8 * s->v_count[i];

  1075.             if (s->interlaced)

  1076.                 w *= 2;

  1077.             s->linesize[i] = w;

  1078.             s->current_picture[i] = av_mallocz(w * h);

  1079. 	    if (!s->current_picture[i])

  1080. 	    {

  1081. 		dprintf("error: no picture buffers allocated\n");

  1082. 		return -1;

  1083. 	    }

  1084.           }

  1085.         }

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

  1087. 

  1088.         s->first_picture = 0;

  1089.     }

  1090. 

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

  1092.     {

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

  1094.     }

  1095.     

  1096.     return 0;

  1097. }

  1098. 

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

  1100. {

  1101.     int code;

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

  1103.     if (code < 0)

  1104.     {

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

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

  1107.         return 0xffff;

  1108.     }

  1109. 

  1110.     if(code)

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

  1112.     else

  1113.         return 0;

  1114. }

  1115. 

  1116. /* decode block and dequantize */

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

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

  1119. {

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

  1121.     VLC *ac_vlc;

  1122.     int16_t *quant_matrix;

  1123. 

  1124.     /* DC coef */

  1125.     val = mjpeg_decode_dc(s, dc_index);

  1126.     if (val == 0xffff) {

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

  1128.         return -1;

  1129.     }

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

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

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

  1133.     block[0] = val;

  1134.     /* AC coefs */

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

  1136.     i = 1;

  1137.     for(;;) {

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

  1139. 

  1140.         if (code < 0) {

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

  1142.             return -1;

  1143.         }

  1144.         /* EOB */

  1145.         if (code == 0)

  1146.             break;

  1147.         if (code == 0xf0) {

  1148.             i += 16;

  1149.         } else {

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

  1151.             i += code >> 4;

  1152.             if (i >= 64) {

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

  1154.                 return -1;

  1155.             }

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

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

  1158.             i++;

  1159.             if (i >= 64)

  1160.                 break;

  1161.         }

  1162.     }

  1163.     return 0;

  1164. }

  1165. 

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

  1167.     int i, mb_x, mb_y;

  1168.     uint16_t buffer[2048][4];

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

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

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

  1172.     

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

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

  1175.     }

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

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

  1178.         uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);

  1179. 

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

  1181.             ptr += linesize >> 1;

  1182. 

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

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

  1185.         }

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

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

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

  1189. 

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

  1191.                 int pred;

  1192. 

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

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

  1195. 

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

  1197.                 

  1198.                 left[i]= 

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

  1200.             }

  1201. 

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

  1203.                 align_get_bits(&s->gb);

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

  1205.             }

  1206.         }

  1207. 

  1208.         if(s->rct){

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

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

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

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

  1213.             }

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

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

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

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

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

  1219.             }

  1220.         }else{

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

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

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

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

  1225.             }

  1226.         }

  1227.     }

  1228.     return 0;

  1229. }

  1230. 

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

  1232.     int i, mb_x, mb_y;

  1233.     const int nb_components=3;

  1234. 

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

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

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

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

  1239. 

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

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

  1242.                     uint8_t *ptr;

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

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

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

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

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

  1248.                     x = 0;

  1249.                     y = 0;

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

  1251.                     

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

  1253.                         int pred;

  1254. 

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

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

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

  1258.                                 pred= 128 << point_transform;

  1259.                             }else{

  1260.                                 pred= ptr[-1];

  1261.                             }

  1262.                         }else{

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

  1264.                                 pred= ptr[-linesize];

  1265.                             }else{

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

  1267.                             }

  1268.                         }

  1269.                         

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

  1271.                             ptr += linesize >> 1;

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

  1273. 

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

  1275.                             x = 0;

  1276.                             y++;

  1277.                         }

  1278.                     }

  1279.                 }

  1280.             }else{

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

  1282.                     uint8_t *ptr;

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

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

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

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

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

  1288.                     x = 0;

  1289.                     y = 0;

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

  1291.                     

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

  1293.                         int pred;

  1294. 

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

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

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

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

  1299.                             x = 0;

  1300.                             y++;

  1301.                         }

  1302.                     }

  1303.                 }

  1304.             }

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

  1306.                 align_get_bits(&s->gb);

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

  1308.             }

  1309.         }

  1310.     }

  1311.     return 0;

  1312. }

  1313. 

  1314. static int mjpeg_decode_scan(MJpegDecodeContext *s){

  1315.     int i, mb_x, mb_y;

  1316.     const int nb_components=3;

  1317. 

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

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

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

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

  1322. 

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

  1324.                 uint8_t *ptr;

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

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

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

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

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

  1330.                 x = 0;

  1331.                 y = 0;

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

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

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

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

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

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

  1338.                         return -1;

  1339.                     }

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

  1341.                     ptr = s->current_picture[c] + 

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

  1343.                         (h * mb_x + x) * 8;

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

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

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

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

  1348.                         x = 0;

  1349.                         y++;

  1350.                     }

  1351.                 }

  1352.             }

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

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

  1355.                 !--s->restart_count) {

  1356.                 align_get_bits(&s->gb);

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

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

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

  1360.             }

  1361.         }

  1362.     }

  1363.     return 0;

  1364. }

  1365. 

  1366. static int mjpeg_decode_sos(MJpegDecodeContext *s)

  1367. {

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

  1369.     int vmax, hmax, index, id;

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

  1371. 

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

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

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

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

  1376.     {

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

  1378. 	return -1;

  1379.     }

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

  1381.     if (nb_components != 3)

  1382.     {

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

  1384.         return -1;

  1385.     }

  1386.     vmax = 0;

  1387.     hmax = 0;

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

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

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

  1391.         /* find component index */

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

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

  1394.                 break;

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

  1396. 	{

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

  1398.             return -1;

  1399. 	}

  1400. 

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

  1402. 

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

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

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

  1406. 

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

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

  1409. 

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

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

  1412. 	    goto out_of_range;

  1413. #if 0 //buggy

  1414. 	switch(s->start_code)

  1415. 	{

  1416. 	    case SOF0:

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

  1418. 		    goto out_of_range;

  1419. 		break;

  1420. 	    case SOF1:

  1421. 	    case SOF2:

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

  1423. 		    goto out_of_range;

  1424. 		break;

  1425. 	    case SOF3:

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

  1427. 		    goto out_of_range;

  1428. 		break;	

  1429. 	}

  1430. #endif

  1431.     }

  1432. 

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

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

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

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

  1437. 

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

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

  1440. 

  1441.     if (nb_components > 1) {

  1442.         /* interleaved stream */

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

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

  1445.     } else {

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

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

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

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

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

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

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

  1453.     }

  1454. 

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

  1456.         printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);

  1457.     

  1458.     if(s->lossless){

  1459.             if(s->rgb){

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

  1461.                     return -1;

  1462.             }else{

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

  1464.                     return -1;

  1465.             }

  1466.     }else{

  1467.         if(mjpeg_decode_scan(s) < 0)

  1468.             return -1;

  1469.     }

  1470.     emms_c();

  1471.     return 0;

  1472.  out_of_range:

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

  1474.     return -1;

  1475. }

  1476. 

  1477. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1478. {

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

  1480. 	return -1;

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

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

  1483. 

  1484.     return 0;

  1485. }

  1486. 

  1487. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1488. {

  1489.     int len, id;

  1490. 

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

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

  1493.     if (len < 5)

  1494. 	return -1;

  1495. 

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

  1497.     id = be2me_32(id);

  1498.     len -= 6;

  1499. 

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

  1501.         printf("APPx %8X\n", id); 

  1502.     }

  1503.     

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

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

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

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

  1508.     {

  1509. 	/* structure:

  1510. 	    4bytes	AVI1

  1511. 	    1bytes	polarity

  1512. 	    1bytes	always zero

  1513. 	    4bytes	field_size

  1514. 	    4bytes	field_size_less_padding

  1515. 	*/

  1516.     	s->buggy_avid = 1;

  1517. //	if (s->first_picture)

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

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

  1520. #if 0

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

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

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

  1524. 	len -= 10;

  1525. #endif

  1526. //	if (s->interlace_polarity)

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

  1528. 	goto out;

  1529.     }

  1530.     

  1531. //    len -= 2;

  1532.     

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

  1534.     {

  1535. 	int t_w, t_h;

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

  1537. 	printf("mjpeg: JFIF header found (version: %x.%x)\n",

  1538. 	    get_bits(&s->gb, 8), get_bits(&s->gb, 8));

  1539. 	if (get_bits(&s->gb, 8) == 0)

  1540. 	{

  1541. 	    int x_density, y_density; 

  1542. 	    x_density = get_bits(&s->gb, 16);

  1543. 	    y_density = get_bits(&s->gb, 16);

  1544. 

  1545. 	    dprintf("x/y density: %d (%f), %d (%f)\n", x_density,

  1546. 		(float)x_density, y_density, (float)y_density);

  1547. #if 0

  1548.             //MN: needs to be checked

  1549.             if(x_density)

  1550. //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);

  1551. 		s->avctx->aspect_ratio = (float)x_density/y_density;

  1552. 		/* it's better, but every JFIF I have seen stores 1:1 */

  1553.             else

  1554.                 s->avctx->aspect_ratio= 0.0;

  1555. #endif

  1556. 	}

  1557. 	else

  1558. 	{

  1559. 	    skip_bits(&s->gb, 16);

  1560. 	    skip_bits(&s->gb, 16);

  1561. 	}

  1562. 

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

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

  1565. 	if (t_w && t_h)

  1566. 	{

  1567. 	    /* skip thumbnail */

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

  1569. 		len -= t_w*t_h*3;

  1570. 	}

  1571. 	len -= 10;

  1572. 	goto out;

  1573.     }

  1574.     

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

  1576.     {

  1577. 	printf("mjpeg: Adobe header found\n");

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

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

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

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

  1582. 	len -= 7;

  1583. 	goto out;

  1584.     }

  1585. 

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

  1587.         printf("Pegasus lossless jpeg header found\n");

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

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

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

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

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

  1593.         case 1:

  1594.             s->rgb= 1;

  1595.             s->pegasus_rct=0;

  1596.             break;

  1597.         case 2:

  1598.             s->rgb= 1;

  1599.             s->pegasus_rct=1;

  1600.             break;

  1601.         default:

  1602.             printf("unknown colorspace\n");

  1603.         }

  1604.         len -= 9;

  1605.         goto out;

  1606.     }

  1607.     

  1608.     /* Apple MJPEG-A */

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

  1610.     {

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

  1612. 	id = be2me_32(id);

  1613. 	len -= 4;

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

  1615. 	{

  1616. #if 0

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

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

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

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

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

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

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

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

  1625. #endif

  1626. 	    if (s->first_picture)

  1627. 		printf("mjpeg: Apple MJPEG-A header found\n");

  1628. 	}

  1629.     }

  1630. 

  1631. out:

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

  1633.     if (len < 0)

  1634. 	printf("mjpeg: error, decode_app parser read over the end\n");

  1635.     while(--len > 0)

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

  1637. 

  1638.     return 0;

  1639. }

  1640. 

  1641. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1642. {

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

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

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

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

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

  1648. 	if (cbuf) {

  1649. 	    int i;

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

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

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

  1653. 		cbuf[i-1] = 0;

  1654. 	    else

  1655. 		cbuf[i] = 0;

  1656. 

  1657. 	    printf("mjpeg comment: '%s'\n", cbuf);

  1658. 

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

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

  1661. 	    {

  1662. 		s->buggy_avid = 1;

  1663. 		//	if (s->first_picture)

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

  1665. 	    }

  1666. 

  1667. 	    av_free(cbuf);

  1668. 	}

  1669.     }

  1670. 

  1671.     return 0;

  1672. }

  1673. 

  1674. #if 0

  1675. static int valid_marker_list[] =

  1676. {

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

  1678. /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1679. /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1680. /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1681. /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1682. /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1683. /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1684. /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1685. /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1686. /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1687. /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1688. /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1689. /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1690. /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1691. /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1692. /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1693. /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

  1694. }

  1695. #endif

  1696. 

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

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

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

  1700. {

  1701.     uint8_t *buf_ptr;

  1702.     unsigned int v, v2;

  1703.     int val;

  1704. #ifdef DEBUG

  1705.     int skipped=0;

  1706. #endif

  1707. 

  1708.     buf_ptr = *pbuf_ptr;

  1709.     while (buf_ptr < buf_end) {

  1710.         v = *buf_ptr++;

  1711. 	v2 = *buf_ptr;

  1712.         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {

  1713. 	    val = *buf_ptr++;

  1714. 	    goto found;

  1715.         }

  1716. #ifdef DEBUG

  1717. 	skipped++;

  1718. #endif

  1719.     }

  1720.     val = -1;

  1721. found:

  1722. #ifdef DEBUG

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

  1724. #endif

  1725.     *pbuf_ptr = buf_ptr;

  1726.     return val;

  1727. }

  1728. 

  1729. static int mjpeg_decode_frame(AVCodecContext *avctx, 

  1730.                               void *data, int *data_size,

  1731.                               uint8_t *buf, int buf_size)

  1732. {

  1733.     MJpegDecodeContext *s = avctx->priv_data;

  1734.     uint8_t *buf_end, *buf_ptr;

  1735.     int i, start_code;

  1736.     AVFrame *picture = data;

  1737. 

  1738.     *data_size = 0;

  1739. 

  1740.     /* no supplementary picture */

  1741.     if (buf_size == 0)

  1742.         return 0;

  1743. 

  1744.     buf_ptr = buf;

  1745.     buf_end = buf + buf_size;

  1746.     while (buf_ptr < buf_end) {

  1747.         /* find start next marker */

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

  1749. 	{

  1750. 	    /* EOF */

  1751.             if (start_code < 0) {

  1752. 		goto the_end;

  1753.             } else {

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

  1755. 		

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

  1757. 		{

  1758. 		    av_free(s->buffer);

  1759. 		    s->buffer_size = buf_end-buf_ptr;

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

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

  1762. 			s->buffer_size);

  1763. 		}

  1764. 		

  1765. 		/* unescape buffer of SOS */

  1766. 		if (start_code == SOS)

  1767. 		{

  1768. 		    uint8_t *src = buf_ptr;

  1769. 		    uint8_t *dst = s->buffer;

  1770. 

  1771. 		    while (src<buf_end)

  1772. 		    {

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

  1774. 

  1775. 			*(dst++) = x;

  1776. 			if (x == 0xff)

  1777. 			{

  1778. 			    while(*src == 0xff) src++;

  1779. 

  1780. 			    x = *(src++);

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

  1782. 				*(dst++) = x;

  1783. 			    else if (x)

  1784. 				break;

  1785. 			}

  1786. 		    }

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

  1788. 		    

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

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

  1791. 		}

  1792. 		else

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

  1794. 		

  1795. 		s->start_code = start_code;

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

  1797.                     printf("startcode: %X\n", start_code);

  1798.                 }

  1799. 

  1800. 		/* process markers */

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

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

  1803. 		} else if (s->first_picture) {

  1804. 		    /* APP fields */

  1805. 		    if (start_code >= 0xe0 && start_code <= 0xef)

  1806. 			mjpeg_decode_app(s);

  1807. 		    /* Comment */

  1808. 		    else if (start_code == COM)

  1809. 			mjpeg_decode_com(s);

  1810. 		}

  1811. 

  1812.                 switch(start_code) {

  1813.                 case SOI:

  1814. 		    s->restart_interval = 0;

  1815.                     /* nothing to do on SOI */

  1816.                     break;

  1817.                 case DQT:

  1818.                     mjpeg_decode_dqt(s);

  1819.                     break;

  1820.                 case DHT:

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

  1822.                         fprintf(stderr, "huffman table decode error\n");

  1823.                         return -1;

  1824.                     }

  1825.                     break;

  1826.                 case SOF0:

  1827.                     s->lossless=0;

  1828.                     if (mjpeg_decode_sof(s) < 0) 

  1829. 			return -1;

  1830.                     break;

  1831.                 case SOF3:

  1832.                     s->lossless=1;

  1833.                     if (mjpeg_decode_sof(s) < 0) 

  1834. 			return -1;

  1835.                     break;

  1836. 		case EOI:

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

  1838.                         break;

  1839. eoi_parser:

  1840. 		    {

  1841.                         if (s->interlaced) {

  1842.                             s->bottom_field ^= 1;

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

  1844.                             if (s->bottom_field)

  1845.                                 goto not_the_end;

  1846.                         }

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

  1848.                             picture->data[i] = s->current_picture[i];

  1849. 			    picture->linesize[i] = (s->interlaced) ?

  1850. 				s->linesize[i] >> 1 : s->linesize[i];

  1851.                         }

  1852.                         *data_size = sizeof(AVFrame);

  1853.                         avctx->height = s->height;

  1854.                         if (s->interlaced)

  1855.                             avctx->height *= 2;

  1856.                         avctx->width = s->width;

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

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

  1859.                         case 0x11:

  1860.                             if(s->rgb){

  1861.                                 avctx->pix_fmt = PIX_FMT_RGBA32;

  1862.                             }else

  1863.                                 avctx->pix_fmt = PIX_FMT_YUV444P;

  1864.                             break;

  1865.                         case 0x21:

  1866.                             avctx->pix_fmt = PIX_FMT_YUV422P;

  1867.                             break;

  1868.                         default:

  1869.                         case 0x22:

  1870.                             avctx->pix_fmt = PIX_FMT_YUV420P;

  1871.                             break;

  1872.                         }

  1873. 

  1874.                         if(!s->lossless){

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

  1876.                             picture->qstride= 0;

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

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

  1879.                             if(avctx->debug & FF_DEBUG_QP)

  1880.                                 printf("QP: %d\n", (int)picture->quality);

  1881.                         }

  1882.                         

  1883.                         goto the_end;

  1884.                     }

  1885. 		    break;

  1886.                 case SOS:

  1887.                     mjpeg_decode_sos(s);

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

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

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

  1891. 			goto eoi_parser;

  1892.                     break;

  1893. 		case DRI:

  1894. 		    mjpeg_decode_dri(s);

  1895. 		    break;

  1896. 		case SOF1:

  1897. 		case SOF2:

  1898. 		case SOF5:

  1899. 		case SOF6:

  1900. 		case SOF7:

  1901. 		case SOF9:

  1902. 		case SOF10:

  1903. 		case SOF11:

  1904. 		case SOF13:

  1905. 		case SOF14:

  1906. 		case SOF15:

  1907. 		case JPG:

  1908. 		    printf("mjpeg: unsupported coding type (%x)\n", start_code);

  1909. 		    break;

  1910. //		default:

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

  1912. //		    break;

  1913.                 }

  1914. 

  1915. not_the_end:

  1916. 		/* eof process start code */

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

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

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

  1920.             }

  1921.         }

  1922.     }

  1923. the_end:

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

  1925. //    return buf_end - buf_ptr;

  1926.     return buf_ptr - buf;

  1927. }

  1928. 

  1929. static int mjpegb_decode_frame(AVCodecContext *avctx, 

  1930.                               void *data, int *data_size,

  1931.                               uint8_t *buf, int buf_size)

  1932. {

  1933.     MJpegDecodeContext *s = avctx->priv_data;

  1934.     uint8_t *buf_end, *buf_ptr;

  1935.     int i;

  1936.     AVFrame *picture = data;

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

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

  1939.     uint32_t field_size;

  1940. 

  1941.     *data_size = 0;

  1942. 

  1943.     /* no supplementary picture */

  1944.     if (buf_size == 0)

  1945.         return 0;

  1946. 

  1947.     buf_ptr = buf;

  1948.     buf_end = buf + buf_size;

  1949.     

  1950. read_header:

  1951.     /* reset on every SOI */

  1952.     s->restart_interval = 0;

  1953. 

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

  1955. 

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

  1957.     

  1958.     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))

  1959.     {

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

  1961. 	return 0;

  1962.     }

  1963. 

  1964.     field_size = get_bits(&hgb, 32); /* field size */

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

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

  1967.     second_field_offs = get_bits(&hgb, 32);

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

  1969.     if (second_field_offs)

  1970. 	s->interlaced = 1;

  1971. 

  1972.     dqt_offs = get_bits(&hgb, 32);

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

  1974.     if (dqt_offs)

  1975.     {

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

  1977. 	s->start_code = DQT;

  1978. 	mjpeg_decode_dqt(s);

  1979.     }

  1980.     

  1981.     dht_offs = get_bits(&hgb, 32);

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

  1983.     if (dht_offs)

  1984.     {

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

  1986. 	s->start_code = DHT;

  1987. 	mjpeg_decode_dht(s);

  1988.     }

  1989. 

  1990.     sof_offs = get_bits(&hgb, 32);

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

  1992.     if (sof_offs)

  1993.     {

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

  1995. 	s->start_code = SOF0;

  1996. 	if (mjpeg_decode_sof(s) < 0)

  1997. 	    return -1;

  1998.     }

  1999. 

  2000.     sos_offs = get_bits(&hgb, 32);

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

  2002.     if (sos_offs)

  2003.     {

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

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

  2006. 	s->start_code = SOS;

  2007. 	mjpeg_decode_sos(s);

  2008.     }

  2009. 

  2010.     skip_bits(&hgb, 32); /* start of data offset */

  2011. 

  2012.     if (s->interlaced) {

  2013.         s->bottom_field ^= 1;

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

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

  2016. 	{

  2017. 	    buf_ptr = buf + second_field_offs;

  2018. 	    second_field_offs = 0;

  2019. 	    goto read_header;

  2020.     	}

  2021.     }

  2022. 

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

  2024.     

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

  2026.         picture->data[i] = s->current_picture[i];

  2027.         picture->linesize[i] = (s->interlaced) ?

  2028.     	    s->linesize[i] >> 1 : s->linesize[i];

  2029.     }

  2030.     *data_size = sizeof(AVFrame);

  2031.     avctx->height = s->height;

  2032.     if (s->interlaced)

  2033.         avctx->height *= 2;

  2034.     avctx->width = s->width;

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

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

  2037.         case 0x11:

  2038.     	    avctx->pix_fmt = PIX_FMT_YUV444P;

  2039.             break;

  2040.         case 0x21:

  2041.             avctx->pix_fmt = PIX_FMT_YUV422P;

  2042.             break;

  2043.         default:

  2044. 	case 0x22:

  2045.             avctx->pix_fmt = PIX_FMT_YUV420P;

  2046.             break;

  2047.     }

  2048.     

  2049.     if(!s->lossless){

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

  2051.         picture->qstride= 0;

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

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

  2054.         if(avctx->debug & FF_DEBUG_QP)

  2055.             printf("QP: %f\n", picture->quality);

  2056.     }

  2057. 

  2058.     return buf_ptr - buf;

  2059. }

  2060. 

  2061. 

  2062. static int mjpeg_decode_end(AVCodecContext *avctx)

  2063. {

  2064.     MJpegDecodeContext *s = avctx->priv_data;

  2065.     int i, j;

  2066. 

  2067.     av_free(s->buffer);

  2068.     av_free(s->qscale_table);

  2069.     for(i=0;i<MAX_COMPONENTS;i++)

  2070.         av_free(s->current_picture[i]);

  2071.     for(i=0;i<2;i++) {

  2072.         for(j=0;j<4;j++)

  2073.             free_vlc(&s->vlcs[i][j]);

  2074.     }

  2075.     return 0;

  2076. }

  2077. 

  2078. AVCodec mjpeg_decoder = {

  2079.     "mjpeg",

  2080.     CODEC_TYPE_VIDEO,

  2081.     CODEC_ID_MJPEG,

  2082.     sizeof(MJpegDecodeContext),

  2083.     mjpeg_decode_init,

  2084.     NULL,

  2085.     mjpeg_decode_end,

  2086.     mjpeg_decode_frame,

  2087.     0,

  2088.     NULL

  2089. };

  2090. 

  2091. AVCodec mjpegb_decoder = {

  2092.     "mjpegb",

  2093.     CODEC_TYPE_VIDEO,

  2094.     CODEC_ID_MJPEGB,

  2095.     sizeof(MJpegDecodeContext),

  2096.     mjpeg_decode_init,

  2097.     NULL,

  2098.     mjpeg_decode_end,

  2099.     mjpegb_decode_frame,

  2100.     0,

  2101.     NULL

  2102. };

  2103. 

  2104. #ifdef CONFIG_ENCODERS

  2105. AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them

  2106.     "ljpeg",

  2107.     CODEC_TYPE_VIDEO,

  2108.     CODEC_ID_LJPEG,

  2109.     sizeof(MpegEncContext),

  2110.     MPV_encode_init,

  2111.     encode_picture_lossless,

  2112.     MPV_encode_end,

  2113. };

  2114. #endif