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.

1836 lines
64KB

  1. /*
  2. * MJPEG decoder
  3. * Copyright (c) 2000, 2001 Fabrice Bellard
  4. * Copyright (c) 2003 Alex Beregszaszi
  5. * Copyright (c) 2003-2004 Michael Niedermayer
  6. *
  7. * Support for external huffman table, various fixes (AVID workaround),
  8. * aspecting, new decode_frame mechanism and apple mjpeg-b support
  9. * by Alex Beregszaszi
  10. *
  11. * This file is part of FFmpeg.
  12. *
  13. * FFmpeg is free software; you can redistribute it and/or
  14. * modify it under the terms of the GNU Lesser General Public
  15. * License as published by the Free Software Foundation; either
  16. * version 2.1 of the License, or (at your option) any later version.
  17. *
  18. * FFmpeg is distributed in the hope that it will be useful,
  19. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21. * Lesser General Public License for more details.
  22. *
  23. * You should have received a copy of the GNU Lesser General Public
  24. * License along with FFmpeg; if not, write to the Free Software
  25. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26. */
  27. /**
  28. * @file
  29. * MJPEG decoder.
  30. */
  31. // #define DEBUG
  32. #include <assert.h>
  33. #include "libavutil/imgutils.h"
  34. #include "libavutil/avassert.h"
  35. #include "libavutil/opt.h"
  36. #include "avcodec.h"
  37. #include "dsputil.h"
  38. #include "mjpeg.h"
  39. #include "mjpegdec.h"
  40. #include "jpeglsdec.h"
  41. static int build_vlc(VLC *vlc, const uint8_t *bits_table,
  42. const uint8_t *val_table, int nb_codes,
  43. int use_static, int is_ac)
  44. {
  45. uint8_t huff_size[256];
  46. uint16_t huff_code[256];
  47. uint16_t huff_sym[256];
  48. int i;
  49. assert(nb_codes <= 256);
  50. memset(huff_size, 0, sizeof(huff_size));
  51. ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
  52. for (i = 0; i < 256; i++)
  53. huff_sym[i] = i + 16 * is_ac;
  54. if (is_ac)
  55. huff_sym[0] = 16 * 256;
  56. return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
  57. huff_code, 2, 2, huff_sym, 2, 2, use_static);
  58. }
  59. static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
  60. {
  61. build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
  62. ff_mjpeg_val_dc, 12, 0, 0);
  63. build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
  64. ff_mjpeg_val_dc, 12, 0, 0);
  65. build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
  66. ff_mjpeg_val_ac_luminance, 251, 0, 1);
  67. build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
  68. ff_mjpeg_val_ac_chrominance, 251, 0, 1);
  69. build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
  70. ff_mjpeg_val_ac_luminance, 251, 0, 0);
  71. build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance,
  72. ff_mjpeg_val_ac_chrominance, 251, 0, 0);
  73. }
  74. av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
  75. {
  76. MJpegDecodeContext *s = avctx->priv_data;
  77. if (!s->picture_ptr)
  78. s->picture_ptr = &s->picture;
  79. avcodec_get_frame_defaults(&s->picture);
  80. s->avctx = avctx;
  81. ff_dsputil_init(&s->dsp, avctx);
  82. ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
  83. s->buffer_size = 0;
  84. s->buffer = NULL;
  85. s->start_code = -1;
  86. s->first_picture = 1;
  87. s->org_height = avctx->coded_height;
  88. avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
  89. build_basic_mjpeg_vlc(s);
  90. if (s->extern_huff) {
  91. av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
  92. init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
  93. if (ff_mjpeg_decode_dht(s)) {
  94. av_log(avctx, AV_LOG_ERROR,
  95. "mjpeg: error using external huffman table, switching back to internal\n");
  96. build_basic_mjpeg_vlc(s);
  97. }
  98. }
  99. if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
  100. s->interlace_polarity = 1; /* bottom field first */
  101. av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
  102. }
  103. if (avctx->codec->id == CODEC_ID_AMV)
  104. s->flipped = 1;
  105. return 0;
  106. }
  107. /* quantize tables */
  108. int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
  109. {
  110. int len, index, i, j;
  111. len = get_bits(&s->gb, 16) - 2;
  112. while (len >= 65) {
  113. /* only 8 bit precision handled */
  114. if (get_bits(&s->gb, 4) != 0) {
  115. av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
  116. return -1;
  117. }
  118. index = get_bits(&s->gb, 4);
  119. if (index >= 4)
  120. return -1;
  121. av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
  122. /* read quant table */
  123. for (i = 0; i < 64; i++) {
  124. j = s->scantable.permutated[i];
  125. s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
  126. }
  127. // XXX FIXME finetune, and perhaps add dc too
  128. s->qscale[index] = FFMAX(s->quant_matrixes[index][s->scantable.permutated[1]],
  129. s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
  130. av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
  131. index, s->qscale[index]);
  132. len -= 65;
  133. }
  134. return 0;
  135. }
  136. /* decode huffman tables and build VLC decoders */
  137. int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
  138. {
  139. int len, index, i, class, n, v, code_max;
  140. uint8_t bits_table[17];
  141. uint8_t val_table[256];
  142. len = get_bits(&s->gb, 16) - 2;
  143. while (len > 0) {
  144. if (len < 17)
  145. return -1;
  146. class = get_bits(&s->gb, 4);
  147. if (class >= 2)
  148. return -1;
  149. index = get_bits(&s->gb, 4);
  150. if (index >= 4)
  151. return -1;
  152. n = 0;
  153. for (i = 1; i <= 16; i++) {
  154. bits_table[i] = get_bits(&s->gb, 8);
  155. n += bits_table[i];
  156. }
  157. len -= 17;
  158. if (len < n || n > 256)
  159. return -1;
  160. code_max = 0;
  161. for (i = 0; i < n; i++) {
  162. v = get_bits(&s->gb, 8);
  163. if (v > code_max)
  164. code_max = v;
  165. val_table[i] = v;
  166. }
  167. len -= n;
  168. /* build VLC and flush previous vlc if present */
  169. ff_free_vlc(&s->vlcs[class][index]);
  170. av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
  171. class, index, code_max + 1);
  172. if (build_vlc(&s->vlcs[class][index], bits_table, val_table,
  173. code_max + 1, 0, class > 0) < 0)
  174. return -1;
  175. if (class > 0) {
  176. ff_free_vlc(&s->vlcs[2][index]);
  177. if (build_vlc(&s->vlcs[2][index], bits_table, val_table,
  178. code_max + 1, 0, 0) < 0)
  179. return -1;
  180. }
  181. }
  182. return 0;
  183. }
  184. int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
  185. {
  186. int len, nb_components, i, width, height, pix_fmt_id;
  187. s->cur_scan = 0;
  188. s->upscale_h = s->upscale_v = 0;
  189. /* XXX: verify len field validity */
  190. len = get_bits(&s->gb, 16);
  191. s->bits = get_bits(&s->gb, 8);
  192. if (s->pegasus_rct)
  193. s->bits = 9;
  194. if (s->bits == 9 && !s->pegasus_rct)
  195. s->rct = 1; // FIXME ugly
  196. if (s->bits != 8 && !s->lossless) {
  197. av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
  198. return -1;
  199. }
  200. if(s->lossless && s->avctx->lowres){
  201. av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
  202. return -1;
  203. }
  204. height = get_bits(&s->gb, 16);
  205. width = get_bits(&s->gb, 16);
  206. // HACK for odd_height.mov
  207. if (s->interlaced && s->width == width && s->height == height + 1)
  208. height= s->height;
  209. av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
  210. if (av_image_check_size(width, height, 0, s->avctx))
  211. return -1;
  212. nb_components = get_bits(&s->gb, 8);
  213. if (nb_components <= 0 ||
  214. nb_components > MAX_COMPONENTS)
  215. return -1;
  216. if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
  217. if (nb_components != s->nb_components) {
  218. av_log(s->avctx, AV_LOG_ERROR, "nb_components changing in interlaced picture\n");
  219. return AVERROR_INVALIDDATA;
  220. }
  221. }
  222. if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
  223. av_log(s->avctx, AV_LOG_ERROR,
  224. "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
  225. return -1;
  226. }
  227. s->nb_components = nb_components;
  228. s->h_max = 1;
  229. s->v_max = 1;
  230. for (i = 0; i < nb_components; i++) {
  231. /* component id */
  232. s->component_id[i] = get_bits(&s->gb, 8) - 1;
  233. s->h_count[i] = get_bits(&s->gb, 4);
  234. s->v_count[i] = get_bits(&s->gb, 4);
  235. /* compute hmax and vmax (only used in interleaved case) */
  236. if (s->h_count[i] > s->h_max)
  237. s->h_max = s->h_count[i];
  238. if (s->v_count[i] > s->v_max)
  239. s->v_max = s->v_count[i];
  240. s->quant_index[i] = get_bits(&s->gb, 8);
  241. if (s->quant_index[i] >= 4)
  242. return -1;
  243. av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
  244. i, s->h_count[i], s->v_count[i],
  245. s->component_id[i], s->quant_index[i]);
  246. }
  247. if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
  248. av_log(s->avctx, AV_LOG_ERROR,
  249. "Subsampling in JPEG-LS is not supported.\n");
  250. return -1;
  251. }
  252. if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && nb_components==3)
  253. s->rgb = 1;
  254. /* if different size, realloc/alloc picture */
  255. /* XXX: also check h_count and v_count */
  256. if (width != s->width || height != s->height) {
  257. av_freep(&s->qscale_table);
  258. s->width = width;
  259. s->height = height;
  260. s->interlaced = 0;
  261. /* test interlaced mode */
  262. if (s->first_picture &&
  263. s->org_height != 0 &&
  264. s->height < ((s->org_height * 3) / 4)) {
  265. s->interlaced = 1;
  266. s->bottom_field = s->interlace_polarity;
  267. s->picture_ptr->interlaced_frame = 1;
  268. s->picture_ptr->top_field_first = !s->interlace_polarity;
  269. height *= 2;
  270. }
  271. avcodec_set_dimensions(s->avctx, width, height);
  272. s->qscale_table = av_mallocz((s->width + 15) / 16);
  273. s->first_picture = 0;
  274. }
  275. if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
  276. if (s->progressive) {
  277. av_log_ask_for_sample(s->avctx, "progressively coded interlaced pictures not supported\n");
  278. return AVERROR_INVALIDDATA;
  279. }
  280. return 0;
  281. }
  282. /* XXX: not complete test ! */
  283. pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) |
  284. (s->h_count[1] << 20) | (s->v_count[1] << 16) |
  285. (s->h_count[2] << 12) | (s->v_count[2] << 8) |
  286. (s->h_count[3] << 4) | s->v_count[3];
  287. av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
  288. /* NOTE we do not allocate pictures large enough for the possible
  289. * padding of h/v_count being 4 */
  290. if (!(pix_fmt_id & 0xD0D0D0D0))
  291. pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
  292. if (!(pix_fmt_id & 0x0D0D0D0D))
  293. pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
  294. switch (pix_fmt_id) {
  295. case 0x11111100:
  296. if (s->rgb)
  297. s->avctx->pix_fmt = PIX_FMT_BGR24;
  298. else {
  299. if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
  300. s->avctx->pix_fmt = PIX_FMT_GBR24P;
  301. } else {
  302. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
  303. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  304. }
  305. }
  306. assert(s->nb_components == 3);
  307. break;
  308. case 0x12121100:
  309. case 0x22122100:
  310. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
  311. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  312. s->upscale_v = 2;
  313. s->upscale_h = (pix_fmt_id == 0x22122100);
  314. s->chroma_height = s->height;
  315. break;
  316. case 0x21211100:
  317. case 0x22211200:
  318. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
  319. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  320. s->upscale_v = (pix_fmt_id == 0x22211200);
  321. s->upscale_h = 2;
  322. s->chroma_height = s->height;
  323. break;
  324. case 0x22221100:
  325. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
  326. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  327. s->upscale_v = 2;
  328. s->upscale_h = 2;
  329. s->chroma_height = s->height / 2;
  330. break;
  331. case 0x11000000:
  332. if(s->bits <= 8)
  333. s->avctx->pix_fmt = PIX_FMT_GRAY8;
  334. else
  335. s->avctx->pix_fmt = PIX_FMT_GRAY16;
  336. break;
  337. case 0x12111100:
  338. case 0x22211100:
  339. case 0x22112100:
  340. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P;
  341. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  342. s->upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);
  343. s->chroma_height = s->height / 2;
  344. break;
  345. case 0x21111100:
  346. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
  347. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  348. break;
  349. case 0x22121100:
  350. case 0x22111200:
  351. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
  352. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  353. s->upscale_v = (pix_fmt_id == 0x22121100) + 1;
  354. break;
  355. case 0x22111100:
  356. s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
  357. s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
  358. break;
  359. default:
  360. av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
  361. return -1;
  362. }
  363. if (s->ls) {
  364. s->upscale_h = s->upscale_v = 0;
  365. if (s->nb_components > 1)
  366. s->avctx->pix_fmt = PIX_FMT_RGB24;
  367. else if (s->bits <= 8)
  368. s->avctx->pix_fmt = PIX_FMT_GRAY8;
  369. else
  370. s->avctx->pix_fmt = PIX_FMT_GRAY16;
  371. }
  372. if (s->picture_ptr->data[0])
  373. s->avctx->release_buffer(s->avctx, s->picture_ptr);
  374. if (s->avctx->get_buffer(s->avctx, s->picture_ptr) < 0) {
  375. av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  376. return -1;
  377. }
  378. s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
  379. s->picture_ptr->key_frame = 1;
  380. s->got_picture = 1;
  381. for (i = 0; i < 3; i++)
  382. s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
  383. // printf("%d %d %d %d %d %d\n",
  384. // s->width, s->height, s->linesize[0], s->linesize[1],
  385. // s->interlaced, s->avctx->height);
  386. if (len != (8 + (3 * nb_components)))
  387. av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
  388. /* totally blank picture as progressive JPEG will only add details to it */
  389. if (s->progressive) {
  390. int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
  391. int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
  392. for (i = 0; i < s->nb_components; i++) {
  393. int size = bw * bh * s->h_count[i] * s->v_count[i];
  394. av_freep(&s->blocks[i]);
  395. av_freep(&s->last_nnz[i]);
  396. s->blocks[i] = av_malloc(size * sizeof(**s->blocks));
  397. s->last_nnz[i] = av_mallocz(size * sizeof(**s->last_nnz));
  398. s->block_stride[i] = bw * s->h_count[i];
  399. }
  400. memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
  401. }
  402. return 0;
  403. }
  404. static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
  405. {
  406. int code;
  407. code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
  408. if (code < 0) {
  409. av_log(s->avctx, AV_LOG_WARNING,
  410. "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
  411. 0, dc_index, &s->vlcs[0][dc_index]);
  412. return 0xffff;
  413. }
  414. if (code)
  415. return get_xbits(&s->gb, code);
  416. else
  417. return 0;
  418. }
  419. /* decode block and dequantize */
  420. static int decode_block(MJpegDecodeContext *s, DCTELEM *block, int component,
  421. int dc_index, int ac_index, int16_t *quant_matrix)
  422. {
  423. int code, i, j, level, val;
  424. /* DC coef */
  425. val = mjpeg_decode_dc(s, dc_index);
  426. if (val == 0xffff) {
  427. av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
  428. return -1;
  429. }
  430. val = val * quant_matrix[0] + s->last_dc[component];
  431. s->last_dc[component] = val;
  432. block[0] = val;
  433. /* AC coefs */
  434. i = 0;
  435. {OPEN_READER(re, &s->gb);
  436. do {
  437. UPDATE_CACHE(re, &s->gb);
  438. GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
  439. i += ((unsigned)code) >> 4;
  440. code &= 0xf;
  441. if (code) {
  442. if (code > MIN_CACHE_BITS - 16)
  443. UPDATE_CACHE(re, &s->gb);
  444. {
  445. int cache = GET_CACHE(re, &s->gb);
  446. int sign = (~cache) >> 31;
  447. level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
  448. }
  449. LAST_SKIP_BITS(re, &s->gb, code);
  450. if (i > 63) {
  451. av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
  452. return -1;
  453. }
  454. j = s->scantable.permutated[i];
  455. block[j] = level * quant_matrix[j];
  456. }
  457. } while (i < 63);
  458. CLOSE_READER(re, &s->gb);}
  459. return 0;
  460. }
  461. static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block,
  462. int component, int dc_index,
  463. int16_t *quant_matrix, int Al)
  464. {
  465. int val;
  466. s->dsp.clear_block(block);
  467. val = mjpeg_decode_dc(s, dc_index);
  468. if (val == 0xffff) {
  469. av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
  470. return -1;
  471. }
  472. val = (val * quant_matrix[0] << Al) + s->last_dc[component];
  473. s->last_dc[component] = val;
  474. block[0] = val;
  475. return 0;
  476. }
  477. /* decode block and dequantize - progressive JPEG version */
  478. static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
  479. uint8_t *last_nnz, int ac_index,
  480. int16_t *quant_matrix,
  481. int ss, int se, int Al, int *EOBRUN)
  482. {
  483. int code, i, j, level, val, run;
  484. if (*EOBRUN) {
  485. (*EOBRUN)--;
  486. return 0;
  487. }
  488. {
  489. OPEN_READER(re, &s->gb);
  490. for (i = ss; ; i++) {
  491. UPDATE_CACHE(re, &s->gb);
  492. GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
  493. run = ((unsigned) code) >> 4;
  494. code &= 0xF;
  495. if (code) {
  496. i += run;
  497. if (code > MIN_CACHE_BITS - 16)
  498. UPDATE_CACHE(re, &s->gb);
  499. {
  500. int cache = GET_CACHE(re, &s->gb);
  501. int sign = (~cache) >> 31;
  502. level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
  503. }
  504. LAST_SKIP_BITS(re, &s->gb, code);
  505. if (i >= se) {
  506. if (i == se) {
  507. j = s->scantable.permutated[se];
  508. block[j] = level * quant_matrix[j] << Al;
  509. break;
  510. }
  511. av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
  512. return -1;
  513. }
  514. j = s->scantable.permutated[i];
  515. block[j] = level * quant_matrix[j] << Al;
  516. } else {
  517. if (run == 0xF) {// ZRL - skip 15 coefficients
  518. i += 15;
  519. if (i >= se) {
  520. av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
  521. return -1;
  522. }
  523. } else {
  524. val = (1 << run);
  525. if (run) {
  526. UPDATE_CACHE(re, &s->gb);
  527. val += NEG_USR32(GET_CACHE(re, &s->gb), run);
  528. LAST_SKIP_BITS(re, &s->gb, run);
  529. }
  530. *EOBRUN = val - 1;
  531. break;
  532. }
  533. }
  534. }
  535. CLOSE_READER(re, &s->gb);
  536. }
  537. if (i > *last_nnz)
  538. *last_nnz = i;
  539. return 0;
  540. }
  541. #define REFINE_BIT(j) { \
  542. UPDATE_CACHE(re, &s->gb); \
  543. sign = block[j] >> 15; \
  544. block[j] += SHOW_UBITS(re, &s->gb, 1) * \
  545. ((quant_matrix[j] ^ sign) - sign) << Al; \
  546. LAST_SKIP_BITS(re, &s->gb, 1); \
  547. }
  548. #define ZERO_RUN \
  549. for (; ; i++) { \
  550. if (i > last) { \
  551. i += run; \
  552. if (i > se) { \
  553. av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
  554. return -1; \
  555. } \
  556. break; \
  557. } \
  558. j = s->scantable.permutated[i]; \
  559. if (block[j]) \
  560. REFINE_BIT(j) \
  561. else if (run-- == 0) \
  562. break; \
  563. }
  564. /* decode block and dequantize - progressive JPEG refinement pass */
  565. static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block,
  566. uint8_t *last_nnz,
  567. int ac_index, int16_t *quant_matrix,
  568. int ss, int se, int Al, int *EOBRUN)
  569. {
  570. int code, i = ss, j, sign, val, run;
  571. int last = FFMIN(se, *last_nnz);
  572. OPEN_READER(re, &s->gb);
  573. if (*EOBRUN) {
  574. (*EOBRUN)--;
  575. } else {
  576. for (; ; i++) {
  577. UPDATE_CACHE(re, &s->gb);
  578. GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
  579. if (code & 0xF) {
  580. run = ((unsigned) code) >> 4;
  581. UPDATE_CACHE(re, &s->gb);
  582. val = SHOW_UBITS(re, &s->gb, 1);
  583. LAST_SKIP_BITS(re, &s->gb, 1);
  584. ZERO_RUN;
  585. j = s->scantable.permutated[i];
  586. val--;
  587. block[j] = ((quant_matrix[j]^val) - val) << Al;
  588. if (i == se) {
  589. if (i > *last_nnz)
  590. *last_nnz = i;
  591. CLOSE_READER(re, &s->gb);
  592. return 0;
  593. }
  594. } else {
  595. run = ((unsigned) code) >> 4;
  596. if (run == 0xF) {
  597. ZERO_RUN;
  598. } else {
  599. val = run;
  600. run = (1 << run);
  601. if (val) {
  602. UPDATE_CACHE(re, &s->gb);
  603. run += SHOW_UBITS(re, &s->gb, val);
  604. LAST_SKIP_BITS(re, &s->gb, val);
  605. }
  606. *EOBRUN = run - 1;
  607. break;
  608. }
  609. }
  610. }
  611. if (i > *last_nnz)
  612. *last_nnz = i;
  613. }
  614. for (; i <= last; i++) {
  615. j = s->scantable.permutated[i];
  616. if (block[j])
  617. REFINE_BIT(j)
  618. }
  619. CLOSE_READER(re, &s->gb);
  620. return 0;
  621. }
  622. #undef REFINE_BIT
  623. #undef ZERO_RUN
  624. static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
  625. {
  626. int i, mb_x, mb_y;
  627. uint16_t (*buffer)[4];
  628. int left[3], top[3], topleft[3];
  629. const int linesize = s->linesize[0];
  630. const int mask = (1 << s->bits) - 1;
  631. int resync_mb_y = 0;
  632. int resync_mb_x = 0;
  633. s->restart_count = s->restart_interval;
  634. av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
  635. (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
  636. buffer = s->ljpeg_buffer;
  637. for (i = 0; i < 3; i++)
  638. buffer[0][i] = 1 << (s->bits - 1);
  639. for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
  640. uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
  641. if (s->interlaced && s->bottom_field)
  642. ptr += linesize >> 1;
  643. for (i = 0; i < 3; i++)
  644. top[i] = left[i] = topleft[i] = buffer[0][i];
  645. for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
  646. int modified_predictor = predictor;
  647. if (s->restart_interval && !s->restart_count){
  648. s->restart_count = s->restart_interval;
  649. resync_mb_x = mb_x;
  650. resync_mb_y = mb_y;
  651. for(i=0; i<3; i++)
  652. top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
  653. }
  654. if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
  655. modified_predictor = 1;
  656. for (i=0;i<nb_components;i++) {
  657. int pred, dc;
  658. topleft[i] = top[i];
  659. top[i] = buffer[mb_x][i];
  660. PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
  661. dc = mjpeg_decode_dc(s, s->dc_index[i]);
  662. if(dc == 0xFFFF)
  663. return -1;
  664. left[i] = buffer[mb_x][i] =
  665. mask & (pred + (dc << point_transform));
  666. }
  667. if (s->restart_interval && !--s->restart_count) {
  668. align_get_bits(&s->gb);
  669. skip_bits(&s->gb, 16); /* skip RSTn */
  670. }
  671. }
  672. if (s->rct) {
  673. for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
  674. ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
  675. ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
  676. ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
  677. }
  678. } else if (s->pegasus_rct) {
  679. for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
  680. ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
  681. ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
  682. ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
  683. }
  684. } else {
  685. for(i=0; i<nb_components; i++) {
  686. int c= s->comp_index[i];
  687. for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
  688. ptr[3*mb_x+2-c] = buffer[mb_x][i];
  689. }
  690. }
  691. }
  692. }
  693. return 0;
  694. }
  695. static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
  696. int point_transform)
  697. {
  698. int i, mb_x, mb_y;
  699. const int nb_components=s->nb_components;
  700. int bits= (s->bits+7)&~7;
  701. int resync_mb_y = 0;
  702. int resync_mb_x = 0;
  703. point_transform += bits - s->bits;
  704. av_assert0(nb_components==1 || nb_components==3);
  705. for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
  706. for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
  707. if (s->restart_interval && !s->restart_count){
  708. s->restart_count = s->restart_interval;
  709. resync_mb_x = mb_x;
  710. resync_mb_y = mb_y;
  711. }
  712. if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
  713. int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
  714. int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
  715. for (i = 0; i < nb_components; i++) {
  716. uint8_t *ptr;
  717. uint16_t *ptr16;
  718. int n, h, v, x, y, c, j, linesize;
  719. n = s->nb_blocks[i];
  720. c = s->comp_index[i];
  721. h = s->h_scount[i];
  722. v = s->v_scount[i];
  723. x = 0;
  724. y = 0;
  725. linesize= s->linesize[c];
  726. if(bits>8) linesize /= 2;
  727. for(j=0; j<n; j++) {
  728. int pred, dc;
  729. dc = mjpeg_decode_dc(s, s->dc_index[i]);
  730. if(dc == 0xFFFF)
  731. return -1;
  732. if(bits<=8){
  733. ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
  734. if(y==0 && toprow){
  735. if(x==0 && leftcol){
  736. pred= 1 << (bits - 1);
  737. }else{
  738. pred= ptr[-1];
  739. }
  740. }else{
  741. if(x==0 && leftcol){
  742. pred= ptr[-linesize];
  743. }else{
  744. PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
  745. }
  746. }
  747. if (s->interlaced && s->bottom_field)
  748. ptr += linesize >> 1;
  749. pred &= (-1)<<(8-s->bits);
  750. *ptr= pred + (dc << point_transform);
  751. }else{
  752. ptr16 = s->picture.data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x); //FIXME optimize this crap
  753. if(y==0 && toprow){
  754. if(x==0 && leftcol){
  755. pred= 1 << (bits - 1);
  756. }else{
  757. pred= ptr16[-1];
  758. }
  759. }else{
  760. if(x==0 && leftcol){
  761. pred= ptr16[-linesize];
  762. }else{
  763. PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
  764. }
  765. }
  766. if (s->interlaced && s->bottom_field)
  767. ptr16 += linesize >> 1;
  768. pred &= (-1)<<(16-s->bits);
  769. *ptr16= pred + (dc << point_transform);
  770. }
  771. if (++x == h) {
  772. x = 0;
  773. y++;
  774. }
  775. }
  776. }
  777. } else {
  778. for (i = 0; i < nb_components; i++) {
  779. uint8_t *ptr;
  780. uint16_t *ptr16;
  781. int n, h, v, x, y, c, j, linesize, dc;
  782. n = s->nb_blocks[i];
  783. c = s->comp_index[i];
  784. h = s->h_scount[i];
  785. v = s->v_scount[i];
  786. x = 0;
  787. y = 0;
  788. linesize = s->linesize[c];
  789. if(bits>8) linesize /= 2;
  790. for (j = 0; j < n; j++) {
  791. int pred;
  792. dc = mjpeg_decode_dc(s, s->dc_index[i]);
  793. if(dc == 0xFFFF)
  794. return -1;
  795. if(bits<=8){
  796. ptr = s->picture.data[c] +
  797. (linesize * (v * mb_y + y)) +
  798. (h * mb_x + x); //FIXME optimize this crap
  799. PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
  800. pred &= (-1)<<(8-s->bits);
  801. *ptr = pred + (dc << point_transform);
  802. }else{
  803. ptr16 = s->picture.data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x); //FIXME optimize this crap
  804. PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
  805. pred &= (-1)<<(16-s->bits);
  806. *ptr16= pred + (dc << point_transform);
  807. }
  808. if (++x == h) {
  809. x = 0;
  810. y++;
  811. }
  812. }
  813. }
  814. }
  815. if (s->restart_interval && !--s->restart_count) {
  816. align_get_bits(&s->gb);
  817. skip_bits(&s->gb, 16); /* skip RSTn */
  818. }
  819. }
  820. }
  821. return 0;
  822. }
  823. static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src,
  824. int linesize, int lowres)
  825. {
  826. switch (lowres) {
  827. case 0: copy_block8(dst, src, linesize, linesize, 8);
  828. break;
  829. case 1: copy_block4(dst, src, linesize, linesize, 4);
  830. break;
  831. case 2: copy_block2(dst, src, linesize, linesize, 2);
  832. break;
  833. case 3: *dst = *src;
  834. break;
  835. }
  836. }
  837. static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
  838. int Al, const uint8_t *mb_bitmask,
  839. const AVFrame *reference)
  840. {
  841. int i, mb_x, mb_y;
  842. uint8_t *data[MAX_COMPONENTS];
  843. const uint8_t *reference_data[MAX_COMPONENTS];
  844. int linesize[MAX_COMPONENTS];
  845. GetBitContext mb_bitmask_gb;
  846. if (mb_bitmask)
  847. init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
  848. if (s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
  849. av_log(s->avctx, AV_LOG_ERROR,
  850. "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
  851. s->flipped = 0;
  852. }
  853. for (i = 0; i < nb_components; i++) {
  854. int c = s->comp_index[i];
  855. data[c] = s->picture_ptr->data[c];
  856. reference_data[c] = reference ? reference->data[c] : NULL;
  857. linesize[c] = s->linesize[c];
  858. s->coefs_finished[c] |= 1;
  859. if (s->flipped) {
  860. // picture should be flipped upside-down for this codec
  861. int offset = (linesize[c] * (s->v_scount[i] *
  862. (8 * s->mb_height - ((s->height / s->v_max) & 7)) - 1));
  863. data[c] += offset;
  864. reference_data[c] += offset;
  865. linesize[c] *= -1;
  866. }
  867. }
  868. for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
  869. for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
  870. const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
  871. if (s->restart_interval && !s->restart_count)
  872. s->restart_count = s->restart_interval;
  873. if (get_bits_left(&s->gb) < 0) {
  874. av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
  875. -get_bits_left(&s->gb));
  876. return -1;
  877. }
  878. for (i = 0; i < nb_components; i++) {
  879. uint8_t *ptr;
  880. int n, h, v, x, y, c, j;
  881. int block_offset;
  882. n = s->nb_blocks[i];
  883. c = s->comp_index[i];
  884. h = s->h_scount[i];
  885. v = s->v_scount[i];
  886. x = 0;
  887. y = 0;
  888. for (j = 0; j < n; j++) {
  889. block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
  890. (h * mb_x + x) * 8) >> s->avctx->lowres);
  891. if (s->interlaced && s->bottom_field)
  892. block_offset += linesize[c] >> 1;
  893. ptr = data[c] + block_offset;
  894. if (!s->progressive) {
  895. if (copy_mb)
  896. mjpeg_copy_block(ptr, reference_data[c] + block_offset,
  897. linesize[c], s->avctx->lowres);
  898. else {
  899. s->dsp.clear_block(s->block);
  900. if (decode_block(s, s->block, i,
  901. s->dc_index[i], s->ac_index[i],
  902. s->quant_matrixes[s->quant_index[c]]) < 0) {
  903. av_log(s->avctx, AV_LOG_ERROR,
  904. "error y=%d x=%d\n", mb_y, mb_x);
  905. return -1;
  906. }
  907. s->dsp.idct_put(ptr, linesize[c], s->block);
  908. }
  909. } else {
  910. int block_idx = s->block_stride[c] * (v * mb_y + y) +
  911. (h * mb_x + x);
  912. DCTELEM *block = s->blocks[c][block_idx];
  913. if (Ah)
  914. block[0] += get_bits1(&s->gb) *
  915. s->quant_matrixes[s->quant_index[c]][0] << Al;
  916. else if (decode_dc_progressive(s, block, i, s->dc_index[i],
  917. s->quant_matrixes[s->quant_index[c]],
  918. Al) < 0) {
  919. av_log(s->avctx, AV_LOG_ERROR,
  920. "error y=%d x=%d\n", mb_y, mb_x);
  921. return -1;
  922. }
  923. }
  924. // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n",
  925. // mb_y, mb_x);
  926. // av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n",
  927. // mb_x, mb_y, x, y, c, s->bottom_field,
  928. // (v * mb_y + y) * 8, (h * mb_x + x) * 8);
  929. if (++x == h) {
  930. x = 0;
  931. y++;
  932. }
  933. }
  934. }
  935. if (s->restart_interval) {
  936. s->restart_count--;
  937. if(s->restart_count == 0 && s->avctx->codec_id == CODEC_ID_THP){
  938. align_get_bits(&s->gb);
  939. for (i = 0; i < nb_components; i++) /* reset dc */
  940. s->last_dc[i] = 1024;
  941. }
  942. i = 8 + ((-get_bits_count(&s->gb)) & 7);
  943. /* skip RSTn */
  944. if (show_bits(&s->gb, i) == (1 << i) - 1) {
  945. int pos = get_bits_count(&s->gb);
  946. align_get_bits(&s->gb);
  947. while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
  948. skip_bits(&s->gb, 8);
  949. if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
  950. for (i = 0; i < nb_components; i++) /* reset dc */
  951. s->last_dc[i] = 1024;
  952. } else
  953. skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
  954. }
  955. }
  956. }
  957. }
  958. return 0;
  959. }
  960. static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
  961. int se, int Ah, int Al)
  962. {
  963. int mb_x, mb_y;
  964. int EOBRUN = 0;
  965. int c = s->comp_index[0];
  966. uint8_t *data = s->picture.data[c];
  967. int linesize = s->linesize[c];
  968. int last_scan = 0;
  969. int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]];
  970. if (!Al) {
  971. s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);
  972. last_scan = !~s->coefs_finished[c];
  973. }
  974. if (s->interlaced && s->bottom_field)
  975. data += linesize >> 1;
  976. for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
  977. uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
  978. int block_idx = mb_y * s->block_stride[c];
  979. DCTELEM (*block)[64] = &s->blocks[c][block_idx];
  980. uint8_t *last_nnz = &s->last_nnz[c][block_idx];
  981. for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
  982. int ret;
  983. if (Ah)
  984. ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
  985. quant_matrix, ss, se, Al, &EOBRUN);
  986. else
  987. ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
  988. quant_matrix, ss, se, Al, &EOBRUN);
  989. if (ret < 0) {
  990. av_log(s->avctx, AV_LOG_ERROR,
  991. "error y=%d x=%d\n", mb_y, mb_x);
  992. return -1;
  993. }
  994. if (last_scan) {
  995. s->dsp.idct_put(ptr, linesize, *block);
  996. ptr += 8 >> s->avctx->lowres;
  997. }
  998. }
  999. }
  1000. return 0;
  1001. }
  1002. int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
  1003. const AVFrame *reference)
  1004. {
  1005. int len, nb_components, i, h, v, predictor, point_transform;
  1006. int index, id;
  1007. const int block_size = s->lossless ? 1 : 8;
  1008. int ilv, prev_shift;
  1009. /* XXX: verify len field validity */
  1010. len = get_bits(&s->gb, 16);
  1011. nb_components = get_bits(&s->gb, 8);
  1012. if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
  1013. av_log(s->avctx, AV_LOG_ERROR,
  1014. "decode_sos: nb_components (%d) unsupported\n", nb_components);
  1015. return -1;
  1016. }
  1017. if (len != 6 + 2 * nb_components) {
  1018. av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
  1019. return -1;
  1020. }
  1021. for (i = 0; i < nb_components; i++) {
  1022. id = get_bits(&s->gb, 8) - 1;
  1023. av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
  1024. /* find component index */
  1025. for (index = 0; index < s->nb_components; index++)
  1026. if (id == s->component_id[index])
  1027. break;
  1028. if (index == s->nb_components) {
  1029. av_log(s->avctx, AV_LOG_ERROR,
  1030. "decode_sos: index(%d) out of components\n", index);
  1031. return -1;
  1032. }
  1033. /* Metasoft MJPEG codec has Cb and Cr swapped */
  1034. if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
  1035. && nb_components == 3 && s->nb_components == 3 && i)
  1036. index = 3 - i;
  1037. if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == PIX_FMT_GBR24P)
  1038. index = (i+2)%3;
  1039. if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == PIX_FMT_GBR24P)
  1040. index = (index+2)%3;
  1041. s->comp_index[i] = index;
  1042. s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
  1043. s->h_scount[i] = s->h_count[index];
  1044. s->v_scount[i] = s->v_count[index];
  1045. s->dc_index[i] = get_bits(&s->gb, 4);
  1046. s->ac_index[i] = get_bits(&s->gb, 4);
  1047. if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
  1048. s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
  1049. goto out_of_range;
  1050. if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table))
  1051. goto out_of_range;
  1052. }
  1053. predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
  1054. ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
  1055. if(s->avctx->codec_tag != AV_RL32("CJPG")){
  1056. prev_shift = get_bits(&s->gb, 4); /* Ah */
  1057. point_transform = get_bits(&s->gb, 4); /* Al */
  1058. }else
  1059. prev_shift = point_transform = 0;
  1060. for (i = 0; i < nb_components; i++)
  1061. s->last_dc[i] = 1024;
  1062. if (nb_components > 1) {
  1063. /* interleaved stream */
  1064. s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
  1065. s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
  1066. } else if (!s->ls) { /* skip this for JPEG-LS */
  1067. h = s->h_max / s->h_scount[0];
  1068. v = s->v_max / s->v_scount[0];
  1069. s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
  1070. s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
  1071. s->nb_blocks[0] = 1;
  1072. s->h_scount[0] = 1;
  1073. s->v_scount[0] = 1;
  1074. }
  1075. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1076. av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
  1077. s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
  1078. predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
  1079. s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
  1080. /* mjpeg-b can have padding bytes between sos and image data, skip them */
  1081. for (i = s->mjpb_skiptosod; i > 0; i--)
  1082. skip_bits(&s->gb, 8);
  1083. if (s->lossless) {
  1084. av_assert0(s->picture_ptr == &s->picture);
  1085. if (CONFIG_JPEGLS_DECODER && s->ls) {
  1086. // for () {
  1087. // reset_ls_coding_parameters(s, 0);
  1088. if (ff_jpegls_decode_picture(s, predictor, point_transform, ilv) < 0)
  1089. return -1;
  1090. } else {
  1091. if (s->rgb) {
  1092. if (ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform) < 0)
  1093. return -1;
  1094. } else {
  1095. if (ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
  1096. return -1;
  1097. }
  1098. }
  1099. } else {
  1100. if (s->progressive && predictor) {
  1101. av_assert0(s->picture_ptr == &s->picture);
  1102. if (mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift,
  1103. point_transform) < 0)
  1104. return -1;
  1105. } else {
  1106. if (mjpeg_decode_scan(s, nb_components, prev_shift, point_transform,
  1107. mb_bitmask, reference) < 0)
  1108. return -1;
  1109. }
  1110. }
  1111. emms_c();
  1112. return 0;
  1113. out_of_range:
  1114. av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
  1115. return -1;
  1116. }
  1117. static int mjpeg_decode_dri(MJpegDecodeContext *s)
  1118. {
  1119. if (get_bits(&s->gb, 16) != 4)
  1120. return -1;
  1121. s->restart_interval = get_bits(&s->gb, 16);
  1122. s->restart_count = 0;
  1123. av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
  1124. s->restart_interval);
  1125. return 0;
  1126. }
  1127. static int mjpeg_decode_app(MJpegDecodeContext *s)
  1128. {
  1129. int len, id, i;
  1130. len = get_bits(&s->gb, 16);
  1131. if (len < 5)
  1132. return -1;
  1133. if (8 * len > get_bits_left(&s->gb))
  1134. return -1;
  1135. id = get_bits_long(&s->gb, 32);
  1136. id = av_be2ne32(id);
  1137. len -= 6;
  1138. if (s->avctx->debug & FF_DEBUG_STARTCODE)
  1139. av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
  1140. /* Buggy AVID, it puts EOI only at every 10th frame. */
  1141. /* Also, this fourcc is used by non-avid files too, it holds some
  1142. information, but it's always present in AVID-created files. */
  1143. if (id == AV_RL32("AVI1")) {
  1144. /* structure:
  1145. 4bytes AVI1
  1146. 1bytes polarity
  1147. 1bytes always zero
  1148. 4bytes field_size
  1149. 4bytes field_size_less_padding
  1150. */
  1151. s->buggy_avid = 1;
  1152. // if (s->first_picture)
  1153. // printf("mjpeg: workarounding buggy AVID\n");
  1154. i = get_bits(&s->gb, 8); len--;
  1155. av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
  1156. #if 0
  1157. skip_bits(&s->gb, 8);
  1158. skip_bits(&s->gb, 32);
  1159. skip_bits(&s->gb, 32);
  1160. len -= 10;
  1161. #endif
  1162. // if (s->interlace_polarity)
  1163. // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
  1164. goto out;
  1165. }
  1166. // len -= 2;
  1167. if (id == AV_RL32("JFIF")) {
  1168. int t_w, t_h, v1, v2;
  1169. skip_bits(&s->gb, 8); /* the trailing zero-byte */
  1170. v1 = get_bits(&s->gb, 8);
  1171. v2 = get_bits(&s->gb, 8);
  1172. skip_bits(&s->gb, 8);
  1173. s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
  1174. s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
  1175. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1176. av_log(s->avctx, AV_LOG_INFO,
  1177. "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
  1178. v1, v2,
  1179. s->avctx->sample_aspect_ratio.num,
  1180. s->avctx->sample_aspect_ratio.den);
  1181. t_w = get_bits(&s->gb, 8);
  1182. t_h = get_bits(&s->gb, 8);
  1183. if (t_w && t_h) {
  1184. /* skip thumbnail */
  1185. if (len -10 - (t_w * t_h * 3) > 0)
  1186. len -= t_w * t_h * 3;
  1187. }
  1188. len -= 10;
  1189. goto out;
  1190. }
  1191. if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e')) {
  1192. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1193. av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
  1194. skip_bits(&s->gb, 16); /* version */
  1195. skip_bits(&s->gb, 16); /* flags0 */
  1196. skip_bits(&s->gb, 16); /* flags1 */
  1197. skip_bits(&s->gb, 8); /* transform */
  1198. len -= 7;
  1199. goto out;
  1200. }
  1201. if (id == AV_RL32("LJIF")) {
  1202. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1203. av_log(s->avctx, AV_LOG_INFO,
  1204. "Pegasus lossless jpeg header found\n");
  1205. skip_bits(&s->gb, 16); /* version ? */
  1206. skip_bits(&s->gb, 16); /* unknwon always 0? */
  1207. skip_bits(&s->gb, 16); /* unknwon always 0? */
  1208. skip_bits(&s->gb, 16); /* unknwon always 0? */
  1209. switch (get_bits(&s->gb, 8)) {
  1210. case 1:
  1211. s->rgb = 1;
  1212. s->pegasus_rct = 0;
  1213. break;
  1214. case 2:
  1215. s->rgb = 1;
  1216. s->pegasus_rct = 1;
  1217. break;
  1218. default:
  1219. av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
  1220. }
  1221. len -= 9;
  1222. goto out;
  1223. }
  1224. /* Apple MJPEG-A */
  1225. if ((s->start_code == APP1) && (len > (0x28 - 8))) {
  1226. id = get_bits_long(&s->gb, 32);
  1227. id = av_be2ne32(id);
  1228. len -= 4;
  1229. /* Apple MJPEG-A */
  1230. if (id == AV_RL32("mjpg")) {
  1231. #if 0
  1232. skip_bits(&s->gb, 32); /* field size */
  1233. skip_bits(&s->gb, 32); /* pad field size */
  1234. skip_bits(&s->gb, 32); /* next off */
  1235. skip_bits(&s->gb, 32); /* quant off */
  1236. skip_bits(&s->gb, 32); /* huff off */
  1237. skip_bits(&s->gb, 32); /* image off */
  1238. skip_bits(&s->gb, 32); /* scan off */
  1239. skip_bits(&s->gb, 32); /* data off */
  1240. #endif
  1241. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1242. av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
  1243. }
  1244. }
  1245. out:
  1246. /* slow but needed for extreme adobe jpegs */
  1247. if (len < 0)
  1248. av_log(s->avctx, AV_LOG_ERROR,
  1249. "mjpeg: error, decode_app parser read over the end\n");
  1250. while (--len > 0)
  1251. skip_bits(&s->gb, 8);
  1252. return 0;
  1253. }
  1254. static int mjpeg_decode_com(MJpegDecodeContext *s)
  1255. {
  1256. int len = get_bits(&s->gb, 16);
  1257. if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
  1258. char *cbuf = av_malloc(len - 1);
  1259. if (cbuf) {
  1260. int i;
  1261. for (i = 0; i < len - 2; i++)
  1262. cbuf[i] = get_bits(&s->gb, 8);
  1263. if (i > 0 && cbuf[i - 1] == '\n')
  1264. cbuf[i - 1] = 0;
  1265. else
  1266. cbuf[i] = 0;
  1267. if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  1268. av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
  1269. /* buggy avid, it puts EOI only at every 10th frame */
  1270. if (!strcmp(cbuf, "AVID")) {
  1271. s->buggy_avid = 1;
  1272. // if (s->first_picture)
  1273. // printf("mjpeg: workarounding buggy AVID\n");
  1274. } else if (!strcmp(cbuf, "CS=ITU601"))
  1275. s->cs_itu601 = 1;
  1276. else if ((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) ||
  1277. (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
  1278. s->flipped = 1;
  1279. av_free(cbuf);
  1280. }
  1281. }
  1282. return 0;
  1283. }
  1284. /* return the 8 bit start code value and update the search
  1285. state. Return -1 if no start code found */
  1286. static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
  1287. {
  1288. const uint8_t *buf_ptr;
  1289. unsigned int v, v2;
  1290. int val;
  1291. int skipped = 0;
  1292. buf_ptr = *pbuf_ptr;
  1293. while (buf_ptr < buf_end) {
  1294. v = *buf_ptr++;
  1295. v2 = *buf_ptr;
  1296. if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
  1297. val = *buf_ptr++;
  1298. goto found;
  1299. }
  1300. skipped++;
  1301. }
  1302. val = -1;
  1303. found:
  1304. av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
  1305. *pbuf_ptr = buf_ptr;
  1306. return val;
  1307. }
  1308. int ff_mjpeg_find_marker(MJpegDecodeContext *s,
  1309. const uint8_t **buf_ptr, const uint8_t *buf_end,
  1310. const uint8_t **unescaped_buf_ptr,
  1311. int *unescaped_buf_size)
  1312. {
  1313. int start_code;
  1314. start_code = find_marker(buf_ptr, buf_end);
  1315. av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
  1316. if (!s->buffer)
  1317. return AVERROR(ENOMEM);
  1318. /* unescape buffer of SOS, use special treatment for JPEG-LS */
  1319. if (start_code == SOS && !s->ls) {
  1320. const uint8_t *src = *buf_ptr;
  1321. uint8_t *dst = s->buffer;
  1322. while (src < buf_end) {
  1323. uint8_t x = *(src++);
  1324. *(dst++) = x;
  1325. if (s->avctx->codec_id != CODEC_ID_THP) {
  1326. if (x == 0xff) {
  1327. while (src < buf_end && x == 0xff)
  1328. x = *(src++);
  1329. if (x >= 0xd0 && x <= 0xd7)
  1330. *(dst++) = x;
  1331. else if (x)
  1332. break;
  1333. }
  1334. }
  1335. }
  1336. *unescaped_buf_ptr = s->buffer;
  1337. *unescaped_buf_size = dst - s->buffer;
  1338. av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
  1339. (buf_end - *buf_ptr) - (dst - s->buffer));
  1340. } else if (start_code == SOS && s->ls) {
  1341. const uint8_t *src = *buf_ptr;
  1342. uint8_t *dst = s->buffer;
  1343. int bit_count = 0;
  1344. int t = 0, b = 0;
  1345. PutBitContext pb;
  1346. s->cur_scan++;
  1347. /* find marker */
  1348. while (src + t < buf_end) {
  1349. uint8_t x = src[t++];
  1350. if (x == 0xff) {
  1351. while ((src + t < buf_end) && x == 0xff)
  1352. x = src[t++];
  1353. if (x & 0x80) {
  1354. t -= 2;
  1355. break;
  1356. }
  1357. }
  1358. }
  1359. bit_count = t * 8;
  1360. init_put_bits(&pb, dst, t);
  1361. /* unescape bitstream */
  1362. while (b < t) {
  1363. uint8_t x = src[b++];
  1364. put_bits(&pb, 8, x);
  1365. if (x == 0xFF) {
  1366. x = src[b++];
  1367. put_bits(&pb, 7, x);
  1368. bit_count--;
  1369. }
  1370. }
  1371. flush_put_bits(&pb);
  1372. *unescaped_buf_ptr = dst;
  1373. *unescaped_buf_size = (bit_count + 7) >> 3;
  1374. } else {
  1375. *unescaped_buf_ptr = *buf_ptr;
  1376. *unescaped_buf_size = buf_end - *buf_ptr;
  1377. }
  1378. return start_code;
  1379. }
  1380. int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
  1381. AVPacket *avpkt)
  1382. {
  1383. const uint8_t *buf = avpkt->data;
  1384. int buf_size = avpkt->size;
  1385. MJpegDecodeContext *s = avctx->priv_data;
  1386. const uint8_t *buf_end, *buf_ptr;
  1387. const uint8_t *unescaped_buf_ptr;
  1388. int unescaped_buf_size;
  1389. int start_code;
  1390. int i, index;
  1391. AVFrame *picture = data;
  1392. s->got_picture = 0; // picture from previous image can not be reused
  1393. buf_ptr = buf;
  1394. buf_end = buf + buf_size;
  1395. while (buf_ptr < buf_end) {
  1396. /* find start next marker */
  1397. start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
  1398. &unescaped_buf_ptr,
  1399. &unescaped_buf_size);
  1400. /* EOF */
  1401. if (start_code < 0) {
  1402. goto the_end;
  1403. } else if (unescaped_buf_size > (1U<<29)) {
  1404. av_log(avctx, AV_LOG_ERROR, "MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",
  1405. start_code, unescaped_buf_size, buf_size);
  1406. return AVERROR_INVALIDDATA;
  1407. } else {
  1408. av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
  1409. start_code, buf_end - buf_ptr);
  1410. init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size * 8);
  1411. s->start_code = start_code;
  1412. if (s->avctx->debug & FF_DEBUG_STARTCODE)
  1413. av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
  1414. /* process markers */
  1415. if (start_code >= 0xd0 && start_code <= 0xd7)
  1416. av_log(avctx, AV_LOG_DEBUG,
  1417. "restart marker: %d\n", start_code & 0x0f);
  1418. /* APP fields */
  1419. else if (start_code >= APP0 && start_code <= APP15)
  1420. mjpeg_decode_app(s);
  1421. /* Comment */
  1422. else if (start_code == COM)
  1423. mjpeg_decode_com(s);
  1424. switch (start_code) {
  1425. case SOI:
  1426. s->restart_interval = 0;
  1427. s->restart_count = 0;
  1428. /* nothing to do on SOI */
  1429. break;
  1430. case DQT:
  1431. ff_mjpeg_decode_dqt(s);
  1432. break;
  1433. case DHT:
  1434. if (ff_mjpeg_decode_dht(s) < 0) {
  1435. av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
  1436. return -1;
  1437. }
  1438. break;
  1439. case SOF0:
  1440. case SOF1:
  1441. s->lossless = 0;
  1442. s->ls = 0;
  1443. s->progressive = 0;
  1444. if (ff_mjpeg_decode_sof(s) < 0)
  1445. return -1;
  1446. break;
  1447. case SOF2:
  1448. s->lossless = 0;
  1449. s->ls = 0;
  1450. s->progressive = 1;
  1451. if (ff_mjpeg_decode_sof(s) < 0)
  1452. return -1;
  1453. break;
  1454. case SOF3:
  1455. s->lossless = 1;
  1456. s->ls = 0;
  1457. s->progressive = 0;
  1458. if (ff_mjpeg_decode_sof(s) < 0)
  1459. return -1;
  1460. break;
  1461. case SOF48:
  1462. s->lossless = 1;
  1463. s->ls = 1;
  1464. s->progressive = 0;
  1465. if (ff_mjpeg_decode_sof(s) < 0)
  1466. return -1;
  1467. break;
  1468. case LSE:
  1469. if (!CONFIG_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0)
  1470. return -1;
  1471. break;
  1472. case EOI:
  1473. eoi_parser:
  1474. s->cur_scan = 0;
  1475. if (!s->got_picture) {
  1476. av_log(avctx, AV_LOG_WARNING,
  1477. "Found EOI before any SOF, ignoring\n");
  1478. break;
  1479. }
  1480. if (s->interlaced) {
  1481. s->bottom_field ^= 1;
  1482. /* if not bottom field, do not output image yet */
  1483. if (s->bottom_field == !s->interlace_polarity)
  1484. break;
  1485. }
  1486. *picture = *s->picture_ptr;
  1487. *data_size = sizeof(AVFrame);
  1488. if (!s->lossless) {
  1489. picture->quality = FFMAX3(s->qscale[0],
  1490. s->qscale[1],
  1491. s->qscale[2]);
  1492. picture->qstride = 0;
  1493. picture->qscale_table = s->qscale_table;
  1494. memset(picture->qscale_table, picture->quality,
  1495. (s->width + 15) / 16);
  1496. if (avctx->debug & FF_DEBUG_QP)
  1497. av_log(avctx, AV_LOG_DEBUG,
  1498. "QP: %d\n", picture->quality);
  1499. picture->quality *= FF_QP2LAMBDA;
  1500. }
  1501. goto the_end;
  1502. case SOS:
  1503. if (!s->got_picture) {
  1504. av_log(avctx, AV_LOG_WARNING,
  1505. "Can not process SOS before SOF, skipping\n");
  1506. break;
  1507. }
  1508. if (ff_mjpeg_decode_sos(s, NULL, NULL) < 0 &&
  1509. (avctx->err_recognition & AV_EF_EXPLODE))
  1510. return AVERROR_INVALIDDATA;
  1511. break;
  1512. case DRI:
  1513. mjpeg_decode_dri(s);
  1514. break;
  1515. case SOF5:
  1516. case SOF6:
  1517. case SOF7:
  1518. case SOF9:
  1519. case SOF10:
  1520. case SOF11:
  1521. case SOF13:
  1522. case SOF14:
  1523. case SOF15:
  1524. case JPG:
  1525. av_log(avctx, AV_LOG_ERROR,
  1526. "mjpeg: unsupported coding type (%x)\n", start_code);
  1527. break;
  1528. // default:
  1529. // printf("mjpeg: unsupported marker (%x)\n", start_code);
  1530. // break;
  1531. }
  1532. /* eof process start code */
  1533. buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
  1534. av_log(avctx, AV_LOG_DEBUG,
  1535. "marker parser used %d bytes (%d bits)\n",
  1536. (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
  1537. }
  1538. }
  1539. if (s->got_picture) {
  1540. av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
  1541. goto eoi_parser;
  1542. }
  1543. av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
  1544. return -1;
  1545. the_end:
  1546. if (s->upscale_h) {
  1547. uint8_t *line = s->picture_ptr->data[s->upscale_h];
  1548. av_assert0(avctx->pix_fmt == PIX_FMT_YUVJ444P ||
  1549. avctx->pix_fmt == PIX_FMT_YUV444P ||
  1550. avctx->pix_fmt == PIX_FMT_YUVJ440P ||
  1551. avctx->pix_fmt == PIX_FMT_YUV440P);
  1552. for (i = 0; i < s->chroma_height; i++) {
  1553. for (index = s->width - 1; index; index--)
  1554. line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
  1555. line += s->linesize[s->upscale_h];
  1556. }
  1557. }
  1558. if (s->upscale_v) {
  1559. uint8_t *dst = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(s->height - 1) * s->linesize[s->upscale_v]];
  1560. av_assert0(avctx->pix_fmt == PIX_FMT_YUVJ444P ||
  1561. avctx->pix_fmt == PIX_FMT_YUV444P ||
  1562. avctx->pix_fmt == PIX_FMT_YUVJ422P ||
  1563. avctx->pix_fmt == PIX_FMT_YUV422P);
  1564. for (i = s->height - 1; i; i--) {
  1565. uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[i / 2 * s->linesize[s->upscale_v]];
  1566. uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(i + 1) / 2 * s->linesize[s->upscale_v]];
  1567. if (src1 == src2) {
  1568. memcpy(dst, src1, s->width);
  1569. } else {
  1570. for (index = 0; index < s->width; index++)
  1571. dst[index] = (src1[index] + src2[index]) >> 1;
  1572. }
  1573. dst -= s->linesize[s->upscale_v];
  1574. }
  1575. }
  1576. av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n",
  1577. buf_end - buf_ptr);
  1578. // return buf_end - buf_ptr;
  1579. return buf_ptr - buf;
  1580. }
  1581. av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
  1582. {
  1583. MJpegDecodeContext *s = avctx->priv_data;
  1584. int i, j;
  1585. if (s->picture_ptr && s->picture_ptr->data[0])
  1586. avctx->release_buffer(avctx, s->picture_ptr);
  1587. av_free(s->buffer);
  1588. av_free(s->qscale_table);
  1589. av_freep(&s->ljpeg_buffer);
  1590. s->ljpeg_buffer_size = 0;
  1591. for (i = 0; i < 3; i++) {
  1592. for (j = 0; j < 4; j++)
  1593. ff_free_vlc(&s->vlcs[i][j]);
  1594. }
  1595. for (i = 0; i < MAX_COMPONENTS; i++) {
  1596. av_freep(&s->blocks[i]);
  1597. av_freep(&s->last_nnz[i]);
  1598. }
  1599. return 0;
  1600. }
  1601. #define OFFSET(x) offsetof(MJpegDecodeContext, x)
  1602. #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
  1603. static const AVOption options[] = {
  1604. { "extern_huff", "Use external huffman table.",
  1605. OFFSET(extern_huff), AV_OPT_TYPE_INT, { 0 }, 0, 1, VD },
  1606. { NULL },
  1607. };
  1608. static const AVClass mjpegdec_class = {
  1609. .class_name = "MJPEG decoder",
  1610. .item_name = av_default_item_name,
  1611. .option = options,
  1612. .version = LIBAVUTIL_VERSION_INT,
  1613. };
  1614. AVCodec ff_mjpeg_decoder = {
  1615. .name = "mjpeg",
  1616. .type = AVMEDIA_TYPE_VIDEO,
  1617. .id = CODEC_ID_MJPEG,
  1618. .priv_data_size = sizeof(MJpegDecodeContext),
  1619. .init = ff_mjpeg_decode_init,
  1620. .close = ff_mjpeg_decode_end,
  1621. .decode = ff_mjpeg_decode_frame,
  1622. .capabilities = CODEC_CAP_DR1,
  1623. .max_lowres = 3,
  1624. .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
  1625. .priv_class = &mjpegdec_class,
  1626. };
  1627. AVCodec ff_thp_decoder = {
  1628. .name = "thp",
  1629. .type = AVMEDIA_TYPE_VIDEO,
  1630. .id = CODEC_ID_THP,
  1631. .priv_data_size = sizeof(MJpegDecodeContext),
  1632. .init = ff_mjpeg_decode_init,
  1633. .close = ff_mjpeg_decode_end,
  1634. .decode = ff_mjpeg_decode_frame,
  1635. .capabilities = CODEC_CAP_DR1,
  1636. .max_lowres = 3,
  1637. .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
  1638. };