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

1453 lines
41KB
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 and new decode_frame mechanism

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

  22.  */

  23. #define DEBUG

  24. #include "avcodec.h"

  25. #include "dsputil.h"

  26. #include "mpegvideo.h"

  27. 

  28. #ifdef USE_FASTMEMCPY

  29. #include "fastmemcpy.h"

  30. #endif

  31. 

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

  33. /* not yet working */

  34. #undef TWOMATRIXES

  35. 

  36. typedef struct MJpegContext {

  37.     UINT8 huff_size_dc_luminance[12];

  38.     UINT16 huff_code_dc_luminance[12];

  39.     UINT8 huff_size_dc_chrominance[12];

  40.     UINT16 huff_code_dc_chrominance[12];

  41. 

  42.     UINT8 huff_size_ac_luminance[256];

  43.     UINT16 huff_code_ac_luminance[256];

  44.     UINT8 huff_size_ac_chrominance[256];

  45.     UINT16 huff_code_ac_chrominance[256];

  46. } MJpegContext;

  47. 

  48. /* JPEG marker codes */

  49. typedef enum {

  50.     /* start of frame */

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

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

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

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

  55. 

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

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

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

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

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

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

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

  63. 

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

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

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

  67. 

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

  69. 

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

  71. 

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

  73.     RST0  = 0xd0,

  74.     RST1  = 0xd1,

  75.     RST2  = 0xd2,

  76.     RST3  = 0xd3,

  77.     RST4  = 0xd4,

  78.     RST5  = 0xd5,

  79.     RST6  = 0xd6,

  80.     RST7  = 0xd7,

  81. 

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

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

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

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

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

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

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

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

  90. 

  91.     APP0  = 0xe0,

  92.     APP1  = 0xe1,

  93.     APP2  = 0xe2,

  94.     APP3  = 0xe3,

  95.     APP4  = 0xe4,

  96.     APP5  = 0xe5,

  97.     APP6  = 0xe6,

  98.     APP7  = 0xe7,

  99.     APP8  = 0xe8,

  100.     APP9  = 0xe9,

  101.     APP10 = 0xea,

  102.     APP11 = 0xeb,

  103.     APP12 = 0xec,

  104.     APP13 = 0xed,

  105.     APP14 = 0xee,

  106.     APP15 = 0xef,

  107. 

  108.     JPG0  = 0xf0,

  109.     JPG1  = 0xf1,

  110.     JPG2  = 0xf2,

  111.     JPG3  = 0xf3,

  112.     JPG4  = 0xf4,

  113.     JPG5  = 0xf5,

  114.     JPG6  = 0xf6,

  115.     JPG7  = 0xf7,

  116.     JPG8  = 0xf8,

  117.     JPG9  = 0xf9,

  118.     JPG10 = 0xfa,

  119.     JPG11 = 0xfb,

  120.     JPG12 = 0xfc,

  121.     JPG13 = 0xfd,

  122. 

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

  124. 

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

  126. 

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

  128. } JPEG_MARKER;

  129. 

  130. #if 0

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

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

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

  134.  */

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

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

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

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

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

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

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

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

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

  144. };

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

  146.     17,  18,  24,  47,  99,  99,  99,  99,

  147.     18,  21,  26,  66,  99,  99,  99,  99,

  148.     24,  26,  56,  99,  99,  99,  99,  99,

  149.     47,  66,  99,  99,  99,  99,  99,  99,

  150.     99,  99,  99,  99,  99,  99,  99,  99,

  151.     99,  99,  99,  99,  99,  99,  99,  99,

  152.     99,  99,  99,  99,  99,  99,  99,  99,

  153.     99,  99,  99,  99,  99,  99,  99,  99

  154. };

  155. #endif

  156. 

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

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

  159. static const UINT8 bits_dc_luminance[17] =

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

  161. static const UINT8 val_dc_luminance[] =

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

  163. 

  164. static const UINT8 bits_dc_chrominance[17] =

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

  166. static const UINT8 val_dc_chrominance[] =

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

  168. 

  169. static const UINT8 bits_ac_luminance[17] =

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

  171. static const UINT8 val_ac_luminance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  192.   0xf9, 0xfa 

  193. };

  194. 

  195. static const UINT8 bits_ac_chrominance[17] =

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

  197. 

  198. static const UINT8 val_ac_chrominance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  219.   0xf9, 0xfa 

  220. };

  221. 

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

  223. static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,

  224.                                 const UINT8 *bits_table, const UINT8 *val_table)

  225. {

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

  227. 

  228.     code = 0;

  229.     k = 0;

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

  231.         nb = bits_table[i];

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

  233.             sym = val_table[k++];

  234.             huff_size[sym] = i;

  235.             huff_code[sym] = code;

  236.             code++;

  237.         }

  238.         code <<= 1;

  239.     }

  240. }

  241. 

  242. int mjpeg_init(MpegEncContext *s)

  243. {

  244.     MJpegContext *m;

  245.     

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

  247.     if (!m)

  248.         return -1;

  249.     

  250.     s->min_qcoeff=-1023;

  251.     s->max_qcoeff= 1023;

  252.     s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x

  253. 

  254.     /* build all the huffman tables */

  255.     build_huffman_codes(m->huff_size_dc_luminance,

  256.                         m->huff_code_dc_luminance,

  257.                         bits_dc_luminance,

  258.                         val_dc_luminance);

  259.     build_huffman_codes(m->huff_size_dc_chrominance,

  260.                         m->huff_code_dc_chrominance,

  261.                         bits_dc_chrominance,

  262.                         val_dc_chrominance);

  263.     build_huffman_codes(m->huff_size_ac_luminance,

  264.                         m->huff_code_ac_luminance,

  265.                         bits_ac_luminance,

  266.                         val_ac_luminance);

  267.     build_huffman_codes(m->huff_size_ac_chrominance,

  268.                         m->huff_code_ac_chrominance,

  269.                         bits_ac_chrominance,

  270.                         val_ac_chrominance);

  271.     

  272.     s->mjpeg_ctx = m;

  273.     return 0;

  274. }

  275. 

  276. void mjpeg_close(MpegEncContext *s)

  277. {

  278.     av_free(s->mjpeg_ctx);

  279. }

  280. 

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

  282. {

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

  284.     put_bits(p, 8, code);

  285. }

  286. 

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

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

  289.                              const UINT8 *bits_table, const UINT8 *value_table)

  290. {

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

  292.     int n, i;

  293. 

  294.     put_bits(p, 4, table_class);

  295.     put_bits(p, 4, table_id);

  296. 

  297.     n = 0;

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

  299.         n += bits_table[i];

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

  301.     }

  302. 

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

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

  305. 

  306.     return n + 17;

  307. }

  308. 

  309. static void jpeg_table_header(MpegEncContext *s)

  310. {

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

  312.     int i, j, size;

  313.     UINT8 *ptr;

  314. 

  315.     /* quant matrixes */

  316.     put_marker(p, DQT);

  317. #ifdef TWOMATRIXES

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

  319. #else

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

  321. #endif

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

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

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

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

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

  327.     }

  328. #ifdef TWOMATRIXES

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

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

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

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

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

  334.     }

  335. #endif

  336. 

  337.     /* huffman table */

  338.     put_marker(p, DHT);

  339.     flush_put_bits(p);

  340.     ptr = pbBufPtr(p);

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

  342.     size = 2;

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

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

  345.     

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

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

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

  349.     ptr[1] = size;

  350. }

  351. 

  352. static void jpeg_put_comments(MpegEncContext *s)

  353. {

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

  355.     int size;

  356.     UINT8 *ptr;

  357. 

  358.     if (s->aspect_ratio_info)

  359.     {

  360.     /* JFIF header */

  361.     put_marker(p, APP0);

  362.     put_bits(p, 16, 16);

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

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

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

  366.     switch(s->aspect_ratio_info)

  367.     {

  368. 	case FF_ASPECT_4_3_625:

  369. 	case FF_ASPECT_4_3_525:

  370. 	    put_bits(p, 16, 4); 

  371. 	    put_bits(p, 16, 3);

  372. 	    break;

  373. 	case FF_ASPECT_16_9_625:

  374. 	case FF_ASPECT_16_9_525:

  375. 	    put_bits(p, 16, 16); 

  376. 	    put_bits(p, 16, 9);

  377. 	    break;

  378. 	case FF_ASPECT_EXTENDED:

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

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

  381. 	    break;

  382. 	case FF_ASPECT_SQUARE:

  383. 	default:

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

  385. 	    put_bits(p, 16, 1);

  386. 	    break;

  387.     }

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

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

  390.     }

  391. 

  392.     /* comment */

  393.     if(!ff_bit_exact){

  394.         put_marker(p, COM);

  395.         flush_put_bits(p);

  396.         ptr = pbBufPtr(p);

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

  398. #define MJPEG_VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR

  399.         put_string(p, MJPEG_VERSION);

  400.         size = strlen(MJPEG_VERSION)+3;

  401. #undef MJPEG_VERSION

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

  403.         ptr[1] = size;

  404.     }

  405. }

  406. 

  407. void mjpeg_picture_header(MpegEncContext *s)

  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, SOF0);

  418. 

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

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

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

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

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

  424.     

  425.     /* Y component */

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

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

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

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

  430.     

  431.     /* Cb component */

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

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

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

  435. #ifdef TWOMATRIXES

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

  437. #else

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

  439. #endif

  440. 

  441.     /* Cr component */

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

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

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

  445. #ifdef TWOMATRIXES

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

  447. #else

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

  449. #endif

  450.     }

  451. 

  452.     /* scan header */

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

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

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

  456.     

  457.     /* Y component */

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

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

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

  461.     

  462.     /* Cb component */

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

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

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

  466.     

  467.     /* Cr component */

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

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

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

  471. 

  472.     put_bits(&s->pb, 8, 0); /* Ss (not used) */

  473.     put_bits(&s->pb, 8, 63); /* Se (not used) */

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

  475. }

  476. 

  477. void mjpeg_picture_trailer(MpegEncContext *s)

  478. {

  479.     jflush_put_bits(&s->pb);

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

  481. }

  482. 

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

  484. 				   UINT8 *huff_size, UINT16 *huff_code)

  485. {

  486.     int mant, nbits;

  487. 

  488.     if (val == 0) {

  489.         jput_bits(&s->pb, huff_size[0], huff_code[0]);

  490.     } else {

  491.         mant = val;

  492.         if (val < 0) {

  493.             val = -val;

  494.             mant--;

  495.         }

  496.         

  497.         /* compute the log (XXX: optimize) */

  498.         nbits = 0;

  499.         while (val != 0) {

  500.             val = val >> 1;

  501.             nbits++;

  502.         }

  503.             

  504.         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);

  505.         

  506.         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));

  507.     }

  508. }

  509. 

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

  511. {

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

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

  514.     MJpegContext *m = s->mjpeg_ctx;

  515.     UINT8 *huff_size_ac;

  516.     UINT16 *huff_code_ac;

  517.     

  518.     /* DC coef */

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

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

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

  522.     if (n < 4) {

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

  524.         huff_size_ac = m->huff_size_ac_luminance;

  525.         huff_code_ac = m->huff_code_ac_luminance;

  526.     } else {

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

  528.         huff_size_ac = m->huff_size_ac_chrominance;

  529.         huff_code_ac = m->huff_code_ac_chrominance;

  530.     }

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

  532.     

  533.     /* AC coefs */

  534.     

  535.     run = 0;

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

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

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

  539.         val = block[j];

  540.         if (val == 0) {

  541.             run++;

  542.         } else {

  543.             while (run >= 16) {

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

  545.                 run -= 16;

  546.             }

  547.             mant = val;

  548.             if (val < 0) {

  549.                 val = -val;

  550.                 mant--;

  551.             }

  552.             

  553.             /* compute the log (XXX: optimize) */

  554.             nbits = 0;

  555.             while (val != 0) {

  556.                 val = val >> 1;

  557.                 nbits++;

  558.             }

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

  560. 

  561.             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);

  562.         

  563.             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));

  564.             run = 0;

  565.         }

  566.     }

  567. 

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

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

  570.         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);

  571. }

  572. 

  573. void mjpeg_encode_mb(MpegEncContext *s, 

  574.                      DCTELEM block[6][64])

  575. {

  576.     int i;

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

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

  579.     }

  580. }

  581. 

  582. /******************************************/

  583. /* decoding */

  584. 

  585. /* compressed picture size */

  586. #define PICTURE_BUFFER_SIZE 100000

  587. 

  588. #define MAX_COMPONENTS 4

  589. 

  590. typedef struct MJpegDecodeContext {

  591.     AVCodecContext *avctx;

  592.     GetBitContext gb;

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

  594. 

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

  596.     int buffer_size;

  597.     UINT8 *buffer;

  598. 

  599.     INT16 quant_matrixes[4][64];

  600.     VLC vlcs[2][4];

  601. 

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

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

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

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

  606. 

  607.     int width, height;

  608.     int nb_components;

  609.     int component_id[MAX_COMPONENTS];

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

  611.     int v_count[MAX_COMPONENTS];

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

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

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

  615.     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */

  616.     int linesize[MAX_COMPONENTS];

  617.     DCTELEM block[64] __align8;

  618. 

  619.     int buggy_avid;

  620.     int restart_interval;

  621.     int restart_count;

  622.     int interleaved_rows;

  623.     ScanTable scantable;

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

  625. } MJpegDecodeContext;

  626. 

  627. static int mjpeg_decode_dht(MJpegDecodeContext *s);

  628. 

  629. static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 

  630.                       int nb_codes)

  631. {

  632.     UINT8 huff_size[256];

  633.     UINT16 huff_code[256];

  634. 

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

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

  637.     

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

  639. }

  640. 

  641. static int mjpeg_decode_init(AVCodecContext *avctx)

  642. {

  643.     MJpegDecodeContext *s = avctx->priv_data;

  644.     MpegEncContext s2;

  645. 

  646.     s->avctx = avctx;

  647. 

  648.     /* ugly way to get the idct & scantable */

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

  650.     s2.flags= avctx->flags;

  651.     s2.avctx= avctx;

  652. //    s2->out_format = FMT_MJPEG;

  653.     s2.width = 8;

  654.     s2.height = 8;

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

  656.        return -1;

  657.     s->scantable= s2.intra_scantable;

  658.     s->idct_put= s2.idct_put;

  659.     MPV_common_end(&s2);

  660. 

  661.     s->mpeg_enc_ctx_allocated = 0;

  662.     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into

  663.                                                  account FF 00 case */

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

  665.     s->start_code = -1;

  666.     s->first_picture = 1;

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

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

  669.     

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

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

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

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

  674. 

  675.     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)

  676.     {

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

  678. 	init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);

  679. 	mjpeg_decode_dht(s);

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

  681.     }

  682. 

  683.     return 0;

  684. }

  685. 

  686. /* quantize tables */

  687. static int mjpeg_decode_dqt(MJpegDecodeContext *s)

  688. {

  689.     int len, index, i, j;

  690.     

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

  692. 

  693.     while (len >= 65) {

  694.         /* only 8 bit precision handled */

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

  696. 	{

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

  698.             return -1;

  699. 	}

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

  701.         if (index >= 4)

  702.             return -1;

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

  704.         /* read quant table */

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

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

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

  708.         }

  709.         len -= 65;

  710.     }

  711.     

  712.     return 0;

  713. }

  714. 

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

  716. static int mjpeg_decode_dht(MJpegDecodeContext *s)

  717. {

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

  719.     UINT8 bits_table[17];

  720.     UINT8 val_table[256];

  721.     

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

  723. 

  724.     while (len > 0) {

  725.         if (len < 17)

  726.             return -1;

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

  728.         if (class >= 2)

  729.             return -1;

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

  731.         if (index >= 4)

  732.             return -1;

  733.         n = 0;

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

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

  736.             n += bits_table[i];

  737.         }

  738.         len -= 17;

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

  740.             return -1;

  741. 

  742.         code_max = 0;

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

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

  745.             if (v > code_max)

  746.                 code_max = v;

  747.             val_table[i] = v;

  748.         }

  749.         len -= n;

  750. 

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

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

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

  754.                class, index, code_max + 1);

  755.         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);

  756.     }

  757.     return 0;

  758. }

  759. 

  760. static int mjpeg_decode_sof0(MJpegDecodeContext *s)

  761. {

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

  763. 

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

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

  766.     /* only 8 bits/component accepted */

  767.     if (get_bits(&s->gb, 8) != 8)

  768.         return -1;

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

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

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

  772. 

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

  774.     if (nb_components <= 0 ||

  775.         nb_components > MAX_COMPONENTS)

  776.         return -1;

  777.     s->nb_components = nb_components;

  778.     s->h_max = 1;

  779.     s->v_max = 1;

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

  781.         /* component id */

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

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

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

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

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

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

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

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

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

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

  792.             return -1;

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

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

  795.     }

  796. 

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

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

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

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

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

  802.         s->width = width;

  803.         s->height = height;

  804.         /* test interlaced mode */

  805.         if (s->first_picture &&

  806.             s->org_height != 0 &&

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

  808.             s->interlaced = 1;

  809. 	    s->bottom_field = 0;

  810.         }

  811. 

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

  813.             int w, h;

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

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

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

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

  818.             if (s->interlaced)

  819.                 w *= 2;

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

  821.             /* memory test is done in mjpeg_decode_sos() */

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

  823.         }

  824.         s->first_picture = 0;

  825.     }

  826. 

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

  828.     {

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

  830.     }

  831.     

  832.     return 0;

  833. }

  834. 

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

  836. {

  837.     int code, diff;

  838. #if 0

  839.     code = get_vlc2(&s->gb, s->vlc[0][dc_index].table,

  840. 	s->vlc[0][dc_index].bits, 1);

  841. #else

  842.     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);

  843. #endif

  844.     if (code < 0)

  845.     {

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

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

  848.         return 0xffff;

  849.     }

  850.     if (code == 0) {

  851.         diff = 0;

  852.     } else {

  853.         diff = get_bits(&s->gb, code);

  854.         if ((diff & (1 << (code - 1))) == 0) 

  855.             diff = (-1 << code) | (diff + 1);

  856.     }

  857.     return diff;

  858. }

  859. 

  860. /* decode block and dequantize */

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

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

  863. {

  864.     int nbits, code, i, j, level;

  865.     int run, val;

  866.     VLC *ac_vlc;

  867.     INT16 *quant_matrix;

  868. 

  869.     /* DC coef */

  870.     val = mjpeg_decode_dc(s, dc_index);

  871.     if (val == 0xffff) {

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

  873.         return -1;

  874.     }

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

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

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

  878.     block[0] = val;

  879.     /* AC coefs */

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

  881.     i = 1;

  882.     for(;;) {

  883. #if 0

  884. 	code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table,

  885. 	    s->vlcs[1][ac_index].bits, 2);

  886. #else

  887.         code = get_vlc(&s->gb, ac_vlc);

  888. #endif

  889.         if (code < 0) {

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

  891.             return -1;

  892.         }

  893.         /* EOB */

  894.         if (code == 0)

  895.             break;

  896.         if (code == 0xf0) {

  897.             i += 16;

  898.         } else {

  899.             run = code >> 4;

  900.             nbits = code & 0xf;

  901.             level = get_bits(&s->gb, nbits);

  902.             if ((level & (1 << (nbits - 1))) == 0) 

  903.                 level = (-1 << nbits) | (level + 1);

  904.             i += run;

  905.             if (i >= 64) {

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

  907.                 return -1;

  908.             }

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

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

  911.             i++;

  912.             if (i >= 64)

  913.                 break;

  914.         }

  915.     }

  916.     return 0;

  917. }

  918. 

  919. static int mjpeg_decode_sos(MJpegDecodeContext *s)

  920. {

  921.     int len, nb_components, i, j, n, h, v, ret;

  922.     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;

  923.     int comp_index[4];

  924.     int dc_index[4];

  925.     int ac_index[4];

  926.     int nb_blocks[4];

  927.     int h_count[4];

  928.     int v_count[4];

  929.     

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

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

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

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

  934.     {

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

  936. 	return -1;

  937.     }

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

  939.     if (nb_components != 3)

  940.     {

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

  942.         return -1;

  943.     }

  944.     vmax = 0;

  945.     hmax = 0;

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

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

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

  949.         /* find component index */

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

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

  952.                 break;

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

  954. 	{

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

  956.             return -1;

  957. 	}

  958. 

  959.         comp_index[i] = index;

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

  961.         h_count[i] = s->h_count[index];

  962.         v_count[i] = s->v_count[index];

  963. 

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

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

  966. 

  967. 	if (dc_index[i] < 0 || ac_index[i] < 0 ||

  968. 	    dc_index[i] >= 4 || ac_index[i] >= 4)

  969. 	    goto out_of_range;

  970. 	switch(s->start_code)

  971. 	{

  972. 	    case SOF0:

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

  974. 		    goto out_of_range;

  975. 		break;

  976. 	    case SOF1:

  977. 	    case SOF2:

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

  979. 		    goto out_of_range;

  980. 		break;

  981. 	    case SOF3:

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

  983. 		    goto out_of_range;

  984. 		break;	

  985. 	}

  986.     }

  987.     skip_bits(&s->gb, 8); /* Ss */

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

  989.     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */

  990. 

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

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

  993. 

  994.     if (nb_components > 1) {

  995.         /* interleaved stream */

  996.         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);

  997.         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);

  998.     } else {

  999.         h = s->h_max / s->h_count[comp_index[0]];

  1000.         v = s->v_max / s->v_count[comp_index[0]];

  1001.         mb_width = (s->width + h * 8 - 1) / (h * 8);

  1002.         mb_height = (s->height + v * 8 - 1) / (v * 8);

  1003.         nb_blocks[0] = 1;

  1004.         h_count[0] = 1;

  1005.         v_count[0] = 1;

  1006.     }

  1007. 

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

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

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

  1011.                 UINT8 *ptr;

  1012.                 int x, y, c;

  1013.                 n = nb_blocks[i];

  1014.                 c = comp_index[i];

  1015.                 h = h_count[i];

  1016.                 v = v_count[i];

  1017.                 x = 0;

  1018.                 y = 0;

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

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

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

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

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

  1024.                                      dc_index[i], ac_index[i], 

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

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

  1027.                         ret = -1;

  1028.                         goto the_end;

  1029.                     }

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

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

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

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

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

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

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

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

  1038.                         x = 0;

  1039.                         y++;

  1040.                     }

  1041.                 }

  1042.             }

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

  1044.                 align_get_bits(&s->gb);

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

  1046.                 for (j=0; j<nb_components; j++) /* reset dc */

  1047.                     s->last_dc[j] = 1024;

  1048.             }

  1049.         }

  1050.     }

  1051.     ret = 0;

  1052.  the_end:

  1053.     emms_c();

  1054.     return ret;

  1055.  out_of_range:

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

  1057.     return -1;

  1058. }

  1059. 

  1060. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1061. {

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

  1063. 	return -1;

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

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

  1066. 

  1067.     return 0;

  1068. }

  1069. 

  1070. #define FOURCC(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d)

  1071. static int mjpeg_decode_app(MJpegDecodeContext *s, int start_code)

  1072. {

  1073.     int len, id;

  1074. 

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

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

  1077.     if (len < 5)

  1078. 	return -1;

  1079. 

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

  1081.     len -= 6;

  1082. 

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

  1084.     /* also this fourcc is used by non-avid files too, it means

  1085.        interleaving, but it's always present in AVID files */

  1086.     if (id == FOURCC('A','V','I','1'))

  1087.     {

  1088. 	/* structure:

  1089. 	    4bytes	AVI1

  1090. 	    1bytes	polarity

  1091. 	    1bytes	always zero

  1092. 	    4bytes	field_size

  1093. 	    4bytes	field_size_less_padding

  1094. 	*/

  1095.     	s->buggy_avid = 1;

  1096. 	if (s->first_picture)

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

  1098. 	s->interleaved_rows = get_bits(&s->gb, 8);

  1099. #if 0

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

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

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

  1103. 	len -= 10;

  1104. #endif

  1105. 	if (s->interleaved_rows)

  1106. 	    printf("mjpeg: interleaved rows: %d\n", s->interleaved_rows);

  1107. 	goto out;

  1108.     }

  1109.     

  1110.     len -= 2;

  1111.     

  1112.     if (id == FOURCC('J','F','I','F'))

  1113.     {

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

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

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

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

  1118. 	{

  1119. 	    s->avctx->aspect_ratio_info = FF_ASPECT_EXTENDED;

  1120. 	    s->avctx->aspected_width = get_bits(&s->gb, 16);

  1121. 	    s->avctx->aspected_height = get_bits(&s->gb, 16);

  1122. 	}

  1123. 	else

  1124. 	{

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

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

  1127. 	}

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

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

  1130. 	goto out;

  1131.     }

  1132.     

  1133.     /* Apple MJPEG-A */

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

  1135.     {

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

  1137. 	len -= 4;

  1138.         if (id == FOURCC('m','j','p','g')) /* Apple MJPEG-A */

  1139. 	{

  1140. #if 0

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

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

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

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

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

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

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

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

  1149. #endif

  1150. 	    if (s->first_picture)

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

  1152. 	}

  1153.     }

  1154. 

  1155. out:

  1156.     /* should check for further values.. */

  1157. 

  1158.     return 0;

  1159. }

  1160. #undef FOURCC

  1161. 

  1162. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1163. {

  1164.     int len, i;

  1165.     UINT8 *cbuf;

  1166. 

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

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

  1169.     cbuf = av_malloc(len+1);

  1170. 

  1171.     for (i = 0; i < len; i++)

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

  1173.     if (cbuf[i-1] == '\n')

  1174. 	cbuf[i-1] = 0;

  1175.     else

  1176. 	cbuf[i] = 0;

  1177. 

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

  1179. 

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

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

  1182.     {

  1183. 	s->buggy_avid = 1;

  1184. //	if (s->first_picture)

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

  1186.     }

  1187.     

  1188.     av_free(cbuf);

  1189. 

  1190.     return 0;

  1191. }

  1192. 

  1193. #if 0

  1194. static int valid_marker_list[] =

  1195. {

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

  1197. /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1198. /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1199. /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1200. /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1201. /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1202. /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1203. /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1204. /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1205. /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1206. /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1207. /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1208. /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1209. /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1210. /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1211. /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1212. /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

  1213. }

  1214. #endif

  1215. 

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

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

  1218. static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)

  1219. {

  1220.     UINT8 *buf_ptr;

  1221.     unsigned int v, v2;

  1222.     int val;

  1223. #ifdef DEBUG

  1224.     int skipped=0;

  1225. #endif

  1226. 

  1227.     buf_ptr = *pbuf_ptr;

  1228.     while (buf_ptr < buf_end) {

  1229.         v = *buf_ptr++;

  1230. 	v2 = *buf_ptr;

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

  1232. 	    val = *buf_ptr++;

  1233. 	    goto found;

  1234.         }

  1235. #ifdef DEBUG

  1236. 	skipped++;

  1237. #endif

  1238.     }

  1239.     val = -1;

  1240. found:

  1241. #ifdef DEBUG

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

  1243. #endif

  1244.     *pbuf_ptr = buf_ptr;

  1245.     return val;

  1246. }

  1247. 

  1248. static int mjpeg_decode_frame(AVCodecContext *avctx, 

  1249.                               void *data, int *data_size,

  1250.                               UINT8 *buf, int buf_size)

  1251. {

  1252.     MJpegDecodeContext *s = avctx->priv_data;

  1253.     UINT8 *buf_end, *buf_ptr;

  1254.     int i, start_code;

  1255.     AVPicture *picture = data;

  1256. 

  1257.     *data_size = 0;

  1258. 

  1259.     /* no supplementary picture */

  1260.     if (buf_size == 0)

  1261.         return 0;

  1262. 

  1263.     buf_ptr = buf;

  1264.     buf_end = buf + buf_size;

  1265.     while (buf_ptr < buf_end) {

  1266.         /* find start next marker */

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

  1268. 	{

  1269. 	    /* EOF */

  1270.             if (start_code < 0) {

  1271. 		goto the_end;

  1272.             } else {

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

  1274. 		

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

  1276. 		{

  1277. 		    av_free(s->buffer);

  1278. 		    s->buffer_size = buf_end-buf_ptr;

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

  1280. 		}

  1281. 		

  1282. 		/* unescape buffer of SOS */

  1283. 		if (start_code == SOS)

  1284. 		{

  1285. 		    UINT8 *src = buf_ptr;

  1286. 		    UINT8 *dst = s->buffer;

  1287. 

  1288. 		    while (src<buf_end)

  1289. 		    {

  1290. 			unsigned char *x = *(src++);

  1291. 			

  1292. 			*(dst++) = x;

  1293. 			if (x == 0xff)

  1294. 			{

  1295. 			    x = *(src++);

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

  1297. 				*(dst++) = x;

  1298. 			    else if (x)

  1299. 				break;

  1300. 			}

  1301. 		    }

  1302. 		}

  1303. 		else

  1304. 		    memcpy(s->buffer, buf_ptr, buf_end - buf_ptr);

  1305. 		init_get_bits(&s->gb, s->buffer, s->buffer_size);

  1306. 		

  1307. 		s->start_code = start_code;

  1308. 

  1309. 		/* process markers */

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

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

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

  1313. 		    /* APP fields */

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

  1315. 			mjpeg_decode_app(s, start_code);

  1316. 		    /* Comment */

  1317. 		    else if (start_code == COM)

  1318. 			mjpeg_decode_com(s);

  1319. 		}

  1320. 

  1321.                 switch(start_code) {

  1322.                 case SOI:

  1323. 		    s->restart_interval = 0;

  1324.                     /* nothing to do on SOI */

  1325.                     break;

  1326.                 case DQT:

  1327.                     mjpeg_decode_dqt(s);

  1328.                     break;

  1329.                 case DHT:

  1330.                     mjpeg_decode_dht(s);

  1331.                     break;

  1332.                 case SOF0:

  1333.                     mjpeg_decode_sof0(s);

  1334.                     break;

  1335. 		case EOI:

  1336. eoi_parser:

  1337. 		    {

  1338.                         int l;

  1339.                         if (s->interlaced) {

  1340.                             s->bottom_field ^= 1;

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

  1342.                             if (s->bottom_field)

  1343.                                 goto not_the_end;

  1344.                         }

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

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

  1347. #if 1

  1348.                             l = s->linesize[i];

  1349.                             if (s->interlaced)

  1350.                                 l >>= 1;

  1351.                             picture->linesize[i] = l;

  1352. #else

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

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

  1355. #endif

  1356.                         }

  1357.                         *data_size = sizeof(AVPicture);

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

  1359.                         if (s->interlaced)

  1360.                             avctx->height *= 2;

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

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

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

  1364.                         case 0x11:

  1365.                             avctx->pix_fmt = PIX_FMT_YUV444P;

  1366.                             break;

  1367.                         case 0x21:

  1368.                             avctx->pix_fmt = PIX_FMT_YUV422P;

  1369.                             break;

  1370.                         default:

  1371.                         case 0x22:

  1372.                             avctx->pix_fmt = PIX_FMT_YUV420P;

  1373.                             break;

  1374.                         }

  1375.                         /* dummy quality */

  1376.                         /* XXX: infer it with matrix */

  1377.                     	avctx->quality = 3; 

  1378.                         goto the_end;

  1379.                     }

  1380. 		    break;

  1381.                 case SOS:

  1382.                     mjpeg_decode_sos(s);

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

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

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

  1386. 			goto eoi_parser;

  1387.                     break;

  1388. 		case DRI:

  1389. 		    mjpeg_decode_dri(s);

  1390. 		    break;

  1391. 		case SOF1:

  1392. 		case SOF2:

  1393. 		case SOF3:

  1394. 		case SOF5:

  1395. 		case SOF6:

  1396. 		case SOF7:

  1397. 		case SOF9:

  1398. 		case SOF10:

  1399. 		case SOF11:

  1400. 		case SOF13:

  1401. 		case SOF14:

  1402. 		case SOF15:

  1403. 		case JPG:

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

  1405. 		    break;

  1406. //		default:

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

  1408. //		    break;

  1409.                 }

  1410. 

  1411. not_the_end:

  1412. 		/* eof process start code */

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

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

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

  1416.             }

  1417.         }

  1418.     }

  1419. the_end:

  1420. 

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

  1422. //    return buf_end - buf_ptr;

  1423.     return buf_ptr - buf;

  1424. }

  1425. 

  1426. static int mjpeg_decode_end(AVCodecContext *avctx)

  1427. {

  1428.     MJpegDecodeContext *s = avctx->priv_data;

  1429.     int i, j;

  1430. 

  1431.     av_free(s->buffer);

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

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

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

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

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

  1437.     }

  1438.     return 0;

  1439. }

  1440. 

  1441. AVCodec mjpeg_decoder = {

  1442.     "mjpeg",

  1443.     CODEC_TYPE_VIDEO,

  1444.     CODEC_ID_MJPEG,

  1445.     sizeof(MJpegDecodeContext),

  1446.     mjpeg_decode_init,

  1447.     NULL,

  1448.     mjpeg_decode_end,

  1449.     mjpeg_decode_frame,

  1450.     0,

  1451.     NULL

  1452. };