~josejuan-sanchez/esajpip/emptypackets

« back to all changes in this revision

Viewing changes to src/jpip/databin_server.cc

  • Committer: José Juan Sánchez Hernández
  • Date: 2012-07-18 11:40:37 UTC
  • Revision ID: josejuan.sanchez@gmail.com-20120718114037-mslgs1evd0gwjp2y
Modifications to control empty packets

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
    has_woi = false;
13
13
    im_index = image_index;
14
14
 
 
15
        // PRUEBA
 
16
    packets_sent.clear();
 
17
    list_of_empty_segments.clear();
 
18
    // ****
 
19
 
15
20
    file = File::Ptr(new File());
16
21
 
17
22
    if(!file->OpenForReading(im_index->GetPathName())) return false;
87
92
 
88
93
    return res;
89
94
  }
90
 
        
91
 
  bool DataBinServer::GenerateChunk(char *buff, int *len, bool *last)
92
 
  {
93
 
    int res;
94
 
 
95
 
    data_writer.SetBuffer(buff, min(pending, *len));
96
 
 
97
 
    if(pending > 0) {
98
 
      eof = false;
99
 
 
100
 
      if(!im_index->ReadLock(range)) {
101
 
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be taken for reading");
102
 
        return false;
103
 
      }
104
 
 
105
 
      if(!cache_model.IsFullMetadata())
106
 
      {
107
 
        if(im_index->GetNumMetadatas() <= 0)
108
 
          WriteSegment<DataBinClass::META_DATA>(0, 0, FileSegment::Null);
109
 
        else {
110
 
          int bin_offset = 0;
111
 
          bool last_metadata = false;
112
 
 
113
 
          for (int i = 0; i < im_index->GetNumMetadatas(); i++)
114
 
          {
115
 
            last_metadata = (i == (im_index->GetNumMetadatas() - 1));
116
 
            res = WriteSegment<DataBinClass::META_DATA>(0, 0, im_index->GetMetadata(i), bin_offset, last_metadata);
117
 
            bin_offset += im_index->GetMetadata(i).length;
118
 
 
119
 
            if (last_metadata) {
120
 
              if(res > 0) cache_model.SetFullMetadata();
121
 
 
122
 
            } else {
123
 
              if (WritePlaceHolder(0, 0, im_index->GetPlaceHolder(i), bin_offset) <= 0) break;
124
 
              bin_offset += im_index->GetPlaceHolder(i).length();
125
 
            }
126
 
          }
127
 
        }
128
 
      }
129
 
 
130
 
      if (!eof)
131
 
      {
132
 
        for (int i = range.first; i <= range.last; i++)
133
 
        {
134
 
          WriteSegment<DataBinClass::MAIN_HEADER>(i, 0, im_index->GetMainHeader(i));
135
 
          WriteSegment<DataBinClass::TILE_HEADER>(i, 0, FileSegment::Null);
136
 
        }
137
 
 
138
 
        if(has_woi) {
139
 
          Packet packet;
140
 
          FileSegment segment;
141
 
          int bin_id, bin_offset;
142
 
          bool last_packet = false;
143
 
 
144
 
          while(data_writer && !eof) {
145
 
            packet = woi_composer.GetCurrentPacket();
146
 
 
147
 
            segment = im_index->GetPacket(current_idx, packet, &bin_offset);
148
 
            bin_id = im_index->GetCodingParameters()->GetPrecinctDataBinId(packet);
149
 
            last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
150
 
 
151
 
            res = WriteSegment<DataBinClass::PRECINCT>(current_idx, bin_id, segment, bin_offset, last_packet);
152
 
 
153
 
            if(res < 0) return false;
154
 
            else if(res > 0) {
155
 
              if (current_idx != range.last) current_idx++;
156
 
              else
157
 
              {
158
 
                if(!woi_composer.GetNextPacket()) break;
159
 
                else current_idx = range.first;
160
 
              }
161
 
            }
162
 
          }
163
 
        }
164
 
      }
165
 
 
166
 
      if(!eof) {
167
 
        data_writer.WriteEOR(EOR::WINDOW_DONE);
168
 
        end_woi_ = true;
169
 
        pending = 0;
170
 
 
171
 
      } else {
172
 
        pending -= data_writer.GetCount();
173
 
 
174
 
        if(pending <= MINIMUM_SPACE + 100) {
175
 
          data_writer.WriteEOR(EOR::BYTE_LIMIT_REACHED);
176
 
          pending = 0;
177
 
        }
178
 
      }
179
 
 
180
 
      if(!im_index->ReadUnlock(range)) {
181
 
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be released");
182
 
        return false;
183
 
      }
184
 
    }
185
 
 
186
 
    *len = data_writer.GetCount();
187
 
    *last = (pending <= 0);
188
 
 
189
 
    if(*last) cache_model.Pack();
190
 
 
191
 
    return data_writer;
192
 
  }
193
 
 
 
95
 
 
96
  // NOTA: Original
 
97
  /*
 
98
  bool DataBinServer::GenerateChunk(char *buff, int *len, bool *last)
 
99
  {
 
100
      int res;
 
101
 
 
102
      data_writer.SetBuffer(buff, min(pending, *len));
 
103
 
 
104
      if(pending > 0) {
 
105
        eof = false;
 
106
 
 
107
        if(!im_index->ReadLock(range)) {
 
108
          ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be taken for reading");
 
109
          return false;
 
110
        }
 
111
 
 
112
        if(!cache_model.IsFullMetadata())
 
113
        {
 
114
          if(im_index->GetNumMetadatas() <= 0)
 
115
            WriteSegment<DataBinClass::META_DATA>(0, 0, FileSegment::Null);
 
116
          else {
 
117
            int bin_offset = 0;
 
118
            bool last_metadata = false;
 
119
 
 
120
            for (int i = 0; i < im_index->GetNumMetadatas(); i++)
 
121
            {
 
122
              last_metadata = (i == (im_index->GetNumMetadatas() - 1));
 
123
              res = WriteSegment<DataBinClass::META_DATA>(0, 0, im_index->GetMetadata(i), bin_offset, last_metadata);
 
124
              bin_offset += im_index->GetMetadata(i).length;
 
125
 
 
126
              if (last_metadata) {
 
127
                if(res > 0) cache_model.SetFullMetadata();
 
128
 
 
129
              } else {
 
130
                if (WritePlaceHolder(0, 0, im_index->GetPlaceHolder(i), bin_offset) <= 0) break;
 
131
                bin_offset += im_index->GetPlaceHolder(i).length();
 
132
              }
 
133
            }
 
134
          }
 
135
        }
 
136
 
 
137
        if (!eof)
 
138
        {
 
139
          for (int i = range.first; i <= range.last; i++)
 
140
          {
 
141
            WriteSegment<DataBinClass::MAIN_HEADER>(i, 0, im_index->GetMainHeader(i));
 
142
            WriteSegment<DataBinClass::TILE_HEADER>(i, 0, FileSegment::Null);
 
143
          }
 
144
 
 
145
          if(has_woi) {
 
146
            Packet packet;
 
147
            FileSegment segment;
 
148
            int bin_id, bin_offset;
 
149
            bool last_packet = false;
 
150
 
 
151
            while(data_writer && !eof) {
 
152
              packet = woi_composer.GetCurrentPacket();
 
153
 
 
154
              cout << "[packet] layer: " << packet.layer << "\tresolution: " << packet.resolution << "\ty: " << packet.precinct_xy.y << "\tx: " << packet.precinct_xy.x;
 
155
              cout << endl;
 
156
 
 
157
              segment = im_index->GetPacket(current_idx, packet, &bin_offset);
 
158
              bin_id = im_index->GetCodingParameters()->GetPrecinctDataBinId(packet);
 
159
 
 
160
              cout << "bin_id: " << bin_id << endl;
 
161
 
 
162
              last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
 
163
 
 
164
              res = WriteSegment<DataBinClass::PRECINCT>(current_idx, bin_id, segment, bin_offset, last_packet);
 
165
 
 
166
              if(res < 0) return false;
 
167
              else if(res > 0) {
 
168
                if (current_idx != range.last) current_idx++;
 
169
                else
 
170
                {
 
171
                  if(!woi_composer.GetNextPacket()) break;
 
172
                  else current_idx = range.first;
 
173
                }
 
174
              }
 
175
            }
 
176
          }
 
177
        }
 
178
 
 
179
        if(!eof) {
 
180
          data_writer.WriteEOR(EOR::WINDOW_DONE);
 
181
          end_woi_ = true;
 
182
          pending = 0;
 
183
 
 
184
        } else {
 
185
          pending -= data_writer.GetCount();
 
186
 
 
187
          if(pending <= MINIMUM_SPACE + 100) {
 
188
            data_writer.WriteEOR(EOR::BYTE_LIMIT_REACHED);
 
189
            pending = 0;
 
190
          }
 
191
        }
 
192
 
 
193
        if(!im_index->ReadUnlock(range)) {
 
194
          ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be released");
 
195
          return false;
 
196
        }
 
197
      }
 
198
 
 
199
      *len = data_writer.GetCount();
 
200
      *last = (pending <= 0);
 
201
 
 
202
      if(*last) cache_model.Pack();
 
203
 
 
204
      return data_writer;
 
205
  }
 
206
  */
 
207
 
 
208
  // Primera aproximación
 
209
  //
 
210
  // NOTA: Modificado.
 
211
  //
 
212
  /*
 
213
  bool DataBinServer::GenerateChunk(char *buff, int *len, bool *last)
 
214
  {
 
215
    int res;
 
216
 
 
217
    data_writer.SetBuffer(buff, min(pending, *len));
 
218
 
 
219
    if(pending > 0) {
 
220
      eof = false;
 
221
 
 
222
      if(!im_index->ReadLock(range)) {
 
223
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be taken for reading");
 
224
        return false;
 
225
      }
 
226
 
 
227
      if(!cache_model.IsFullMetadata())
 
228
      {
 
229
        if(im_index->GetNumMetadatas() <= 0)
 
230
          WriteSegment<DataBinClass::META_DATA>(0, 0, FileSegment::Null);
 
231
        else {
 
232
          int bin_offset = 0;
 
233
          bool last_metadata = false;
 
234
 
 
235
          for (int i = 0; i < im_index->GetNumMetadatas(); i++)
 
236
          {
 
237
            last_metadata = (i == (im_index->GetNumMetadatas() - 1));
 
238
            res = WriteSegment<DataBinClass::META_DATA>(0, 0, im_index->GetMetadata(i), bin_offset, last_metadata);
 
239
            bin_offset += im_index->GetMetadata(i).length;
 
240
 
 
241
            if (last_metadata) {
 
242
              if(res > 0) cache_model.SetFullMetadata();
 
243
 
 
244
            } else {
 
245
              if (WritePlaceHolder(0, 0, im_index->GetPlaceHolder(i), bin_offset) <= 0) break;
 
246
              bin_offset += im_index->GetPlaceHolder(i).length();
 
247
            }
 
248
          }
 
249
        }
 
250
      }
 
251
 
 
252
      if (!eof)
 
253
      {
 
254
        for (int i = range.first; i <= range.last; i++)
 
255
        {
 
256
          WriteSegment<DataBinClass::MAIN_HEADER>(i, 0, im_index->GetMainHeader(i));
 
257
          WriteSegment<DataBinClass::TILE_HEADER>(i, 0, FileSegment::Null);
 
258
        }
 
259
 
 
260
        if(has_woi) {
 
261
          Packet packet;
 
262
          FileSegment segment;
 
263
          int bin_id, bin_offset;
 
264
          bool last_packet = false;
 
265
 
 
266
          while(data_writer && !eof) {
 
267
 
 
268
                packet = woi_composer.GetCurrentPacket();
 
269
 
 
270
            cout << "[packet] layer: " << packet.layer << "\tresolution: " << packet.resolution << "\ty: " << packet.precinct_xy.y << "\tx: " << packet.precinct_xy.x;
 
271
 
 
272
                // TODO: Comprobar que este paquete no lo hemos enviado
 
273
                bool sent = false;
 
274
                for(int i = 0; i < packets_sent.size(); i++)
 
275
                {
 
276
                        if ((packets_sent.at(i).layer == packet.layer) && (packets_sent.at(i).resolution == packet.resolution) &&
 
277
                                (packets_sent.at(i).component == packet.component) && (packets_sent.at(i).precinct_xy.x == packet.precinct_xy.x) &&
 
278
                                (packets_sent.at(i).precinct_xy.y == packet.precinct_xy.y)){
 
279
 
 
280
                                cout << "\t**** Paquete ya enviado ****. packets_sent.size(): " << packets_sent.size() << endl;
 
281
 
 
282
                                sent = true;
 
283
                                break;
 
284
                        }
 
285
                }
 
286
 
 
287
                if (sent) {
 
288
 
 
289
                if (current_idx != range.last) current_idx++;
 
290
                else
 
291
                {
 
292
                  if(!woi_composer.GetNextPacket()) break;
 
293
                  else current_idx = range.first;
 
294
                }
 
295
 
 
296
                        continue;
 
297
                }
 
298
                // *****
 
299
 
 
300
            segment = im_index->GetPacket(current_idx, packet, &bin_offset);
 
301
            bin_id = im_index->GetCodingParameters()->GetPrecinctDataBinId(packet);
 
302
            last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
 
303
                res = WriteSegment<DataBinClass::PRECINCT>(current_idx, bin_id, segment, bin_offset, last_packet);
 
304
            cout << "\ncurrent_idx: " << current_idx << endl;
 
305
            cout << "bin_id: " << bin_id << endl;
 
306
            //cout << "[packet] layer: " << packet.layer << "\tresolution: " << packet.resolution << "\ty: " << packet.precinct_xy.y << "\tx: " << packet.precinct_xy.x;
 
307
                        cout << "\tsegment.offset: " << segment.offset << "\tsegment.length: " << segment.length << "\tbin_id: " << bin_id << "\tlast_packet: " << last_packet << endl;
 
308
 
 
309
            // Si hemos enviado todo el paquete completo entonces lo guardamos como enviado
 
310
            if (res > 0){
 
311
                packets_sent.push_back(packet);
 
312
                cout << "packets_sent.size(): " << packets_sent.size() << endl;
 
313
            }
 
314
 
 
315
                        if (res > 0){
 
316
                    FileSegment segmentAux;
 
317
                        Packet packetAux = packet;
 
318
                        int bin_offsetAux;
 
319
 
 
320
                    packetAux.layer++;
 
321
                if (packetAux.layer < im_index->GetCodingParameters()->num_layers)
 
322
                        segmentAux = im_index->GetPacket(current_idx, packetAux, &bin_offsetAux);
 
323
 
 
324
                        while((segmentAux.length <= 1) && (packetAux.layer < im_index->GetCodingParameters()->num_layers)){
 
325
 
 
326
                        cout << "[packetAux] layer: " << packetAux.layer << "\tresolution: " << packetAux.resolution << "\ty: " << packetAux.precinct_xy.y << "\tx: " << packetAux.precinct_xy.x;
 
327
                        cout << "\tsegmentAux.offset: " << segmentAux.offset << "\tsegmentAux.length: " << segmentAux.length << endl;
 
328
 
 
329
                        last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
 
330
                        int resAux = WriteSegment<DataBinClass::PRECINCT>(current_idx, bin_id, segmentAux, bin_offsetAux, last_packet);
 
331
 
 
332
                        // TODO: Guardar que hemos escrito los datos del paquete en el chunk
 
333
                        if (resAux > 0){
 
334
                                packets_sent.push_back(packetAux);
 
335
                                cout << "packets_sent.size(): " << packets_sent.size() << endl;
 
336
                        }
 
337
 
 
338
                        packetAux.layer++;
 
339
                        if (packetAux.layer < im_index->GetCodingParameters()->num_layers)
 
340
                                segmentAux = im_index->GetPacket(current_idx, packetAux, &bin_offsetAux);
 
341
                    }
 
342
                        }
 
343
 
 
344
            if(res < 0) return false;
 
345
            else if(res > 0) {
 
346
              if (current_idx != range.last) current_idx++;
 
347
              else
 
348
              {
 
349
                if(!woi_composer.GetNextPacket()) break;
 
350
                else current_idx = range.first;
 
351
              }
 
352
            }
 
353
          }
 
354
        }
 
355
      }
 
356
 
 
357
      if(!eof) {
 
358
        data_writer.WriteEOR(EOR::WINDOW_DONE);
 
359
        end_woi_ = true;
 
360
        pending = 0;
 
361
 
 
362
      } else {
 
363
        pending -= data_writer.GetCount();
 
364
 
 
365
        if(pending <= MINIMUM_SPACE + 100) {
 
366
          data_writer.WriteEOR(EOR::BYTE_LIMIT_REACHED);
 
367
          pending = 0;
 
368
        }
 
369
      }
 
370
 
 
371
      if(!im_index->ReadUnlock(range)) {
 
372
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be released");
 
373
        return false;
 
374
      }
 
375
    }
 
376
 
 
377
    *len = data_writer.GetCount();
 
378
    *last = (pending <= 0);
 
379
 
 
380
    if(*last) cache_model.Pack();
 
381
 
 
382
    return data_writer;
 
383
  }
 
384
  */
 
385
 
 
386
  // NOTA: Modificado
 
387
  //
 
388
  bool DataBinServer::GenerateChunk(char *buff, int *len, bool *last)
 
389
  {
 
390
    int res;
 
391
 
 
392
    data_writer.SetBuffer(buff, min(pending, *len));
 
393
 
 
394
    if(pending > 0) {
 
395
      eof = false;
 
396
 
 
397
      if(!im_index->ReadLock(range)) {
 
398
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be taken for reading");
 
399
        return false;
 
400
      }
 
401
 
 
402
      if(!cache_model.IsFullMetadata())
 
403
      {
 
404
        if(im_index->GetNumMetadatas() <= 0)
 
405
          WriteSegment<DataBinClass::META_DATA>(0, 0, FileSegment::Null);
 
406
        else {
 
407
          int bin_offset = 0;
 
408
          bool last_metadata = false;
 
409
 
 
410
          for (int i = 0; i < im_index->GetNumMetadatas(); i++)
 
411
          {
 
412
            last_metadata = (i == (im_index->GetNumMetadatas() - 1));
 
413
            res = WriteSegment<DataBinClass::META_DATA>(0, 0, im_index->GetMetadata(i), bin_offset, last_metadata);
 
414
            bin_offset += im_index->GetMetadata(i).length;
 
415
 
 
416
            if (last_metadata) {
 
417
              if(res > 0) cache_model.SetFullMetadata();
 
418
 
 
419
            } else {
 
420
              if (WritePlaceHolder(0, 0, im_index->GetPlaceHolder(i), bin_offset) <= 0) break;
 
421
              bin_offset += im_index->GetPlaceHolder(i).length();
 
422
            }
 
423
          }
 
424
        }
 
425
      }
 
426
 
 
427
      if (!eof)
 
428
      {
 
429
        for (int i = range.first; i <= range.last; i++)
 
430
        {
 
431
          WriteSegment<DataBinClass::MAIN_HEADER>(i, 0, im_index->GetMainHeader(i));
 
432
          WriteSegment<DataBinClass::TILE_HEADER>(i, 0, FileSegment::Null);
 
433
        }
 
434
 
 
435
        if(has_woi) {
 
436
          Packet packet;
 
437
          FileSegment segment;
 
438
          int bin_id, bin_offset;
 
439
          bool last_packet = false;
 
440
 
 
441
          while(data_writer && !eof) {
 
442
 
 
443
                packet = woi_composer.GetCurrentPacket();
 
444
 
 
445
            cout << "[packet] layer: " << packet.layer << "\tresolution: " << packet.resolution << "\ty: " << packet.precinct_xy.y << "\tx: " << packet.precinct_xy.x;
 
446
 
 
447
                // TODO: Comprobar que este paquete no lo hemos enviado
 
448
                bool sent = false;
 
449
                for(int i = 0; i < packets_sent.size(); i++)
 
450
                {
 
451
                        if ((packets_sent.at(i).layer == packet.layer) && (packets_sent.at(i).resolution == packet.resolution) &&
 
452
                                (packets_sent.at(i).component == packet.component) && (packets_sent.at(i).precinct_xy.x == packet.precinct_xy.x) &&
 
453
                                (packets_sent.at(i).precinct_xy.y == packet.precinct_xy.y)){
 
454
 
 
455
                                cout << "\t**** Paquete ya enviado ****. packets_sent.size(): " << packets_sent.size() << endl;
 
456
 
 
457
                                sent = true;
 
458
                                break;
 
459
                        }
 
460
                }
 
461
 
 
462
                if (sent) {
 
463
 
 
464
                if (current_idx != range.last) current_idx++;
 
465
                else
 
466
                {
 
467
                  if(!woi_composer.GetNextPacket()) break;
 
468
                  else current_idx = range.first;
 
469
                }
 
470
 
 
471
                        continue;
 
472
                }
 
473
                // *****
 
474
 
 
475
            segment = im_index->GetPacket(current_idx, packet, &bin_offset);
 
476
            bin_id = im_index->GetCodingParameters()->GetPrecinctDataBinId(packet);
 
477
            last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
 
478
 
 
479
            list_of_empty_segments.push_back(segment);
 
480
                packets_sent.push_back(packet);
 
481
                cout << "\npackets_sent.size(): " << packets_sent.size() << endl;
 
482
 
 
483
            cout << "\nbin_id: " << bin_id << endl;
 
484
            cout << "[packet] layer: " << packet.layer << "\tresolution: " << packet.resolution << "\ty: " << packet.precinct_xy.y << "\tx: " << packet.precinct_xy.x;
 
485
                        cout << "\tsegment.offset: " << segment.offset << "\tsegment.length: " << segment.length << "\tbin_id: " << bin_id << "\tlast_packet: " << last_packet << endl;
 
486
 
 
487
            FileSegment segmentAux;
 
488
                Packet packetAux = packet;
 
489
                int bin_offsetAux;
 
490
 
 
491
            packetAux.layer++;
 
492
            if (packetAux.layer < im_index->GetCodingParameters()->num_layers)
 
493
                segmentAux = im_index->GetPacket(current_idx, packetAux, &bin_offsetAux);
 
494
 
 
495
                while((segmentAux.length <= 1) && (packetAux.layer < im_index->GetCodingParameters()->num_layers)){
 
496
 
 
497
                cout << "[packetAux] layer: " << packetAux.layer << "\tresolution: " << packetAux.resolution << "\ty: " << packetAux.precinct_xy.y << "\tx: " << packetAux.precinct_xy.x;
 
498
                cout << "\tsegmentAux.offset: " << segmentAux.offset << "\tsegmentAux.length: " << segmentAux.length;
 
499
                cout << "\tbin_id: " << bin_id << "\tlast_packet: " << last_packet << endl;
 
500
 
 
501
                last_packet = (packet.layer >= (im_index->GetCodingParameters()->num_layers - 1));
 
502
 
 
503
                list_of_empty_segments.push_back(segmentAux);
 
504
                packets_sent.push_back(packetAux);
 
505
                cout << "\npackets_sent.size(): " << packets_sent.size() << endl;
 
506
 
 
507
                packetAux.layer++;
 
508
                if (packetAux.layer < im_index->GetCodingParameters()->num_layers)
 
509
                        segmentAux = im_index->GetPacket(current_idx, packetAux, &bin_offsetAux);
 
510
            }
 
511
 
 
512
                // TODO
 
513
                // Enviar la lista de segmentos
 
514
            res = WriteSegment2<DataBinClass::PRECINCT>(current_idx, bin_id, list_of_empty_segments, bin_offsetAux, last_packet);
 
515
 
 
516
                // Limpiamos la lista de segmentos
 
517
                list_of_empty_segments.clear();
 
518
 
 
519
 
 
520
            if(res < 0) return false;
 
521
            else if(res > 0) {
 
522
              if (current_idx != range.last) current_idx++;
 
523
              else
 
524
              {
 
525
                if(!woi_composer.GetNextPacket()) break;
 
526
                else current_idx = range.first;
 
527
              }
 
528
            }
 
529
          }
 
530
        }
 
531
      }
 
532
 
 
533
      if(!eof) {
 
534
        data_writer.WriteEOR(EOR::WINDOW_DONE);
 
535
        end_woi_ = true;
 
536
        pending = 0;
 
537
 
 
538
      } else {
 
539
        pending -= data_writer.GetCount();
 
540
 
 
541
        if(pending <= MINIMUM_SPACE + 100) {
 
542
          data_writer.WriteEOR(EOR::BYTE_LIMIT_REACHED);
 
543
          pending = 0;
 
544
        }
 
545
      }
 
546
 
 
547
      if(!im_index->ReadUnlock(range)) {
 
548
        ERROR("The lock of the image '" << im_index->GetPathName() << "' can not be released");
 
549
        return false;
 
550
      }
 
551
    }
 
552
 
 
553
    *len = data_writer.GetCount();
 
554
    *last = (pending <= 0);
 
555
 
 
556
    if(*last) cache_model.Pack();
 
557
 
 
558
    return data_writer;
 
559
  }
194
560
}