Fix a bug that JPX images can't be shown

core/src/fxcodec/codec/fx_codec_jpx_opj.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxcodec/fx_codec.h"
 #include "codec_int.h"
 #include "../fx_libopenjpeg/libopenjpeg20/openjpeg.h"
 #include "../lcms2/include/fx_lcms2.h"
@@ skipping 22 matching lines @@
     }
     OPJ_SIZE_T bufferLength = srcData->src_size - srcData->offset;
     OPJ_SIZE_T readlength = p_nb_bytes < bufferLength ? p_nb_bytes : bufferLength;
     memcpy(p_buffer, &srcData->src_data[srcData->offset], readlength);
     srcData->offset += readlength;
     return readlength;
 }
 static OPJ_SIZE_T opj_write_from_memory (void * p_buffer, OPJ_SIZE_T p_nb_bytes, void* p_user_data)
 {
     DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
     if (srcData == NULL || srcData->src_size == 0 || srcData->src_data == NULL || srcData->offset >= srcData->src_size) {

[Tom Sepez, 2015/03/11 18:29:12]

Also, per the spec, a fseek() beyond EOF followed by a write produces a region
read back as 0s from the "file".  I'm not sure we care.

[jun_fang, 2015/03/11 21:14:41]

I think that the checking |srcData->offset >= srcData->src_size| is used to
ensure |p_buffer + writeLength| not to overflow. 

         return -1;
     }
     OPJ_SIZE_T bufferLength = srcData->src_size - srcData->offset;
     OPJ_SIZE_T writeLength = p_nb_bytes < bufferLength ? p_nb_bytes : bufferLength;
     memcpy(&srcData->src_data[srcData->offset], p_buffer, writeLength);
     srcData->offset += writeLength;
     return writeLength;
 }
 static OPJ_OFF_T opj_skip_from_memory (OPJ_OFF_T p_nb_bytes, void* p_user_data)
 {
     DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
-    if (srcData == NULL || srcData->src_size == 0 || srcData->src_data == NULL || srcData->offset >= srcData->src_size) {
+    if (srcData == NULL || srcData->src_size == 0 || srcData->src_data == NULL) {
         return -1;
     }
+    if (srcData->offset >= srcData->src_size) {
+        return p_nb_bytes;

[Tom Sepez, 2015/03/11 18:25:41]

I think we have to adjust the offset here, for example imagine a "file"
of size 1024 with a current offset of 1000, and we do a skip of 100. A
subsequent read should then return 0 bytes, but we'd give the remaining 24.

It gets worse should we allow negative seeks (is OPJ_OFF_T signed?), in which
case we'd have to handle seeking back into a valid portion of the "file" at the
correct offset even after seeking past EOF. This kind of implies that the
invariant that srcData->offset < srcData->src_size can't hold, which is
unfortunate because it feels safer that way. 

Let's assume that we don't have to handle negative seeks, and just set
srcData->offset to srcData->size here. 

[jun_fang, 2015/03/11 21:14:41]

Acknowledged.

+    }
     OPJ_SIZE_T bufferLength = srcData->src_size - srcData->offset;
     OPJ_SIZE_T skipLength = p_nb_bytes < bufferLength ? p_nb_bytes : bufferLength;
     srcData->offset += skipLength;
     return skipLength;
 }
 static OPJ_BOOL opj_seek_from_memory (OPJ_OFF_T p_nb_bytes, void* p_user_data)
 {
     DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
-    if (srcData == NULL || srcData->src_size == 0 || srcData->src_data == NULL || srcData->offset >= srcData->src_size) {
+    if (srcData == NULL || srcData->src_size == 0 || srcData->src_data == NULL) {
         return OPJ_FALSE;
     }
+    if (srcData->offset >= srcData->src_size) {
+        return OPJ_TRUE;
+    }
     if (p_nb_bytes >= srcData->src_size) {
         return OPJ_FALSE;
     }
     srcData->offset = p_nb_bytes;
     return OPJ_TRUE;
 }
 opj_stream_t* fx_opj_stream_create_memory_stream (DecodeData* data,     OPJ_SIZE_T p_size,      OPJ_BOOL p_is_read_stream)
 {
     opj_stream_t* l_stream = 00;
     if (!data || ! data->src_data || data->src_size <= 0 ) {
@@ skipping 543 matching lines @@
         image->useColorSpace = 0;
     }
 */
     if (!parameters.nb_tile_to_decode) {
         if (!opj_set_decode_area(l_codec, image, parameters.DA_x0,
                                     parameters.DA_y0, parameters.DA_x1, parameters.DA_y1)) {
             opj_image_destroy(image);
             image = NULL;
             return FALSE;
         }
-        if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec,       l_stream))) {
+        if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
             opj_image_destroy(image);
             image = NULL;
             return FALSE;
         }
     } else {
         if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
             return FALSE;
         }
     }
     opj_stream_destroy(l_stream);
@@ skipping 142 matching lines @@
 FX_BOOL CCodec_JpxModule::Decode(void* ctx, FX_LPBYTE dest_data, int pitch, FX_BOOL bTranslateColor, FX_LPBYTE offsets)
 {
     CJPX_Decoder* pDecoder = (CJPX_Decoder*)ctx;
     return pDecoder->Decode(dest_data, pitch, bTranslateColor, offsets);
 }
 void CCodec_JpxModule::DestroyDecoder(void* ctx)
 {
     CJPX_Decoder* pDecoder = (CJPX_Decoder*)ctx;
     delete pDecoder;
 }