LCOV - code coverage report
Current view: top level - libavcodec - mjpegenc_common.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 289 336 86.0 %
Date: 2017-12-15 11:05:35 Functions: 12 12 100.0 %

          Line data    Source code
       1             : /*
       2             :  * lossless JPEG shared bits
       3             :  * Copyright (c) 2000, 2001 Fabrice Bellard
       4             :  * Copyright (c) 2003 Alex Beregszaszi
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : #include <stdint.h>
      24             : #include <string.h>
      25             : 
      26             : #include "libavutil/common.h"
      27             : #include "libavutil/pixdesc.h"
      28             : #include "libavutil/pixfmt.h"
      29             : 
      30             : #include "avcodec.h"
      31             : #include "idctdsp.h"
      32             : #include "jpegtables.h"
      33             : #include "put_bits.h"
      34             : #include "mjpegenc.h"
      35             : #include "mjpegenc_common.h"
      36             : #include "mjpegenc_huffman.h"
      37             : #include "mjpeg.h"
      38             : 
      39        2536 : av_cold void ff_init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
      40             : {
      41             :     int i;
      42             : 
      43      327144 :     for (i = 0; i < 128; i++) {
      44      324608 :         int level = i - 64;
      45             :         int run;
      46      324608 :         if (!level)
      47        2536 :             continue;
      48    20934680 :         for (run = 0; run < 64; run++) {
      49             :             int len, code, nbits;
      50    20612608 :             int alevel = FFABS(level);
      51             : 
      52    20612608 :             len = (run >> 4) * huff_size_ac[0xf0];
      53             : 
      54    20612608 :             nbits= av_log2_16bit(alevel) + 1;
      55    20612608 :             code = ((15&run) << 4) | nbits;
      56             : 
      57    20612608 :             len += huff_size_ac[code] + nbits;
      58             : 
      59    20612608 :             uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
      60             :             // We ignore EOB as its just a constant which does not change generally
      61             :         }
      62             :     }
      63        2536 : }
      64             : 
      65             : /* table_class: 0 = DC coef, 1 = AC coefs */
      66        5752 : static int put_huffman_table(PutBitContext *p, int table_class, int table_id,
      67             :                              const uint8_t *bits_table, const uint8_t *value_table)
      68             : {
      69             :     int n, i;
      70             : 
      71        5752 :     put_bits(p, 4, table_class);
      72        5752 :     put_bits(p, 4, table_id);
      73             : 
      74        5752 :     n = 0;
      75       97784 :     for(i=1;i<=16;i++) {
      76       92032 :         n += bits_table[i];
      77       92032 :         put_bits(p, 8, bits_table[i]);
      78             :     }
      79             : 
      80      184935 :     for(i=0;i<n;i++)
      81      179183 :         put_bits(p, 8, value_table[i]);
      82             : 
      83        5752 :     return n + 17;
      84             : }
      85             : 
      86        1438 : static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
      87             :                               ScanTable *intra_scantable,
      88             :                               uint16_t luma_intra_matrix[64],
      89             :                               uint16_t chroma_intra_matrix[64],
      90             :                               int hsample[3])
      91             : {
      92             :     int i, j, size;
      93             :     uint8_t *ptr;
      94        1438 :     MpegEncContext *s = NULL;
      95             : 
      96             :     /* Since avctx->priv_data will point to LJpegEncContext in this case */
      97        1438 :     if (avctx->codec_id != AV_CODEC_ID_LJPEG)
      98        1238 :         s = avctx->priv_data;
      99             : 
     100        1438 :     if (avctx->codec_id != AV_CODEC_ID_LJPEG) {
     101        1238 :         int matrix_count = 1 + !!memcmp(luma_intra_matrix,
     102             :                                         chroma_intra_matrix,
     103             :                                         sizeof(luma_intra_matrix[0]) * 64);
     104        1238 :     if (s && s->force_duplicated_matrix)
     105           0 :         matrix_count = 2;
     106             :     /* quant matrixes */
     107        1238 :     put_marker(p, DQT);
     108        1238 :     put_bits(p, 16, 2 + matrix_count * (1 + 64));
     109        1238 :     put_bits(p, 4, 0); /* 8 bit precision */
     110        1238 :     put_bits(p, 4, 0); /* table 0 */
     111       80470 :     for(i=0;i<64;i++) {
     112       79232 :         j = intra_scantable->permutated[i];
     113       79232 :         put_bits(p, 8, luma_intra_matrix[j]);
     114             :     }
     115             : 
     116        1238 :         if (matrix_count > 1) {
     117           0 :             put_bits(p, 4, 0); /* 8 bit precision */
     118           0 :             put_bits(p, 4, 1); /* table 1 */
     119           0 :             for(i=0;i<64;i++) {
     120           0 :                 j = intra_scantable->permutated[i];
     121           0 :                 put_bits(p, 8, chroma_intra_matrix[j]);
     122             :             }
     123             :         }
     124             :     }
     125             : 
     126        1438 :     if(avctx->active_thread_type & FF_THREAD_SLICE){
     127           0 :         put_marker(p, DRI);
     128           0 :         put_bits(p, 16, 4);
     129           0 :         put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1);
     130             :     }
     131             : 
     132             :     /* huffman table */
     133        1438 :     put_marker(p, DHT);
     134        1438 :     flush_put_bits(p);
     135        1438 :     ptr = put_bits_ptr(p);
     136        1438 :     put_bits(p, 16, 0); /* patched later */
     137        1438 :     size = 2;
     138             : 
     139             :     // Only MJPEG can have a variable Huffman variable. All other
     140             :     // formats use the default Huffman table.
     141        1438 :     if (s && s->huffman == HUFFMAN_TABLE_OPTIMAL) {
     142        1238 :         size += put_huffman_table(p, 0, 0, s->mjpeg_ctx->bits_dc_luminance,
     143        1238 :                                   s->mjpeg_ctx->val_dc_luminance);
     144        1238 :         size += put_huffman_table(p, 0, 1, s->mjpeg_ctx->bits_dc_chrominance,
     145        1238 :                                   s->mjpeg_ctx->val_dc_chrominance);
     146             : 
     147        1238 :         size += put_huffman_table(p, 1, 0, s->mjpeg_ctx->bits_ac_luminance,
     148        1238 :                                   s->mjpeg_ctx->val_ac_luminance);
     149        1238 :         size += put_huffman_table(p, 1, 1, s->mjpeg_ctx->bits_ac_chrominance,
     150        2476 :                                   s->mjpeg_ctx->val_ac_chrominance);
     151             :     } else {
     152         200 :         size += put_huffman_table(p, 0, 0, avpriv_mjpeg_bits_dc_luminance,
     153             :                                   avpriv_mjpeg_val_dc);
     154         200 :         size += put_huffman_table(p, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
     155             :                                   avpriv_mjpeg_val_dc);
     156             : 
     157         200 :         size += put_huffman_table(p, 1, 0, avpriv_mjpeg_bits_ac_luminance,
     158             :                                   avpriv_mjpeg_val_ac_luminance);
     159         200 :         size += put_huffman_table(p, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
     160             :                                   avpriv_mjpeg_val_ac_chrominance);
     161             :     }
     162        1438 :     AV_WB16(ptr, size);
     163        1438 : }
     164             : 
     165        1438 : static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p)
     166             : {
     167             :     int size;
     168             :     uint8_t *ptr;
     169             : 
     170        1438 :     if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
     171           0 :         AVRational sar = avctx->sample_aspect_ratio;
     172             : 
     173           0 :         if (sar.num > 65535 || sar.den > 65535) {
     174           0 :             if (!av_reduce(&sar.num, &sar.den, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 65535))
     175           0 :                 av_log(avctx, AV_LOG_WARNING,
     176             :                     "Cannot store exact aspect ratio %d:%d\n",
     177             :                     avctx->sample_aspect_ratio.num,
     178             :                     avctx->sample_aspect_ratio.den);
     179             :         }
     180             : 
     181             :         /* JFIF header */
     182           0 :         put_marker(p, APP0);
     183           0 :         put_bits(p, 16, 16);
     184           0 :         avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
     185             :         /* The most significant byte is used for major revisions, the least
     186             :          * significant byte for minor revisions. Version 1.02 is the current
     187             :          * released revision. */
     188           0 :         put_bits(p, 16, 0x0102);
     189           0 :         put_bits(p,  8, 0);              /* units type: 0 - aspect ratio */
     190           0 :         put_bits(p, 16, sar.num);
     191           0 :         put_bits(p, 16, sar.den);
     192           0 :         put_bits(p, 8, 0); /* thumbnail width */
     193           0 :         put_bits(p, 8, 0); /* thumbnail height */
     194             :     }
     195             : 
     196             :     /* comment */
     197        1438 :     if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT)) {
     198           0 :         put_marker(p, COM);
     199           0 :         flush_put_bits(p);
     200           0 :         ptr = put_bits_ptr(p);
     201           0 :         put_bits(p, 16, 0); /* patched later */
     202           0 :         avpriv_put_string(p, LIBAVCODEC_IDENT, 1);
     203           0 :         size = strlen(LIBAVCODEC_IDENT)+3;
     204           0 :         AV_WB16(ptr, size);
     205             :     }
     206             : 
     207        2676 :     if (((avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
     208        2476 :           avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
     209        1438 :           avctx->pix_fmt == AV_PIX_FMT_YUV444P) && avctx->color_range != AVCOL_RANGE_JPEG)
     210        1238 :         || avctx->color_range == AVCOL_RANGE_MPEG) {
     211         200 :         put_marker(p, COM);
     212         200 :         flush_put_bits(p);
     213         200 :         ptr = put_bits_ptr(p);
     214         200 :         put_bits(p, 16, 0); /* patched later */
     215         200 :         avpriv_put_string(p, "CS=ITU601", 1);
     216         200 :         size = strlen("CS=ITU601")+3;
     217         200 :         AV_WB16(ptr, size);
     218             :     }
     219        1438 : }
     220             : 
     221        1642 : void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[4], int vsample[4])
     222             : {
     223             :     int chroma_h_shift, chroma_v_shift;
     224             : 
     225        1642 :     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
     226             :                                      &chroma_v_shift);
     227        1846 :     if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
     228         204 :         (   avctx->pix_fmt == AV_PIX_FMT_BGR0
     229         204 :          || avctx->pix_fmt == AV_PIX_FMT_BGRA
     230         204 :          || avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
     231           0 :         vsample[0] = hsample[0] =
     232           0 :         vsample[1] = hsample[1] =
     233           0 :         vsample[2] = hsample[2] =
     234           0 :         vsample[3] = hsample[3] = 1;
     235        1642 :     } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
     236         200 :         vsample[0] = vsample[1] = vsample[2] = 2;
     237         200 :         hsample[0] = hsample[1] = hsample[2] = 1;
     238             :     } else {
     239        1442 :         vsample[0] = 2;
     240        1442 :         vsample[1] = 2 >> chroma_v_shift;
     241        1442 :         vsample[2] = 2 >> chroma_v_shift;
     242        1442 :         hsample[0] = 2;
     243        1442 :         hsample[1] = 2 >> chroma_h_shift;
     244        1442 :         hsample[2] = 2 >> chroma_h_shift;
     245             :     }
     246        1642 : }
     247             : 
     248        1638 : void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
     249             :                                     ScanTable *intra_scantable, int pred,
     250             :                                     uint16_t luma_intra_matrix[64],
     251             :                                     uint16_t chroma_intra_matrix[64])
     252             : {
     253        1638 :     const int lossless = avctx->codec_id != AV_CODEC_ID_MJPEG && avctx->codec_id != AV_CODEC_ID_AMV;
     254             :     int hsample[4], vsample[4];
     255             :     int i;
     256        1638 :     int components = 3 + (avctx->pix_fmt == AV_PIX_FMT_BGRA);
     257        1638 :     int chroma_matrix = !!memcmp(luma_intra_matrix,
     258             :                                  chroma_intra_matrix,
     259             :                                  sizeof(luma_intra_matrix[0])*64);
     260             : 
     261        1638 :     ff_mjpeg_init_hvsample(avctx, hsample, vsample);
     262             : 
     263        1638 :     put_marker(pb, SOI);
     264             : 
     265             :     // hack for AMV mjpeg format
     266        1638 :     if(avctx->codec_id == AV_CODEC_ID_AMV) goto end;
     267             : 
     268        1438 :     jpeg_put_comments(avctx, pb);
     269             : 
     270        1438 :     jpeg_table_header(avctx, pb, intra_scantable, luma_intra_matrix, chroma_intra_matrix, hsample);
     271             : 
     272        1438 :     switch (avctx->codec_id) {
     273        1238 :     case AV_CODEC_ID_MJPEG:  put_marker(pb, SOF0 ); break;
     274         200 :     case AV_CODEC_ID_LJPEG:  put_marker(pb, SOF3 ); break;
     275           0 :     default: av_assert0(0);
     276             :     }
     277             : 
     278        1438 :     put_bits(pb, 16, 17);
     279        1438 :     if (lossless && (  avctx->pix_fmt == AV_PIX_FMT_BGR0
     280         200 :                     || avctx->pix_fmt == AV_PIX_FMT_BGRA
     281         200 :                     || avctx->pix_fmt == AV_PIX_FMT_BGR24))
     282           0 :         put_bits(pb, 8, 9); /* 9 bits/component RCT */
     283             :     else
     284        1438 :         put_bits(pb, 8, 8); /* 8 bits/component */
     285        1438 :     put_bits(pb, 16, avctx->height);
     286        1438 :     put_bits(pb, 16, avctx->width);
     287        1438 :     put_bits(pb, 8, components); /* 3 or 4 components */
     288             : 
     289             :     /* Y component */
     290        1438 :     put_bits(pb, 8, 1); /* component number */
     291        1438 :     put_bits(pb, 4, hsample[0]); /* H factor */
     292        1438 :     put_bits(pb, 4, vsample[0]); /* V factor */
     293        1438 :     put_bits(pb, 8, 0); /* select matrix */
     294             : 
     295             :     /* Cb component */
     296        1438 :     put_bits(pb, 8, 2); /* component number */
     297        1438 :     put_bits(pb, 4, hsample[1]); /* H factor */
     298        1438 :     put_bits(pb, 4, vsample[1]); /* V factor */
     299        1438 :     put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
     300             : 
     301             :     /* Cr component */
     302        1438 :     put_bits(pb, 8, 3); /* component number */
     303        1438 :     put_bits(pb, 4, hsample[2]); /* H factor */
     304        1438 :     put_bits(pb, 4, vsample[2]); /* V factor */
     305        1438 :     put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
     306             : 
     307        1438 :     if (components == 4) {
     308           0 :         put_bits(pb, 8, 4); /* component number */
     309           0 :         put_bits(pb, 4, hsample[3]); /* H factor */
     310           0 :         put_bits(pb, 4, vsample[3]); /* V factor */
     311           0 :         put_bits(pb, 8, 0); /* select matrix */
     312             :     }
     313             : 
     314             :     /* scan header */
     315        1438 :     put_marker(pb, SOS);
     316        1438 :     put_bits(pb, 16, 6 + 2*components); /* length */
     317        1438 :     put_bits(pb, 8, components); /* 3 components */
     318             : 
     319             :     /* Y component */
     320        1438 :     put_bits(pb, 8, 1); /* index */
     321        1438 :     put_bits(pb, 4, 0); /* DC huffman table index */
     322        1438 :     put_bits(pb, 4, 0); /* AC huffman table index */
     323             : 
     324             :     /* Cb component */
     325        1438 :     put_bits(pb, 8, 2); /* index */
     326        1438 :     put_bits(pb, 4, 1); /* DC huffman table index */
     327        1438 :     put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
     328             : 
     329             :     /* Cr component */
     330        1438 :     put_bits(pb, 8, 3); /* index */
     331        1438 :     put_bits(pb, 4, 1); /* DC huffman table index */
     332        1438 :     put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
     333             : 
     334        1438 :     if (components == 4) {
     335             :         /* Alpha component */
     336           0 :         put_bits(pb, 8, 4); /* index */
     337           0 :         put_bits(pb, 4, 0); /* DC huffman table index */
     338           0 :         put_bits(pb, 4, 0); /* AC huffman table index */
     339             :     }
     340             : 
     341        1438 :     put_bits(pb, 8, lossless ? pred : 0); /* Ss (not used) */
     342             : 
     343        1438 :     switch (avctx->codec_id) {
     344        1238 :     case AV_CODEC_ID_MJPEG:  put_bits(pb, 8, 63); break; /* Se (not used) */
     345         200 :     case AV_CODEC_ID_LJPEG:  put_bits(pb, 8,  0); break; /* not used */
     346           0 :     default: av_assert0(0);
     347             :     }
     348             : 
     349        1438 :     put_bits(pb, 8, 0); /* Ah/Al (not used) */
     350             : 
     351        1638 : end:
     352        1638 :     if (!lossless) {
     353        1438 :         MpegEncContext *s = avctx->priv_data;
     354        1438 :         av_assert0(avctx->codec->priv_data_size == sizeof(MpegEncContext));
     355             : 
     356        1438 :         s->esc_pos = put_bits_count(pb) >> 3;
     357        1438 :         for(i=1; i<s->slice_context_count; i++)
     358           0 :             s->thread_context[i]->esc_pos = 0;
     359             :     }
     360        1638 : }
     361             : 
     362             : /**
     363             :  * Encodes and outputs the entire frame in the JPEG format.
     364             :  *
     365             :  * @param s The MpegEncContext.
     366             :  */
     367        1238 : void ff_mjpeg_encode_picture_frame(MpegEncContext *s)
     368             : {
     369             :     int i, nbits, code, table_id;
     370        1238 :     MJpegContext *m = s->mjpeg_ctx;
     371        4952 :     uint8_t *huff_size[4] = {m->huff_size_dc_luminance,
     372        1238 :                              m->huff_size_dc_chrominance,
     373        1238 :                              m->huff_size_ac_luminance,
     374        1238 :                              m->huff_size_ac_chrominance};
     375        4952 :     uint16_t *huff_code[4] = {m->huff_code_dc_luminance,
     376        1238 :                               m->huff_code_dc_chrominance,
     377        1238 :                               m->huff_code_ac_luminance,
     378        1238 :                               m->huff_code_ac_chrominance};
     379        1238 :     size_t total_bits = 0;
     380             :     size_t bytes_needed;
     381             : 
     382        1238 :     s->header_bits = get_bits_diff(s);
     383             :     // Estimate the total size first
     384    28812345 :     for (i = 0; i < m->huff_ncode; i++) {
     385    28811107 :         table_id = m->huff_buffer[i].table_id;
     386    28811107 :         code = m->huff_buffer[i].code;
     387    28811107 :         nbits = code & 0xf;
     388             : 
     389    28811107 :         total_bits += huff_size[table_id][code] + nbits;
     390             :     }
     391             : 
     392        1238 :     bytes_needed = (total_bits + 7) / 8;
     393        1238 :     ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
     394             : 
     395    28812345 :     for (i = 0; i < m->huff_ncode; i++) {
     396    28811107 :         table_id = m->huff_buffer[i].table_id;
     397    28811107 :         code = m->huff_buffer[i].code;
     398    28811107 :         nbits = code & 0xf;
     399             : 
     400    28811107 :         put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
     401    28811107 :         if (nbits != 0) {
     402    26007642 :             put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
     403             :         }
     404             :     }
     405             : 
     406        1238 :     m->huff_ncode = 0;
     407        1238 :     s->i_tex_bits = get_bits_diff(s);
     408        1238 : }
     409             : 
     410        1638 : void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
     411             : {
     412             :     int size;
     413             :     int i, ff_count;
     414        1638 :     uint8_t *buf = pb->buf + start;
     415        1638 :     int align= (-(size_t)(buf))&3;
     416        1638 :     int pad = (-put_bits_count(pb))&7;
     417             : 
     418        1638 :     if (pad)
     419        1419 :         put_bits(pb, pad, (1<<pad)-1);
     420             : 
     421        1638 :     flush_put_bits(pb);
     422        1638 :     size = put_bits_count(pb) - start * 8;
     423             : 
     424             :     av_assert1((size&7) == 0);
     425        1638 :     size >>= 3;
     426             : 
     427        1638 :     ff_count=0;
     428        4487 :     for(i=0; i<size && i<align; i++){
     429        2849 :         if(buf[i]==0xFF) ff_count++;
     430             :     }
     431     2331275 :     for(; i<size-15; i+=16){
     432             :         int acc, v;
     433             : 
     434     2329637 :         v= *(uint32_t*)(&buf[i]);
     435     2329637 :         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
     436     2329637 :         v= *(uint32_t*)(&buf[i+4]);
     437     2329637 :         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
     438     2329637 :         v= *(uint32_t*)(&buf[i+8]);
     439     2329637 :         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
     440     2329637 :         v= *(uint32_t*)(&buf[i+12]);
     441     2329637 :         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
     442             : 
     443     2329637 :         acc>>=4;
     444     2329637 :         acc+= (acc>>16);
     445     2329637 :         acc+= (acc>>8);
     446     2329637 :         ff_count+= acc&0xFF;
     447             :     }
     448       13684 :     for(; i<size; i++){
     449       12046 :         if(buf[i]==0xFF) ff_count++;
     450             :     }
     451             : 
     452        1638 :     if(ff_count==0) return;
     453             : 
     454        1607 :     flush_put_bits(pb);
     455        1607 :     skip_put_bytes(pb, ff_count);
     456             : 
     457    36521623 :     for(i=size-1; ff_count; i--){
     458    36520016 :         int v= buf[i];
     459             : 
     460    36520016 :         if(v==0xFF){
     461      138316 :             buf[i+ff_count]= 0;
     462      138316 :             ff_count--;
     463             :         }
     464             : 
     465    36520016 :         buf[i+ff_count]= v;
     466             :     }
     467             : }
     468             : 
     469             : /**
     470             :  * Builds all 4 optimal Huffman tables.
     471             :  *
     472             :  * Uses the data stored in the JPEG buffer to compute the tables.
     473             :  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
     474             :  *
     475             :  * @param m MJpegContext containing the JPEG buffer.
     476             :  */
     477        1238 : static void ff_mjpeg_build_optimal_huffman(MJpegContext *m)
     478             : {
     479             :     int i, table_id, code;
     480             : 
     481             :     MJpegEncHuffmanContext dc_luminance_ctx;
     482             :     MJpegEncHuffmanContext dc_chrominance_ctx;
     483             :     MJpegEncHuffmanContext ac_luminance_ctx;
     484             :     MJpegEncHuffmanContext ac_chrominance_ctx;
     485        1238 :     MJpegEncHuffmanContext *ctx[4] = {&dc_luminance_ctx,
     486             :                                       &dc_chrominance_ctx,
     487             :                                       &ac_luminance_ctx,
     488             :                                       &ac_chrominance_ctx};
     489        6190 :     for (i = 0; i < 4; i++) {
     490        4952 :         ff_mjpeg_encode_huffman_init(ctx[i]);
     491             :     }
     492    28812345 :     for (i = 0; i < m->huff_ncode; i++) {
     493    28811107 :         table_id = m->huff_buffer[i].table_id;
     494    28811107 :         code = m->huff_buffer[i].code;
     495             : 
     496    28811107 :         ff_mjpeg_encode_huffman_increment(ctx[table_id], code);
     497             :     }
     498             : 
     499        1238 :     ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
     500        1238 :                                   m->bits_dc_luminance,
     501        1238 :                                   m->val_dc_luminance, 12);
     502        1238 :     ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
     503        1238 :                                   m->bits_dc_chrominance,
     504        1238 :                                   m->val_dc_chrominance, 12);
     505        1238 :     ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
     506        1238 :                                   m->bits_ac_luminance,
     507        1238 :                                   m->val_ac_luminance, 256);
     508        1238 :     ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
     509        1238 :                                   m->bits_ac_chrominance,
     510        1238 :                                   m->val_ac_chrominance, 256);
     511             : 
     512        1238 :     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
     513        1238 :                                  m->huff_code_dc_luminance,
     514        1238 :                                  m->bits_dc_luminance,
     515        1238 :                                  m->val_dc_luminance);
     516        1238 :     ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
     517        1238 :                                  m->huff_code_dc_chrominance,
     518        1238 :                                  m->bits_dc_chrominance,
     519        1238 :                                  m->val_dc_chrominance);
     520        1238 :     ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
     521        1238 :                                  m->huff_code_ac_luminance,
     522        1238 :                                  m->bits_ac_luminance,
     523        1238 :                                  m->val_ac_luminance);
     524        1238 :     ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
     525        1238 :                                  m->huff_code_ac_chrominance,
     526        1238 :                                  m->bits_ac_chrominance,
     527        1238 :                                  m->val_ac_chrominance);
     528        1238 : }
     529             : 
     530             : /**
     531             :  * Writes the complete JPEG frame when optimal huffman tables are enabled,
     532             :  * otherwise writes the stuffing.
     533             :  *
     534             :  * Header + values + stuffing.
     535             :  *
     536             :  * @param s The MpegEncContext.
     537             :  * @return int Error code, 0 if successful.
     538             :  */
     539        1438 : int ff_mjpeg_encode_stuffing(MpegEncContext *s)
     540             : {
     541             :     int i;
     542        1438 :     PutBitContext *pbc = &s->pb;
     543        1438 :     int mb_y = s->mb_y - !s->mb_x;
     544             :     int ret;
     545             :     MJpegContext *m;
     546             : 
     547        1438 :     m = s->mjpeg_ctx;
     548             : 
     549        1438 :     if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
     550        1238 :         ff_mjpeg_build_optimal_huffman(m);
     551             : 
     552             :         // Replace the VLCs with the optimal ones.
     553             :         // The default ones may be used for trellis during quantization.
     554        1238 :         ff_init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
     555        1238 :         ff_init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
     556        1238 :         s->intra_ac_vlc_length      =
     557        1238 :         s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
     558        1238 :         s->intra_chroma_ac_vlc_length      =
     559        1238 :         s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
     560             : 
     561        1238 :         ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
     562        1238 :                                        s->pred, s->intra_matrix, s->chroma_intra_matrix);
     563        1238 :         ff_mjpeg_encode_picture_frame(s);
     564             :     }
     565             : 
     566        1438 :     ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
     567        1438 :                                             put_bits_count(&s->pb) / 4 + 1000);
     568             : 
     569        1438 :     if (ret < 0) {
     570           0 :         av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
     571           0 :         goto fail;
     572             :     }
     573             : 
     574        1438 :     ff_mjpeg_escape_FF(pbc, s->esc_pos);
     575             : 
     576        1438 :     if((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height)
     577           0 :         put_marker(pbc, RST0 + (mb_y&7));
     578        1438 :     s->esc_pos = put_bits_count(pbc) >> 3;
     579        1438 : fail:
     580             : 
     581        5752 :     for(i=0; i<3; i++)
     582        4314 :         s->last_dc[i] = 128 << s->intra_dc_precision;
     583             : 
     584        1438 :     return ret;
     585             : }
     586             : 
     587        1638 : void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
     588             : {
     589             :     av_assert1((header_bits & 7) == 0);
     590             : 
     591        1638 :     put_marker(pb, EOI);
     592        1638 : }
     593             : 
     594    23255400 : void ff_mjpeg_encode_dc(PutBitContext *pb, int val,
     595             :                         uint8_t *huff_size, uint16_t *huff_code)
     596             : {
     597             :     int mant, nbits;
     598             : 
     599    23255400 :     if (val == 0) {
     600     2701595 :         put_bits(pb, huff_size[0], huff_code[0]);
     601             :     } else {
     602    20553805 :         mant = val;
     603    20553805 :         if (val < 0) {
     604     8922845 :             val = -val;
     605     8922845 :             mant--;
     606             :         }
     607             : 
     608    20553805 :         nbits= av_log2_16bit(val) + 1;
     609             : 
     610    20553805 :         put_bits(pb, huff_size[nbits], huff_code[nbits]);
     611             : 
     612    20553805 :         put_sbits(pb, nbits, mant);
     613             :     }
     614    23255400 : }

Generated by: LCOV version 1.13