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

1691 lines
47KB
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. //#define DEBUG

  24. #include "avcodec.h"

  25. #include "dsputil.h"

  26. #include "mpegvideo.h"

  27. 

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

  29. /* not yet working */

  30. #undef TWOMATRIXES

  31. 

  32. typedef struct MJpegContext {

  33.     UINT8 huff_size_dc_luminance[12];

  34.     UINT16 huff_code_dc_luminance[12];

  35.     UINT8 huff_size_dc_chrominance[12];

  36.     UINT16 huff_code_dc_chrominance[12];

  37. 

  38.     UINT8 huff_size_ac_luminance[256];

  39.     UINT16 huff_code_ac_luminance[256];

  40.     UINT8 huff_size_ac_chrominance[256];

  41.     UINT16 huff_code_ac_chrominance[256];

  42. } MJpegContext;

  43. 

  44. /* JPEG marker codes */

  45. typedef enum {

  46.     /* start of frame */

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

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

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

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

  51. 

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

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

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

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

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

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

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

  59. 

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

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

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

  63. 

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

  65. 

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

  67. 

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

  69.     RST0  = 0xd0,

  70.     RST1  = 0xd1,

  71.     RST2  = 0xd2,

  72.     RST3  = 0xd3,

  73.     RST4  = 0xd4,

  74.     RST5  = 0xd5,

  75.     RST6  = 0xd6,

  76.     RST7  = 0xd7,

  77. 

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

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

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

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

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

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

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

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

  86. 

  87.     APP0  = 0xe0,

  88.     APP1  = 0xe1,

  89.     APP2  = 0xe2,

  90.     APP3  = 0xe3,

  91.     APP4  = 0xe4,

  92.     APP5  = 0xe5,

  93.     APP6  = 0xe6,

  94.     APP7  = 0xe7,

  95.     APP8  = 0xe8,

  96.     APP9  = 0xe9,

  97.     APP10 = 0xea,

  98.     APP11 = 0xeb,

  99.     APP12 = 0xec,

  100.     APP13 = 0xed,

  101.     APP14 = 0xee,

  102.     APP15 = 0xef,

  103. 

  104.     JPG0  = 0xf0,

  105.     JPG1  = 0xf1,

  106.     JPG2  = 0xf2,

  107.     JPG3  = 0xf3,

  108.     JPG4  = 0xf4,

  109.     JPG5  = 0xf5,

  110.     JPG6  = 0xf6,

  111.     JPG7  = 0xf7,

  112.     JPG8  = 0xf8,

  113.     JPG9  = 0xf9,

  114.     JPG10 = 0xfa,

  115.     JPG11 = 0xfb,

  116.     JPG12 = 0xfc,

  117.     JPG13 = 0xfd,

  118. 

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

  120. 

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

  122. 

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

  124. } JPEG_MARKER;

  125. 

  126. #if 0

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

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

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

  130.  */

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

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

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

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

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

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

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

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

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

  140. };

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

  142.     17,  18,  24,  47,  99,  99,  99,  99,

  143.     18,  21,  26,  66,  99,  99,  99,  99,

  144.     24,  26,  56,  99,  99,  99,  99,  99,

  145.     47,  66,  99,  99,  99,  99,  99,  99,

  146.     99,  99,  99,  99,  99,  99,  99,  99,

  147.     99,  99,  99,  99,  99,  99,  99,  99,

  148.     99,  99,  99,  99,  99,  99,  99,  99,

  149.     99,  99,  99,  99,  99,  99,  99,  99

  150. };

  151. #endif

  152. 

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

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

  155. static const UINT8 bits_dc_luminance[17] =

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

  157. static const UINT8 val_dc_luminance[] =

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

  159. 

  160. static const UINT8 bits_dc_chrominance[17] =

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

  162. static const UINT8 val_dc_chrominance[] =

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

  164. 

  165. static const UINT8 bits_ac_luminance[17] =

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

  167. static const UINT8 val_ac_luminance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  188.   0xf9, 0xfa 

  189. };

  190. 

  191. static const UINT8 bits_ac_chrominance[17] =

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

  193. 

  194. static const UINT8 val_ac_chrominance[] =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  215.   0xf9, 0xfa 

  216. };

  217. 

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

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

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

  221. {

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

  223. 

  224.     code = 0;

  225.     k = 0;

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

  227.         nb = bits_table[i];

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

  229.             sym = val_table[k++];

  230.             huff_size[sym] = i;

  231.             huff_code[sym] = code;

  232.             code++;

  233.         }

  234.         code <<= 1;

  235.     }

  236. }

  237. 

  238. int mjpeg_init(MpegEncContext *s)

  239. {

  240.     MJpegContext *m;

  241.     

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

  243.     if (!m)

  244.         return -1;

  245.     

  246.     s->min_qcoeff=-1023;

  247.     s->max_qcoeff= 1023;

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

  249. 

  250.     /* build all the huffman tables */

  251.     build_huffman_codes(m->huff_size_dc_luminance,

  252.                         m->huff_code_dc_luminance,

  253.                         bits_dc_luminance,

  254.                         val_dc_luminance);

  255.     build_huffman_codes(m->huff_size_dc_chrominance,

  256.                         m->huff_code_dc_chrominance,

  257.                         bits_dc_chrominance,

  258.                         val_dc_chrominance);

  259.     build_huffman_codes(m->huff_size_ac_luminance,

  260.                         m->huff_code_ac_luminance,

  261.                         bits_ac_luminance,

  262.                         val_ac_luminance);

  263.     build_huffman_codes(m->huff_size_ac_chrominance,

  264.                         m->huff_code_ac_chrominance,

  265.                         bits_ac_chrominance,

  266.                         val_ac_chrominance);

  267.     

  268.     s->mjpeg_ctx = m;

  269.     return 0;

  270. }

  271. 

  272. void mjpeg_close(MpegEncContext *s)

  273. {

  274.     av_free(s->mjpeg_ctx);

  275. }

  276. 

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

  278. {

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

  280.     put_bits(p, 8, code);

  281. }

  282. 

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

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

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

  286. {

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

  288.     int n, i;

  289. 

  290.     put_bits(p, 4, table_class);

  291.     put_bits(p, 4, table_id);

  292. 

  293.     n = 0;

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

  295.         n += bits_table[i];

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

  297.     }

  298. 

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

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

  301. 

  302.     return n + 17;

  303. }

  304. 

  305. static void jpeg_table_header(MpegEncContext *s)

  306. {

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

  308.     int i, j, size;

  309.     UINT8 *ptr;

  310. 

  311.     /* quant matrixes */

  312.     put_marker(p, DQT);

  313. #ifdef TWOMATRIXES

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

  315. #else

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

  317. #endif

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

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

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

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

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

  323.     }

  324. #ifdef TWOMATRIXES

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

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

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

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

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

  330.     }

  331. #endif

  332. 

  333.     /* huffman table */

  334.     put_marker(p, DHT);

  335.     flush_put_bits(p);

  336.     ptr = pbBufPtr(p);

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

  338.     size = 2;

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

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

  341.     

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

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

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

  345.     ptr[1] = size;

  346. }

  347. 

  348. static void jpeg_put_comments(MpegEncContext *s)

  349. {

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

  351.     int size;

  352.     UINT8 *ptr;

  353. 

  354.     if (s->aspect_ratio_info)

  355.     {

  356.     /* JFIF header */

  357.     put_marker(p, APP0);

  358.     put_bits(p, 16, 16);

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

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

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

  362.     switch(s->aspect_ratio_info)

  363.     {

  364. 	case FF_ASPECT_4_3_625:

  365. 	case FF_ASPECT_4_3_525:

  366. 	    put_bits(p, 16, 4); 

  367. 	    put_bits(p, 16, 3);

  368. 	    break;

  369. 	case FF_ASPECT_16_9_625:

  370. 	case FF_ASPECT_16_9_525:

  371. 	    put_bits(p, 16, 16); 

  372. 	    put_bits(p, 16, 9);

  373. 	    break;

  374. 	case FF_ASPECT_EXTENDED:

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

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

  377. 	    break;

  378. 	case FF_ASPECT_SQUARE:

  379. 	default:

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

  381. 	    put_bits(p, 16, 1);

  382. 	    break;

  383.     }

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

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

  386.     }

  387. 

  388.     /* comment */

  389.     if(!ff_bit_exact){

  390.         put_marker(p, COM);

  391.         flush_put_bits(p);

  392.         ptr = pbBufPtr(p);

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

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

  395.         put_string(p, MJPEG_VERSION);

  396.         size = strlen(MJPEG_VERSION)+3;

  397. #undef MJPEG_VERSION

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

  399.         ptr[1] = size;

  400.     }

  401. }

  402. 

  403. void mjpeg_picture_header(MpegEncContext *s)

  404. {

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

  406. 

  407.     if (!s->mjpeg_data_only_frames)

  408.     {

  409.     jpeg_put_comments(s);    

  410. 

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

  412. 

  413.     put_marker(&s->pb, SOF0);

  414. 

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

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

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

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

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

  420.     

  421.     /* Y component */

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

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

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

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

  426.     

  427.     /* Cb component */

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

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

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

  431. #ifdef TWOMATRIXES

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

  433. #else

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

  435. #endif

  436. 

  437.     /* Cr component */

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

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

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

  441. #ifdef TWOMATRIXES

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

  443. #else

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

  445. #endif

  446.     }

  447. 

  448.     /* scan header */

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

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

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

  452.     

  453.     /* Y component */

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

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

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

  457.     

  458.     /* Cb component */

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

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

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

  462.     

  463.     /* Cr component */

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

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

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

  467. 

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

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

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

  471. }

  472. 

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

  474. {

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

  476.     int i, ff_count;

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

  478.     int align= (-(int)(buf))&3;

  479.     

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

  481.     size >>= 3;

  482.     

  483.     ff_count=0;

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

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

  486.     }

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

  488.         int acc, v;

  489. 

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

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

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

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

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

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

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

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

  498. 

  499.         acc>>=4;

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

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

  502.         ff_count+= acc&0xFF;

  503.     }

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

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

  506.     }

  507. 

  508.     if(ff_count==0) return;

  509.     

  510.     /* skip put bits */

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

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

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

  514.     flush_put_bits(&s->pb); 

  515. 

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

  517.         int v= buf[i];

  518. 

  519.         if(v==0xFF){

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

  521.             buf[i+ff_count]= 0;

  522.             ff_count--;

  523.         }

  524. 

  525.         buf[i+ff_count]= v;

  526.     }

  527. }

  528. 

  529. void mjpeg_picture_trailer(MpegEncContext *s)

  530. {

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

  532.     

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

  534.     flush_put_bits(&s->pb);

  535. 

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

  537.     

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

  539. 

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

  541. }

  542. 

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

  544. 				   UINT8 *huff_size, UINT16 *huff_code)

  545. {

  546.     int mant, nbits;

  547. 

  548.     if (val == 0) {

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

  550.     } else {

  551.         mant = val;

  552.         if (val < 0) {

  553.             val = -val;

  554.             mant--;

  555.         }

  556.         

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

  558.         nbits = 0;

  559.         while (val != 0) {

  560.             val = val >> 1;

  561.             nbits++;

  562.         }

  563.             

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

  565.         

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

  567.     }

  568. }

  569. 

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

  571. {

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

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

  574.     MJpegContext *m = s->mjpeg_ctx;

  575.     UINT8 *huff_size_ac;

  576.     UINT16 *huff_code_ac;

  577.     

  578.     /* DC coef */

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

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

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

  582.     if (n < 4) {

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

  584.         huff_size_ac = m->huff_size_ac_luminance;

  585.         huff_code_ac = m->huff_code_ac_luminance;

  586.     } else {

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

  588.         huff_size_ac = m->huff_size_ac_chrominance;

  589.         huff_code_ac = m->huff_code_ac_chrominance;

  590.     }

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

  592.     

  593.     /* AC coefs */

  594.     

  595.     run = 0;

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

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

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

  599.         val = block[j];

  600.         if (val == 0) {

  601.             run++;

  602.         } else {

  603.             while (run >= 16) {

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

  605.                 run -= 16;

  606.             }

  607.             mant = val;

  608.             if (val < 0) {

  609.                 val = -val;

  610.                 mant--;

  611.             }

  612.             

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

  614.             nbits = 0;

  615.             while (val != 0) {

  616.                 val = val >> 1;

  617.                 nbits++;

  618.             }

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

  620. 

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

  622.         

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

  624.             run = 0;

  625.         }

  626.     }

  627. 

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

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

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

  631. }

  632. 

  633. void mjpeg_encode_mb(MpegEncContext *s, 

  634.                      DCTELEM block[6][64])

  635. {

  636.     int i;

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

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

  639.     }

  640. }

  641. 

  642. /******************************************/

  643. /* decoding */

  644. 

  645. #define MAX_COMPONENTS 4

  646. 

  647. typedef struct MJpegDecodeContext {

  648.     AVCodecContext *avctx;

  649.     GetBitContext gb;

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

  651. 

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

  653.     int buffer_size;

  654.     UINT8 *buffer;

  655. 

  656.     INT16 quant_matrixes[4][64];

  657.     VLC vlcs[2][4];

  658. 

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

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

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

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

  663. 

  664.     int width, height;

  665.     int nb_components;

  666.     int component_id[MAX_COMPONENTS];

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

  668.     int v_count[MAX_COMPONENTS];

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

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

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

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

  673.     int linesize[MAX_COMPONENTS];

  674.     DCTELEM block[64] __align8;

  675.     ScanTable scantable;

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

  677. 

  678.     int restart_interval;

  679.     int restart_count;

  680. 

  681.     int buggy_avid;

  682.     int interlace_polarity;

  683. } MJpegDecodeContext;

  684. 

  685. static int mjpeg_decode_dht(MJpegDecodeContext *s);

  686. 

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

  688.                       int nb_codes)

  689. {

  690.     UINT8 huff_size[256];

  691.     UINT16 huff_code[256];

  692. 

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

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

  695.     

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

  697. }

  698. 

  699. static int mjpeg_decode_init(AVCodecContext *avctx)

  700. {

  701.     MJpegDecodeContext *s = avctx->priv_data;

  702.     MpegEncContext s2;

  703. 

  704.     s->avctx = avctx;

  705. 

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

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

  708.     s2.flags= avctx->flags;

  709.     s2.avctx= avctx;

  710. //    s2->out_format = FMT_MJPEG;

  711.     s2.width = 8;

  712.     s2.height = 8;

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

  714.        return -1;

  715.     s->scantable= s2.intra_scantable;

  716.     s->idct_put= s2.idct_put;

  717.     MPV_common_end(&s2);

  718. 

  719.     s->mpeg_enc_ctx_allocated = 0;

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

  721. 				but photojpg files could ahive bigger sizes */

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

  723.     if (!s->buffer)

  724. 	return -1;

  725.     s->start_code = -1;

  726.     s->first_picture = 1;

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

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

  729.     

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

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

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

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

  734. 

  735.     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)

  736.     {

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

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

  739. 	mjpeg_decode_dht(s);

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

  741.     }

  742. 

  743.     return 0;

  744. }

  745. 

  746. /* quantize tables */

  747. static int mjpeg_decode_dqt(MJpegDecodeContext *s)

  748. {

  749.     int len, index, i, j;

  750.     

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

  752. 

  753.     while (len >= 65) {

  754.         /* only 8 bit precision handled */

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

  756. 	{

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

  758.             return -1;

  759. 	}

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

  761.         if (index >= 4)

  762.             return -1;

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

  764.         /* read quant table */

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

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

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

  768.         }

  769.         len -= 65;

  770.     }

  771.     

  772.     return 0;

  773. }

  774. 

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

  776. static int mjpeg_decode_dht(MJpegDecodeContext *s)

  777. {

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

  779.     UINT8 bits_table[17];

  780.     UINT8 val_table[256];

  781.     

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

  783. 

  784.     while (len > 0) {

  785.         if (len < 17)

  786.             return -1;

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

  788.         if (class >= 2)

  789.             return -1;

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

  791.         if (index >= 4)

  792.             return -1;

  793.         n = 0;

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

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

  796.             n += bits_table[i];

  797.         }

  798.         len -= 17;

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

  800.             return -1;

  801. 

  802.         code_max = 0;

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

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

  805.             if (v > code_max)

  806.                 code_max = v;

  807.             val_table[i] = v;

  808.         }

  809.         len -= n;

  810. 

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

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

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

  814.                class, index, code_max + 1);

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

  816.     }

  817.     return 0;

  818. }

  819. 

  820. static int mjpeg_decode_sof0(MJpegDecodeContext *s)

  821. {

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

  823. 

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

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

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

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

  828.         return -1;

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

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

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

  832. 

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

  834.     if (nb_components <= 0 ||

  835.         nb_components > MAX_COMPONENTS)

  836.         return -1;

  837.     s->nb_components = nb_components;

  838.     s->h_max = 1;

  839.     s->v_max = 1;

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

  841.         /* component id */

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

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

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

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

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

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

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

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

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

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

  852.             return -1;

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

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

  855.     }

  856. 

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

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

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

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

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

  862.         s->width = width;

  863.         s->height = height;

  864.         /* test interlaced mode */

  865.         if (s->first_picture &&

  866.             s->org_height != 0 &&

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

  868.             s->interlaced = 1;

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

  870. 	    s->bottom_field = 0;

  871.         }

  872. 

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

  874.             int w, h;

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

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

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

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

  879.             if (s->interlaced)

  880.                 w *= 2;

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

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

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

  884. 	    {

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

  886. 		return -1;

  887. 	    }

  888.         }

  889.         s->first_picture = 0;

  890.     }

  891. 

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

  893.     {

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

  895.     }

  896.     

  897.     return 0;

  898. }

  899. 

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

  901. {

  902.     int code, diff;

  903. #if 1

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

  905. #else

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

  907. #endif

  908.     if (code < 0)

  909.     {

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

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

  912.         return 0xffff;

  913.     }

  914.     if (code == 0) {

  915.         diff = 0;

  916.     } else {

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

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

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

  920.     }

  921.     return diff;

  922. }

  923. 

  924. /* decode block and dequantize */

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

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

  927. {

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

  929.     int run, val;

  930.     VLC *ac_vlc;

  931.     INT16 *quant_matrix;

  932. 

  933.     /* DC coef */

  934.     val = mjpeg_decode_dc(s, dc_index);

  935.     if (val == 0xffff) {

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

  937.         return -1;

  938.     }

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

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

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

  942.     block[0] = val;

  943.     /* AC coefs */

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

  945.     i = 1;

  946.     for(;;) {

  947. #if 1

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

  949. #else

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

  951. #endif

  952.         if (code < 0) {

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

  954.             return -1;

  955.         }

  956.         /* EOB */

  957.         if (code == 0)

  958.             break;

  959.         if (code == 0xf0) {

  960.             i += 16;

  961.         } else {

  962.             run = code >> 4;

  963.             nbits = code & 0xf;

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

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

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

  967.             i += run;

  968.             if (i >= 64) {

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

  970.                 return -1;

  971.             }

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

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

  974.             i++;

  975.             if (i >= 64)

  976.                 break;

  977.         }

  978.     }

  979.     return 0;

  980. }

  981. 

  982. static int mjpeg_decode_sos(MJpegDecodeContext *s)

  983. {

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

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

  986.     int comp_index[4];

  987.     int dc_index[4];

  988.     int ac_index[4];

  989.     int nb_blocks[4];

  990.     int h_count[4];

  991.     int v_count[4];

  992.     

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

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

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

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

  997.     {

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

  999. 	return -1;

  1000.     }

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

  1002.     if (nb_components != 3)

  1003.     {

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

  1005.         return -1;

  1006.     }

  1007.     vmax = 0;

  1008.     hmax = 0;

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

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

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

  1012.         /* find component index */

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

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

  1015.                 break;

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

  1017. 	{

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

  1019.             return -1;

  1020. 	}

  1021. 

  1022.         comp_index[i] = index;

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

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

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

  1026. 

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

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

  1029. 

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

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

  1032. 	    goto out_of_range;

  1033. 	switch(s->start_code)

  1034. 	{

  1035. 	    case SOF0:

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

  1037. 		    goto out_of_range;

  1038. 		break;

  1039. 	    case SOF1:

  1040. 	    case SOF2:

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

  1042. 		    goto out_of_range;

  1043. 		break;

  1044. 	    case SOF3:

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

  1046. 		    goto out_of_range;

  1047. 		break;	

  1048. 	}

  1049.     }

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

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

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

  1053. 

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

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

  1056. 

  1057.     if (nb_components > 1) {

  1058.         /* interleaved stream */

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

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

  1061.     } else {

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

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

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

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

  1066.         nb_blocks[0] = 1;

  1067.         h_count[0] = 1;

  1068.         v_count[0] = 1;

  1069.     }

  1070.     

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

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

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

  1074.                 UINT8 *ptr;

  1075.                 int x, y, c;

  1076.                 n = nb_blocks[i];

  1077.                 c = comp_index[i];

  1078.                 h = h_count[i];

  1079.                 v = v_count[i];

  1080.                 x = 0;

  1081.                 y = 0;

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

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

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

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

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

  1087.                                      dc_index[i], ac_index[i], 

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

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

  1090.                         ret = -1;

  1091.                         goto the_end;

  1092.                     }

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

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

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

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

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

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

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

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

  1101.                         x = 0;

  1102.                         y++;

  1103.                     }

  1104.                 }

  1105.             }

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

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

  1108. 		!--s->restart_count) {

  1109.                 align_get_bits(&s->gb);

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

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

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

  1113.             }

  1114.         }

  1115.     }

  1116.     ret = 0;

  1117.  the_end:

  1118.     emms_c();

  1119.     return ret;

  1120.  out_of_range:

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

  1122.     return -1;

  1123. }

  1124. 

  1125. static int mjpeg_decode_dri(MJpegDecodeContext *s)

  1126. {

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

  1128. 	return -1;

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

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

  1131. 

  1132.     return 0;

  1133. }

  1134. 

  1135. static int mjpeg_decode_app(MJpegDecodeContext *s)

  1136. {

  1137.     int len, id;

  1138. 

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

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

  1141.     if (len < 5)

  1142. 	return -1;

  1143. 

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

  1145.     id = be2me_32(id);

  1146.     len -= 6;

  1147. 

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

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

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

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

  1152.     {

  1153. 	/* structure:

  1154. 	    4bytes	AVI1

  1155. 	    1bytes	polarity

  1156. 	    1bytes	always zero

  1157. 	    4bytes	field_size

  1158. 	    4bytes	field_size_less_padding

  1159. 	*/

  1160.     	s->buggy_avid = 1;

  1161. //	if (s->first_picture)

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

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

  1164. #if 0

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

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

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

  1168. 	len -= 10;

  1169. #endif

  1170. //	if (s->interlace_polarity)

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

  1172. 	goto out;

  1173.     }

  1174.     

  1175. //    len -= 2;

  1176.     

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

  1178.     {

  1179. 	int t_w, t_h;

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

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

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

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

  1184. 	{

  1185. 	    int x_density, y_density; 

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

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

  1188. 

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

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

  1191. #if 0

  1192.             //MN: needs to be checked

  1193.             if(x_density)

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

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

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

  1197.             else

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

  1199. #endif

  1200. 	}

  1201. 	else

  1202. 	{

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

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

  1205. 	}

  1206. 

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

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

  1209. 	if (t_w && t_h)

  1210. 	{

  1211. 	    /* skip thumbnail */

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

  1213. 		len -= t_w*t_h*3;

  1214. 	}

  1215. 	len -= 10;

  1216. 	goto out;

  1217.     }

  1218.     

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

  1220.     {

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

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

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

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

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

  1226. 	len -= 7;

  1227. 	goto out;

  1228.     }

  1229.     

  1230.     /* Apple MJPEG-A */

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

  1232.     {

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

  1234. 	id = be2me_32(id);

  1235. 	len -= 4;

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

  1237. 	{

  1238. #if 0

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

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

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

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

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

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

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

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

  1247. #endif

  1248. 	    if (s->first_picture)

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

  1250. 	}

  1251.     }

  1252. 

  1253. out:

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

  1255.     if (len < 0)

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

  1257.     while(--len > 0)

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

  1259. 

  1260.     return 0;

  1261. }

  1262. 

  1263. static int mjpeg_decode_com(MJpegDecodeContext *s)

  1264. {

  1265.     int len, i;

  1266.     UINT8 *cbuf;

  1267. 

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

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

  1270.     cbuf = av_malloc(len+1);

  1271. 

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

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

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

  1275. 	cbuf[i-1] = 0;

  1276.     else

  1277. 	cbuf[i] = 0;

  1278. 

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

  1280. 

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

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

  1283.     {

  1284. 	s->buggy_avid = 1;

  1285. //	if (s->first_picture)

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

  1287.     }

  1288.     

  1289.     av_free(cbuf);

  1290. 

  1291.     return 0;

  1292. }

  1293. 

  1294. #if 0

  1295. static int valid_marker_list[] =

  1296. {

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

  1298. /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1299. /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1300. /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1301. /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1302. /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1303. /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1304. /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1305. /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1306. /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1307. /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1308. /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1309. /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  1310. /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1311. /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1312. /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  1313. /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

  1314. }

  1315. #endif

  1316. 

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

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

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

  1320. {

  1321.     UINT8 *buf_ptr;

  1322.     unsigned int v, v2;

  1323.     int val;

  1324. #ifdef DEBUG

  1325.     int skipped=0;

  1326. #endif

  1327. 

  1328.     buf_ptr = *pbuf_ptr;

  1329.     while (buf_ptr < buf_end) {

  1330.         v = *buf_ptr++;

  1331. 	v2 = *buf_ptr;

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

  1333. 	    val = *buf_ptr++;

  1334. 	    goto found;

  1335.         }

  1336. #ifdef DEBUG

  1337. 	skipped++;

  1338. #endif

  1339.     }

  1340.     val = -1;

  1341. found:

  1342. #ifdef DEBUG

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

  1344. #endif

  1345.     *pbuf_ptr = buf_ptr;

  1346.     return val;

  1347. }

  1348. 

  1349. static int mjpeg_decode_frame(AVCodecContext *avctx, 

  1350.                               void *data, int *data_size,

  1351.                               UINT8 *buf, int buf_size)

  1352. {

  1353.     MJpegDecodeContext *s = avctx->priv_data;

  1354.     UINT8 *buf_end, *buf_ptr;

  1355.     int i, start_code;

  1356.     AVPicture *picture = data;

  1357. 

  1358.     *data_size = 0;

  1359. 

  1360.     /* no supplementary picture */

  1361.     if (buf_size == 0)

  1362.         return 0;

  1363. 

  1364.     buf_ptr = buf;

  1365.     buf_end = buf + buf_size;

  1366.     while (buf_ptr < buf_end) {

  1367.         /* find start next marker */

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

  1369. 	{

  1370. 	    /* EOF */

  1371.             if (start_code < 0) {

  1372. 		goto the_end;

  1373.             } else {

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

  1375. 		

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

  1377. 		{

  1378. 		    av_free(s->buffer);

  1379. 		    s->buffer_size = buf_end-buf_ptr;

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

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

  1382. 			s->buffer_size);

  1383. 		}

  1384. 		

  1385. 		/* unescape buffer of SOS */

  1386. 		if (start_code == SOS)

  1387. 		{

  1388. 		    UINT8 *src = buf_ptr;

  1389. 		    UINT8 *dst = s->buffer;

  1390. 

  1391. 		    while (src<buf_end)

  1392. 		    {

  1393. 			UINT8 x = *(src++);

  1394. 

  1395. 			*(dst++) = x;

  1396. 			if (x == 0xff)

  1397. 			{

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

  1399. 

  1400. 			    x = *(src++);

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

  1402. 				*(dst++) = x;

  1403. 			    else if (x)

  1404. 				break;

  1405. 			}

  1406. 		    }

  1407. 		    init_get_bits(&s->gb, s->buffer, dst - s->buffer);

  1408. 		    

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

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

  1411. 		}

  1412. 		else

  1413. 		    init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);

  1414. 		

  1415. 		s->start_code = start_code;

  1416. 

  1417. 		/* process markers */

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

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

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

  1421. 		    /* APP fields */

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

  1423. 			mjpeg_decode_app(s);

  1424. 		    /* Comment */

  1425. 		    else if (start_code == COM)

  1426. 			mjpeg_decode_com(s);

  1427. 		}

  1428. 

  1429.                 switch(start_code) {

  1430.                 case SOI:

  1431. 		    s->restart_interval = 0;

  1432.                     /* nothing to do on SOI */

  1433.                     break;

  1434.                 case DQT:

  1435.                     mjpeg_decode_dqt(s);

  1436.                     break;

  1437.                 case DHT:

  1438.                     mjpeg_decode_dht(s);

  1439.                     break;

  1440.                 case SOF0:

  1441.                     if (mjpeg_decode_sof0(s) < 0)

  1442. 			return -1;

  1443.                     break;

  1444. 		case EOI:

  1445. eoi_parser:

  1446. 		    {

  1447.                         if (s->interlaced) {

  1448.                             s->bottom_field ^= 1;

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

  1450.                             if (s->bottom_field)

  1451.                                 goto not_the_end;

  1452.                         }

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

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

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

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

  1457.                         }

  1458.                         *data_size = sizeof(AVPicture);

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

  1460.                         if (s->interlaced)

  1461.                             avctx->height *= 2;

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

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

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

  1465.                         case 0x11:

  1466.                             avctx->pix_fmt = PIX_FMT_YUV444P;

  1467.                             break;

  1468.                         case 0x21:

  1469.                             avctx->pix_fmt = PIX_FMT_YUV422P;

  1470.                             break;

  1471.                         default:

  1472.                         case 0x22:

  1473.                             avctx->pix_fmt = PIX_FMT_YUV420P;

  1474.                             break;

  1475.                         }

  1476.                         /* dummy quality */

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

  1478. //                    	avctx->quality = 3; 

  1479.                         goto the_end;

  1480.                     }

  1481. 		    break;

  1482.                 case SOS:

  1483.                     mjpeg_decode_sos(s);

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

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

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

  1487. 			goto eoi_parser;

  1488.                     break;

  1489. 		case DRI:

  1490. 		    mjpeg_decode_dri(s);

  1491. 		    break;

  1492. 		case SOF1:

  1493. 		case SOF2:

  1494. 		case SOF3:

  1495. 		case SOF5:

  1496. 		case SOF6:

  1497. 		case SOF7:

  1498. 		case SOF9:

  1499. 		case SOF10:

  1500. 		case SOF11:

  1501. 		case SOF13:

  1502. 		case SOF14:

  1503. 		case SOF15:

  1504. 		case JPG:

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

  1506. 		    break;

  1507. //		default:

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

  1509. //		    break;

  1510.                 }

  1511. 

  1512. not_the_end:

  1513. 		/* eof process start code */

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

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

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

  1517.             }

  1518.         }

  1519.     }

  1520. the_end:

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

  1522. //    return buf_end - buf_ptr;

  1523.     return buf_ptr - buf;

  1524. }

  1525. 

  1526. static int mjpegb_decode_frame(AVCodecContext *avctx, 

  1527.                               void *data, int *data_size,

  1528.                               UINT8 *buf, int buf_size)

  1529. {

  1530.     MJpegDecodeContext *s = avctx->priv_data;

  1531.     UINT8 *buf_end, *buf_ptr;

  1532.     int i;

  1533.     AVPicture *picture = data;

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

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

  1536.     uint32_t field_size;

  1537. 

  1538.     *data_size = 0;

  1539. 

  1540.     /* no supplementary picture */

  1541.     if (buf_size == 0)

  1542.         return 0;

  1543. 

  1544.     buf_ptr = buf;

  1545.     buf_end = buf + buf_size;

  1546.     

  1547. read_header:

  1548.     /* reset on every SOI */

  1549.     s->restart_interval = 0;

  1550. 

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

  1552. 

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

  1554.     

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

  1556.     {

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

  1558. 	return 0;

  1559.     }

  1560. 

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

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

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

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

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

  1566.     if (second_field_offs)

  1567. 	s->interlaced = 1;

  1568. 

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

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

  1571.     if (dqt_offs)

  1572.     {

  1573. 	init_get_bits(&s->gb, buf+dqt_offs, buf_end - (buf+dqt_offs));

  1574. 	s->start_code = DQT;

  1575. 	mjpeg_decode_dqt(s);

  1576.     }

  1577.     

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

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

  1580.     if (dht_offs)

  1581.     {

  1582. 	init_get_bits(&s->gb, buf+dht_offs, buf_end - (buf+dht_offs));

  1583. 	s->start_code = DHT;

  1584. 	mjpeg_decode_dht(s);

  1585.     }

  1586. 

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

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

  1589.     if (sof_offs)

  1590.     {

  1591. 	init_get_bits(&s->gb, buf+sof_offs, buf_end - (buf+sof_offs));

  1592. 	s->start_code = SOF0;

  1593. 	if (mjpeg_decode_sof0(s) < 0)

  1594. 	    return -1;

  1595.     }

  1596. 

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

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

  1599.     if (sos_offs)

  1600.     {

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

  1602. 	init_get_bits(&s->gb, buf+sos_offs, field_size);

  1603. 	s->start_code = SOS;

  1604. 	mjpeg_decode_sos(s);

  1605.     }

  1606. 

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

  1608. 

  1609.     if (s->interlaced) {

  1610.         s->bottom_field ^= 1;

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

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

  1613. 	{

  1614. 	    buf_ptr = buf + second_field_offs;

  1615. 	    second_field_offs = 0;

  1616. 	    goto read_header;

  1617.     	}

  1618.     }

  1619. 

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

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

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

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

  1624.     }

  1625.     *data_size = sizeof(AVPicture);

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

  1627.     if (s->interlaced)

  1628.         avctx->height *= 2;

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

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

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

  1632.         case 0x11:

  1633.     	    avctx->pix_fmt = PIX_FMT_YUV444P;

  1634.             break;

  1635.         case 0x21:

  1636.             avctx->pix_fmt = PIX_FMT_YUV422P;

  1637.             break;

  1638.         default:

  1639. 	case 0x22:

  1640.             avctx->pix_fmt = PIX_FMT_YUV420P;

  1641.             break;

  1642.     }

  1643.     /* dummy quality */

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

  1645. //    avctx->quality = 3; 

  1646. 

  1647.     return buf_ptr - buf;

  1648. }

  1649. 

  1650. 

  1651. static int mjpeg_decode_end(AVCodecContext *avctx)

  1652. {

  1653.     MJpegDecodeContext *s = avctx->priv_data;

  1654.     int i, j;

  1655. 

  1656.     av_free(s->buffer);

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

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

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

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

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

  1662.     }

  1663.     return 0;

  1664. }

  1665. 

  1666. AVCodec mjpeg_decoder = {

  1667.     "mjpeg",

  1668.     CODEC_TYPE_VIDEO,

  1669.     CODEC_ID_MJPEG,

  1670.     sizeof(MJpegDecodeContext),

  1671.     mjpeg_decode_init,

  1672.     NULL,

  1673.     mjpeg_decode_end,

  1674.     mjpeg_decode_frame,

  1675.     0,

  1676.     NULL

  1677. };

  1678. 

  1679. AVCodec mjpegb_decoder = {

  1680.     "mjpegb",

  1681.     CODEC_TYPE_VIDEO,

  1682.     CODEC_ID_MJPEGB,

  1683.     sizeof(MJpegDecodeContext),

  1684.     mjpeg_decode_init,

  1685.     NULL,

  1686.     mjpeg_decode_end,

  1687.     mjpegb_decode_frame,

  1688.     0,

  1689.     NULL

  1690. };