[ tor-browser ].git.dasho

enc_jpeg_data.cc (14477B)
      1 // Copyright (c) the JPEG XL Project Authors. All rights reserved.
      2 //
      3 // Use of this source code is governed by a BSD-style
      4 // license that can be found in the LICENSE file.
      5 
      6 #include "lib/jxl/jpeg/enc_jpeg_data.h"
      7 
      8 #include <brotli/encode.h>
      9 #include <jxl/cms.h>
     10 #include <jxl/memory_manager.h>
     11 #include <jxl/types.h>
     12 
     13 #include <cstdint>
     14 
     15 #include "lib/jxl/base/sanitizers.h"
     16 #include "lib/jxl/base/status.h"
     17 #include "lib/jxl/codec_in_out.h"
     18 #include "lib/jxl/enc_aux_out.h"
     19 #include "lib/jxl/enc_bit_writer.h"
     20 #include "lib/jxl/image_bundle.h"
     21 #include "lib/jxl/jpeg/enc_jpeg_data_reader.h"
     22 #include "lib/jxl/luminance.h"
     23 
     24 namespace jxl {
     25 namespace jpeg {
     26 
     27 namespace {
     28 
     29 constexpr int BITS_IN_JSAMPLE = 8;
     30 using ByteSpan = Span<const uint8_t>;
     31 
     32 // TODO(eustas): move to jpeg_data, to use from codec_jpg as well.
     33 // See if there is a canonically chunked ICC profile and mark corresponding
     34 // app-tags with AppMarkerType::kICC.
     35 Status DetectIccProfile(JPEGData& jpeg_data) {
     36  JXL_ENSURE(jpeg_data.app_data.size() == jpeg_data.app_marker_type.size());
     37  size_t num_icc = 0;
     38  size_t num_icc_jpeg = 0;
     39  for (size_t i = 0; i < jpeg_data.app_data.size(); i++) {
     40    const auto& app = jpeg_data.app_data[i];
     41    size_t pos = 0;
     42    if (app[pos++] != 0xE2) continue;
     43    // At least APPn + size; otherwise it should be intermarker-data.
     44    JXL_ENSURE(app.size() >= 3);
     45    size_t tag_length = (app[pos] << 8) + app[pos + 1];
     46    pos += 2;
     47    JXL_ENSURE(app.size() == tag_length + 1);
     48    // Empty payload is 2 bytes for tag length itself + signature
     49    if (tag_length < 2 + sizeof kIccProfileTag) continue;
     50 
     51    if (memcmp(&app[pos], kIccProfileTag, sizeof kIccProfileTag) != 0) continue;
     52    pos += sizeof kIccProfileTag;
     53    uint8_t chunk_id = app[pos++];
     54    uint8_t num_chunks = app[pos++];
     55    if (chunk_id != num_icc + 1) continue;
     56    if (num_icc_jpeg == 0) num_icc_jpeg = num_chunks;
     57    if (num_icc_jpeg != num_chunks) continue;
     58    num_icc++;
     59    jpeg_data.app_marker_type[i] = AppMarkerType::kICC;
     60  }
     61  if (num_icc != num_icc_jpeg) {
     62    return JXL_FAILURE("Invalid ICC chunks");
     63  }
     64  return true;
     65 }
     66 
     67 bool GetMarkerPayload(const uint8_t* data, size_t size, ByteSpan* payload) {
     68  if (size < 3) {
     69    return false;
     70  }
     71  size_t hi = data[1];
     72  size_t lo = data[2];
     73  size_t internal_size = (hi << 8u) | lo;
     74  // Second byte of marker is not counted towards size.
     75  if (internal_size != size - 1) {
     76    return false;
     77  }
     78  // cut second marker byte and "length" from payload.
     79  *payload = ByteSpan(data, size);
     80  if (!payload->remove_prefix(3)) return false;
     81  return true;
     82 }
     83 
     84 Status DetectBlobs(jpeg::JPEGData& jpeg_data) {
     85  JXL_ENSURE(jpeg_data.app_data.size() == jpeg_data.app_marker_type.size());
     86  bool have_exif = false;
     87  bool have_xmp = false;
     88  for (size_t i = 0; i < jpeg_data.app_data.size(); i++) {
     89    auto& marker = jpeg_data.app_data[i];
     90    if (marker.empty() || marker[0] != kApp1) {
     91      continue;
     92    }
     93    ByteSpan payload;
     94    if (!GetMarkerPayload(marker.data(), marker.size(), &payload)) {
     95      // Something is wrong with this marker; does not care.
     96      continue;
     97    }
     98    if (!have_exif && payload.size() > sizeof kExifTag &&
     99        !memcmp(payload.data(), kExifTag, sizeof kExifTag)) {
    100      jpeg_data.app_marker_type[i] = AppMarkerType::kExif;
    101      have_exif = true;
    102    }
    103    if (!have_xmp && payload.size() >= sizeof kXMPTag &&
    104        !memcmp(payload.data(), kXMPTag, sizeof kXMPTag)) {
    105      jpeg_data.app_marker_type[i] = AppMarkerType::kXMP;
    106      have_xmp = true;
    107    }
    108  }
    109  return true;
    110 }
    111 
    112 Status ParseChunkedMarker(const jpeg::JPEGData& src, uint8_t marker_type,
    113                          const ByteSpan& tag, IccBytes* output,
    114                          bool allow_permutations = false) {
    115  output->clear();
    116 
    117  std::vector<ByteSpan> chunks;
    118  std::vector<bool> presence;
    119  size_t expected_number_of_parts = 0;
    120  bool is_first_chunk = true;
    121  size_t ordinal = 0;
    122  for (const auto& marker : src.app_data) {
    123    if (marker.empty() || marker[0] != marker_type) {
    124      continue;
    125    }
    126    ByteSpan payload;
    127    if (!GetMarkerPayload(marker.data(), marker.size(), &payload)) {
    128      // Something is wrong with this marker; does not care.
    129      continue;
    130    }
    131    if ((payload.size() < tag.size()) ||
    132        memcmp(payload.data(), tag.data(), tag.size()) != 0) {
    133      continue;
    134    }
    135    JXL_RETURN_IF_ERROR(payload.remove_prefix(tag.size()));
    136    if (payload.size() < 2) {
    137      return JXL_FAILURE("Chunk is too small.");
    138    }
    139    uint8_t index = payload[0];
    140    uint8_t total = payload[1];
    141    ordinal++;
    142    if (!allow_permutations) {
    143      if (index != ordinal) return JXL_FAILURE("Invalid chunk order.");
    144    }
    145 
    146    JXL_RETURN_IF_ERROR(payload.remove_prefix(2));
    147 
    148    JXL_RETURN_IF_ERROR(total != 0);
    149    if (is_first_chunk) {
    150      is_first_chunk = false;
    151      expected_number_of_parts = total;
    152      // 1-based indices; 0-th element is added for convenience.
    153      chunks.resize(total + 1);
    154      presence.resize(total + 1);
    155    } else {
    156      JXL_RETURN_IF_ERROR(expected_number_of_parts == total);
    157    }
    158 
    159    if (index == 0 || index > total) {
    160      return JXL_FAILURE("Invalid chunk index.");
    161    }
    162 
    163    if (presence[index]) {
    164      return JXL_FAILURE("Duplicate chunk.");
    165    }
    166    presence[index] = true;
    167    chunks[index] = payload;
    168  }
    169 
    170  for (size_t i = 0; i < expected_number_of_parts; ++i) {
    171    // 0-th element is not used.
    172    size_t index = i + 1;
    173    if (!presence[index]) {
    174      return JXL_FAILURE("Missing chunk.");
    175    }
    176    chunks[index].AppendTo(*output);
    177  }
    178 
    179  return true;
    180 }
    181 
    182 Status SetBlobsFromJpegData(const jpeg::JPEGData& jpeg_data, Blobs* blobs) {
    183  for (const auto& marker : jpeg_data.app_data) {
    184    if (marker.empty() || marker[0] != kApp1) {
    185      continue;
    186    }
    187    ByteSpan payload;
    188    if (!GetMarkerPayload(marker.data(), marker.size(), &payload)) {
    189      // Something is wrong with this marker; does not care.
    190      continue;
    191    }
    192    if (payload.size() >= sizeof kExifTag &&
    193        !memcmp(payload.data(), kExifTag, sizeof kExifTag)) {
    194      if (blobs->exif.empty()) {
    195        blobs->exif.resize(payload.size() - sizeof kExifTag);
    196        memcpy(blobs->exif.data(), payload.data() + sizeof kExifTag,
    197               payload.size() - sizeof kExifTag);
    198      } else {
    199        JXL_WARNING(
    200            "ReJPEG: multiple Exif blobs, storing only first one in the JPEG "
    201            "XL container\n");
    202      }
    203    }
    204    if (payload.size() >= sizeof kXMPTag &&
    205        !memcmp(payload.data(), kXMPTag, sizeof kXMPTag)) {
    206      if (blobs->xmp.empty()) {
    207        blobs->xmp.resize(payload.size() - sizeof kXMPTag);
    208        memcpy(blobs->xmp.data(), payload.data() + sizeof kXMPTag,
    209               payload.size() - sizeof kXMPTag);
    210      } else {
    211        JXL_WARNING(
    212            "ReJPEG: multiple XMP blobs, storing only first one in the JPEG "
    213            "XL container\n");
    214      }
    215    }
    216  }
    217  return true;
    218 }
    219 
    220 inline bool IsJPG(const Span<const uint8_t> bytes) {
    221  return bytes.size() >= 2 && bytes[0] == 0xFF && bytes[1] == 0xD8;
    222 }
    223 
    224 }  // namespace
    225 
    226 Status SetColorEncodingFromJpegData(const jpeg::JPEGData& jpg,
    227                                    ColorEncoding* color_encoding) {
    228  IccBytes icc_profile;
    229  if (!ParseChunkedMarker(jpg, kApp2, ByteSpan(kIccProfileTag), &icc_profile)) {
    230    JXL_WARNING("ReJPEG: corrupted ICC profile\n");
    231    icc_profile.clear();
    232  }
    233 
    234  if (icc_profile.empty()) {
    235    bool is_gray = (jpg.components.size() == 1);
    236    *color_encoding = ColorEncoding::SRGB(is_gray);
    237  } else {
    238    JXL_RETURN_IF_ERROR(
    239        color_encoding->SetICC(std::move(icc_profile), JxlGetDefaultCms()));
    240  }
    241  return true;
    242 }
    243 
    244 Status SetChromaSubsamplingFromJpegData(const JPEGData& jpg,
    245                                        YCbCrChromaSubsampling* cs) {
    246  size_t nbcomp = jpg.components.size();
    247  if (nbcomp != 1 && nbcomp != 3) {
    248    return JXL_FAILURE("Cannot recompress JPEGs with neither 1 nor 3 channels");
    249  }
    250  if (nbcomp == 3) {
    251    uint8_t hsample[3];
    252    uint8_t vsample[3];
    253    for (size_t i = 0; i < nbcomp; i++) {
    254      hsample[i] = jpg.components[i].h_samp_factor;
    255      vsample[i] = jpg.components[i].v_samp_factor;
    256    }
    257    JXL_RETURN_IF_ERROR(cs->Set(hsample, vsample));
    258  } else if (nbcomp == 1) {
    259    uint8_t hsample[3];
    260    uint8_t vsample[3];
    261    for (size_t i = 0; i < 3; i++) {
    262      hsample[i] = jpg.components[0].h_samp_factor;
    263      vsample[i] = jpg.components[0].v_samp_factor;
    264    }
    265    JXL_RETURN_IF_ERROR(cs->Set(hsample, vsample));
    266  }
    267  return true;
    268 }
    269 
    270 Status SetColorTransformFromJpegData(const JPEGData& jpg,
    271                                     ColorTransform* color_transform) {
    272  size_t nbcomp = jpg.components.size();
    273  if (nbcomp != 1 && nbcomp != 3) {
    274    return JXL_FAILURE("Cannot recompress JPEGs with neither 1 nor 3 channels");
    275  }
    276  bool is_rgb = false;
    277  {
    278    const auto& markers = jpg.marker_order;
    279    // If there is a JFIF marker, this is YCbCr. Otherwise...
    280    if (std::find(markers.begin(), markers.end(), 0xE0) == markers.end()) {
    281      // Try to find an 'Adobe' marker.
    282      size_t app_markers = 0;
    283      size_t i = 0;
    284      for (; i < markers.size(); i++) {
    285        // This is an APP marker.
    286        if ((markers[i] & 0xF0) == 0xE0) {
    287          JXL_ENSURE(app_markers < jpg.app_data.size());
    288          // APP14 marker
    289          if (markers[i] == 0xEE) {
    290            const auto& data = jpg.app_data[app_markers];
    291            if (data.size() == 15 && data[3] == 'A' && data[4] == 'd' &&
    292                data[5] == 'o' && data[6] == 'b' && data[7] == 'e') {
    293              // 'Adobe' marker.
    294              is_rgb = data[14] == 0;
    295              break;
    296            }
    297          }
    298          app_markers++;
    299        }
    300      }
    301 
    302      if (i == markers.size()) {
    303        // No 'Adobe' marker, guess from component IDs.
    304        is_rgb = nbcomp == 3 && jpg.components[0].id == 'R' &&
    305                 jpg.components[1].id == 'G' && jpg.components[2].id == 'B';
    306      }
    307    }
    308  }
    309  *color_transform =
    310      (!is_rgb || nbcomp == 1) ? ColorTransform::kYCbCr : ColorTransform::kNone;
    311  return true;
    312 }
    313 
    314 Status EncodeJPEGData(JxlMemoryManager* memory_manager, JPEGData& jpeg_data,
    315                      std::vector<uint8_t>* bytes,
    316                      const CompressParams& cparams) {
    317  bytes->clear();
    318  jpeg_data.app_marker_type.resize(jpeg_data.app_data.size(),
    319                                   AppMarkerType::kUnknown);
    320  JXL_RETURN_IF_ERROR(DetectIccProfile(jpeg_data));
    321  JXL_RETURN_IF_ERROR(DetectBlobs(jpeg_data));
    322 
    323  size_t total_data = 0;
    324  for (size_t i = 0; i < jpeg_data.app_data.size(); i++) {
    325    if (jpeg_data.app_marker_type[i] != AppMarkerType::kUnknown) {
    326      continue;
    327    }
    328    total_data += jpeg_data.app_data[i].size();
    329  }
    330  for (const auto& data : jpeg_data.com_data) {
    331    total_data += data.size();
    332  }
    333  for (const auto& data : jpeg_data.inter_marker_data) {
    334    total_data += data.size();
    335  }
    336  total_data += jpeg_data.tail_data.size();
    337  size_t brotli_capacity = BrotliEncoderMaxCompressedSize(total_data);
    338 
    339  BitWriter writer{memory_manager};
    340  JXL_RETURN_IF_ERROR(
    341      Bundle::Write(jpeg_data, &writer, LayerType::Header, nullptr));
    342  writer.ZeroPadToByte();
    343  {
    344    PaddedBytes serialized_jpeg_data = std::move(writer).TakeBytes();
    345    bytes->reserve(serialized_jpeg_data.size() + brotli_capacity);
    346    Bytes(serialized_jpeg_data).AppendTo(*bytes);
    347  }
    348 
    349  BrotliEncoderState* brotli_enc =
    350      BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
    351  int effort = cparams.brotli_effort;
    352  if (effort < 0) effort = 11 - static_cast<int>(cparams.speed_tier);
    353  BrotliEncoderSetParameter(brotli_enc, BROTLI_PARAM_QUALITY, effort);
    354  size_t initial_size = bytes->size();
    355  BrotliEncoderSetParameter(brotli_enc, BROTLI_PARAM_SIZE_HINT, total_data);
    356  bytes->resize(initial_size + brotli_capacity);
    357  size_t enc_size = 0;
    358  auto br_append = [&](const std::vector<uint8_t>& data, bool last) -> Status {
    359    size_t available_in = data.size();
    360    const uint8_t* in = data.data();
    361    uint8_t* out = &(*bytes)[initial_size + enc_size];
    362    do {
    363      uint8_t* out_before = out;
    364      msan::MemoryIsInitialized(in, available_in);
    365      JXL_ENSURE(BrotliEncoderCompressStream(
    366          brotli_enc, last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
    367          &available_in, &in, &brotli_capacity, &out, &enc_size));
    368      msan::UnpoisonMemory(out_before, out - out_before);
    369    } while (FROM_JXL_BOOL(BrotliEncoderHasMoreOutput(brotli_enc)) ||
    370             available_in > 0);
    371    return true;
    372  };
    373 
    374  for (size_t i = 0; i < jpeg_data.app_data.size(); i++) {
    375    if (jpeg_data.app_marker_type[i] != AppMarkerType::kUnknown) {
    376      continue;
    377    }
    378    JXL_RETURN_IF_ERROR(br_append(jpeg_data.app_data[i], /*last=*/false));
    379  }
    380  for (const auto& data : jpeg_data.com_data) {
    381    JXL_RETURN_IF_ERROR(br_append(data, /*last=*/false));
    382  }
    383  for (const auto& data : jpeg_data.inter_marker_data) {
    384    JXL_RETURN_IF_ERROR(br_append(data, /*last=*/false));
    385  }
    386  JXL_RETURN_IF_ERROR(br_append(jpeg_data.tail_data, /*last=*/true));
    387  BrotliEncoderDestroyInstance(brotli_enc);
    388  bytes->resize(initial_size + enc_size);
    389  return true;
    390 }
    391 
    392 Status DecodeImageJPG(const Span<const uint8_t> bytes, CodecInOut* io) {
    393  if (!IsJPG(bytes)) return false;
    394  JxlMemoryManager* memory_manager = io->memory_manager;
    395  io->frames.clear();
    396  io->frames.reserve(1);
    397  io->frames.emplace_back(memory_manager, &io->metadata.m);
    398  io->Main().jpeg_data = make_unique<jpeg::JPEGData>();
    399  jpeg::JPEGData* jpeg_data = io->Main().jpeg_data.get();
    400  if (!jpeg::ReadJpeg(bytes.data(), bytes.size(), jpeg::JpegReadMode::kReadAll,
    401                      jpeg_data)) {
    402    return JXL_FAILURE("Error reading JPEG");
    403  }
    404  JXL_RETURN_IF_ERROR(
    405      SetColorEncodingFromJpegData(*jpeg_data, &io->metadata.m.color_encoding));
    406  JXL_RETURN_IF_ERROR(SetBlobsFromJpegData(*jpeg_data, &io->blobs));
    407  JXL_RETURN_IF_ERROR(SetChromaSubsamplingFromJpegData(
    408      *jpeg_data, &io->Main().chroma_subsampling));
    409  JXL_RETURN_IF_ERROR(
    410      SetColorTransformFromJpegData(*jpeg_data, &io->Main().color_transform));
    411 
    412  io->metadata.m.SetIntensityTarget(kDefaultIntensityTarget);
    413  io->metadata.m.SetUintSamples(BITS_IN_JSAMPLE);
    414  JXL_ASSIGN_OR_RETURN(
    415      Image3F tmp,
    416      Image3F::Create(memory_manager, jpeg_data->width, jpeg_data->height));
    417  JXL_RETURN_IF_ERROR(
    418      io->SetFromImage(std::move(tmp), io->metadata.m.color_encoding));
    419  SetIntensityTarget(&io->metadata.m);
    420  return true;
    421 }
    422 
    423 }  // namespace jpeg
    424 }  // namespace jxl
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE