2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13 % Read/Write Raw BGR Image Format %
20 % Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % http://www.imagemagick.org/script/license.php %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
42 #include "magick/studio.h"
43 #include "magick/blob.h"
44 #include "magick/blob-private.h"
45 #include "magick/cache.h"
46 #include "magick/colorspace.h"
47 #include "magick/constitute.h"
48 #include "magick/exception.h"
49 #include "magick/exception-private.h"
50 #include "magick/image.h"
51 #include "magick/image-private.h"
52 #include "magick/list.h"
53 #include "magick/magick.h"
54 #include "magick/memory_.h"
55 #include "magick/monitor.h"
56 #include "magick/monitor-private.h"
57 #include "magick/pixel-private.h"
58 #include "magick/quantum-private.h"
59 #include "magick/static.h"
60 #include "magick/statistic.h"
61 #include "magick/string_.h"
62 #include "magick/module.h"
63 #include "magick/utility.h"
68 static MagickBooleanType
69 WriteBGRImage(const ImageInfo *,Image *);
72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76 % R e a d B G R I m a g e %
80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
82 % ReadBGRImage() reads an image of raw BGR, or BGRA samples and returns
83 % it. It allocates the memory necessary for the new Image structure and
84 % returns a pointer to the new image.
86 % The format of the ReadBGRImage method is:
88 % Image *ReadBGRImage(const ImageInfo *image_info,
89 % ExceptionInfo *exception)
91 % A description of each parameter follows:
93 % o image_info: the image info.
95 % o exception: return any errors or warnings in this structure.
98 static Image *ReadBGRImage(const ImageInfo *image_info,
99 ExceptionInfo *exception)
133 assert(image_info != (const ImageInfo *) NULL);
134 assert(image_info->signature == MagickSignature);
135 if (image_info->debug != MagickFalse)
136 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
137 image_info->filename);
138 assert(exception != (ExceptionInfo *) NULL);
139 assert(exception->signature == MagickSignature);
140 image=AcquireImage(image_info);
141 if ((image->columns == 0) || (image->rows == 0))
142 ThrowReaderException(OptionError,"MustSpecifyImageSize");
143 image->colorspace=RGBColorspace;
144 if (image_info->interlace != PartitionInterlace)
146 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
147 if (status == MagickFalse)
149 image=DestroyImageList(image);
150 return((Image *) NULL);
152 if (DiscardBlobBytes(image,image->offset) == MagickFalse)
153 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
157 Create virtual canvas to support cropping (i.e. image.rgb[100x100+10+20]).
159 canvas_image=CloneImage(image,image->extract_info.width,1,MagickFalse,
161 (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod);
162 quantum_info=AcquireQuantumInfo(image_info,canvas_image);
163 if (quantum_info == (QuantumInfo *) NULL)
164 ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
165 pixels=GetQuantumPixels(quantum_info);
166 quantum_type=BGRQuantum;
167 if (LocaleCompare(image_info->magick,"BGRA") == 0)
169 quantum_type=BGRAQuantum;
170 image->matte=MagickTrue;
172 if (image_info->number_scenes != 0)
173 while (image->scene < image_info->scene)
179 length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
180 for (y=0; y < (ssize_t) image->rows; y++)
182 count=ReadBlob(image,length,pixels);
183 if (count != (ssize_t) length)
193 Read pixels to virtual canvas image then push to image.
195 if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
196 if (image->scene >= (image_info->scene+image_info->number_scenes-1))
198 image->colorspace=RGBColorspace;
199 switch (image_info->interlace)
205 No interlacing: BGRBGRBGRBGRBGRBGR...
209 length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
210 count=ReadBlob(image,length,pixels);
212 for (y=0; y < (ssize_t) image->extract_info.height; y++)
214 register const PixelPacket
223 if (count != (ssize_t) length)
225 ThrowFileException(exception,CorruptImageError,
226 "UnexpectedEndOfFile",image->filename);
229 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
231 if (q == (PixelPacket *) NULL)
233 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
234 quantum_info,quantum_type,pixels,exception);
235 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
237 if (((y-image->extract_info.y) >= 0) &&
238 ((y-image->extract_info.y) < (ssize_t) image->rows))
240 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
241 canvas_image->columns,1,exception);
242 q=QueueAuthenticPixels(image,0,y-image->extract_info.y,
243 image->columns,1,exception);
244 if ((p == (const PixelPacket *) NULL) ||
245 (q == (PixelPacket *) NULL))
247 for (x=0; x < (ssize_t) image->columns; x++)
249 SetRedPixelComponent(q,GetRedPixelComponent(p));
250 SetGreenPixelComponent(q,GetGreenPixelComponent(p));
251 SetBluePixelComponent(q,GetBluePixelComponent(p));
252 SetOpacityPixelComponent(q,OpaqueOpacity);
253 if (image->matte != MagickFalse)
254 SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
258 if (SyncAuthenticPixels(image,exception) == MagickFalse)
261 if (image->previous == (Image *) NULL)
263 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
265 if (status == MagickFalse)
268 count=ReadBlob(image,length,pixels);
284 Line interlacing: BBB...GGG...RRR...RRR...GGG...BBB...
288 length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
289 count=ReadBlob(image,length,pixels);
291 for (y=0; y < (ssize_t) image->extract_info.height; y++)
293 register const PixelPacket
302 if (count != (ssize_t) length)
304 ThrowFileException(exception,CorruptImageError,
305 "UnexpectedEndOfFile",image->filename);
308 for (i=0; i < (ssize_t) (image->matte != MagickFalse ? 4 : 3); i++)
310 quantum_type=quantum_types[i];
311 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
313 if (q == (PixelPacket *) NULL)
315 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
316 quantum_info,quantum_type,pixels,exception);
317 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
319 if (((y-image->extract_info.y) >= 0) &&
320 ((y-image->extract_info.y) < (ssize_t) image->rows))
322 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
323 0,canvas_image->columns,1,exception);
324 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
325 image->columns,1,exception);
326 if ((p == (const PixelPacket *) NULL) ||
327 (q == (PixelPacket *) NULL))
329 for (x=0; x < (ssize_t) image->columns; x++)
331 switch (quantum_type)
335 SetRedPixelComponent(q,GetRedPixelComponent(p));
340 SetGreenPixelComponent(q,GetGreenPixelComponent(p));
345 SetBluePixelComponent(q,GetBluePixelComponent(p));
350 SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
355 SetAlphaPixelComponent(q,GetAlphaPixelComponent(p));
364 if (SyncAuthenticPixels(image,exception) == MagickFalse)
367 count=ReadBlob(image,length,pixels);
369 if (image->previous == (Image *) NULL)
371 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
373 if (status == MagickFalse)
382 Plane interlacing: RRRRRR...GGGGGG...BBBBBB...
386 length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
387 count=ReadBlob(image,length,pixels);
389 for (y=0; y < (ssize_t) image->extract_info.height; y++)
391 register const PixelPacket
400 if (count != (ssize_t) length)
402 ThrowFileException(exception,CorruptImageError,
403 "UnexpectedEndOfFile",image->filename);
406 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
408 if (q == (PixelPacket *) NULL)
410 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
411 quantum_info,RedQuantum,pixels,exception);
412 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
414 if (((y-image->extract_info.y) >= 0) &&
415 ((y-image->extract_info.y) < (ssize_t) image->rows))
417 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
418 canvas_image->columns,1,exception);
419 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
420 image->columns,1,exception);
421 if ((p == (const PixelPacket *) NULL) ||
422 (q == (PixelPacket *) NULL))
424 for (x=0; x < (ssize_t) image->columns; x++)
426 SetRedPixelComponent(q,GetRedPixelComponent(p));
430 if (SyncAuthenticPixels(image,exception) == MagickFalse)
433 count=ReadBlob(image,length,pixels);
435 if (image->previous == (Image *) NULL)
437 status=SetImageProgress(image,LoadImageTag,1,6);
438 if (status == MagickFalse)
441 for (y=0; y < (ssize_t) image->extract_info.height; y++)
443 register const PixelPacket
452 if (count != (ssize_t) length)
454 ThrowFileException(exception,CorruptImageError,
455 "UnexpectedEndOfFile",image->filename);
458 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
460 if (q == (PixelPacket *) NULL)
462 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
463 quantum_info,GreenQuantum,pixels,exception);
464 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
466 if (((y-image->extract_info.y) >= 0) &&
467 ((y-image->extract_info.y) < (ssize_t) image->rows))
469 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
470 canvas_image->columns,1,exception);
471 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
472 image->columns,1,exception);
473 if ((p == (const PixelPacket *) NULL) ||
474 (q == (PixelPacket *) NULL))
476 for (x=0; x < (ssize_t) image->columns; x++)
478 SetGreenPixelComponent(q,GetGreenPixelComponent(p));
482 if (SyncAuthenticPixels(image,exception) == MagickFalse)
485 count=ReadBlob(image,length,pixels);
487 if (image->previous == (Image *) NULL)
489 status=SetImageProgress(image,LoadImageTag,2,6);
490 if (status == MagickFalse)
493 for (y=0; y < (ssize_t) image->extract_info.height; y++)
495 register const PixelPacket
504 if (count != (ssize_t) length)
506 ThrowFileException(exception,CorruptImageError,
507 "UnexpectedEndOfFile",image->filename);
510 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
512 if (q == (PixelPacket *) NULL)
514 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
515 quantum_info,BlueQuantum,pixels,exception);
516 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
518 if (((y-image->extract_info.y) >= 0) &&
519 ((y-image->extract_info.y) < (ssize_t) image->rows))
521 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
522 canvas_image->columns,1,exception);
523 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
524 image->columns,1,exception);
525 if ((p == (const PixelPacket *) NULL) ||
526 (q == (PixelPacket *) NULL))
528 for (x=0; x < (ssize_t) image->columns; x++)
530 SetBluePixelComponent(q,GetBluePixelComponent(p));
534 if (SyncAuthenticPixels(image,exception) == MagickFalse)
537 count=ReadBlob(image,length,pixels);
539 if (image->previous == (Image *) NULL)
541 status=SetImageProgress(image,LoadImageTag,3,6);
542 if (status == MagickFalse)
545 if (image->previous == (Image *) NULL)
547 status=SetImageProgress(image,LoadImageTag,4,6);
548 if (status == MagickFalse)
551 if (image->matte != MagickFalse)
553 for (y=0; y < (ssize_t) image->extract_info.height; y++)
555 register const PixelPacket
564 if (count != (ssize_t) length)
566 ThrowFileException(exception,CorruptImageError,
567 "UnexpectedEndOfFile",image->filename);
570 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
572 if (q == (PixelPacket *) NULL)
574 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
575 quantum_info,AlphaQuantum,pixels,exception);
576 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
578 if (((y-image->extract_info.y) >= 0) &&
579 ((y-image->extract_info.y) < (ssize_t) image->rows))
581 p=GetVirtualPixels(canvas_image,
582 canvas_image->extract_info.x,0,canvas_image->columns,1,
584 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
585 image->columns,1,exception);
586 if ((p == (const PixelPacket *) NULL) ||
587 (q == (PixelPacket *) NULL))
589 for (x=0; x < (ssize_t) image->columns; x++)
591 SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
595 if (SyncAuthenticPixels(image,exception) == MagickFalse)
598 count=ReadBlob(image,length,pixels);
600 if (image->previous == (Image *) NULL)
602 status=SetImageProgress(image,LoadImageTag,5,6);
603 if (status == MagickFalse)
607 if (image->previous == (Image *) NULL)
609 status=SetImageProgress(image,LoadImageTag,6,6);
610 if (status == MagickFalse)
615 case PartitionInterlace:
618 Partition interlacing: BBBBBB..., GGGGGG..., RRRRRR...
620 AppendImageFormat("B",image->filename);
621 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
622 if (status == MagickFalse)
624 canvas_image=DestroyImageList(canvas_image);
625 image=DestroyImageList(image);
626 return((Image *) NULL);
628 if (DiscardBlobBytes(image,image->offset) == MagickFalse)
629 ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
631 length=GetQuantumExtent(canvas_image,quantum_info,BlueQuantum);
632 for (i=0; i < (ssize_t) scene; i++)
633 for (y=0; y < (ssize_t) image->extract_info.height; y++)
634 if (ReadBlob(image,length,pixels) != (ssize_t) length)
636 ThrowFileException(exception,CorruptImageError,
637 "UnexpectedEndOfFile",image->filename);
640 count=ReadBlob(image,length,pixels);
641 for (y=0; y < (ssize_t) image->extract_info.height; y++)
643 register const PixelPacket
652 if (count != (ssize_t) length)
654 ThrowFileException(exception,CorruptImageError,
655 "UnexpectedEndOfFile",image->filename);
658 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
660 if (q == (PixelPacket *) NULL)
662 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
663 quantum_info,BlueQuantum,pixels,exception);
664 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
666 if (((y-image->extract_info.y) >= 0) &&
667 ((y-image->extract_info.y) < (ssize_t) image->rows))
669 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
670 canvas_image->columns,1,exception);
671 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
672 image->columns,1,exception);
673 if ((p == (const PixelPacket *) NULL) ||
674 (q == (PixelPacket *) NULL))
676 for (x=0; x < (ssize_t) image->columns; x++)
678 SetRedPixelComponent(q,GetRedPixelComponent(p));
682 if (SyncAuthenticPixels(image,exception) == MagickFalse)
685 count=ReadBlob(image,length,pixels);
687 if (image->previous == (Image *) NULL)
689 status=SetImageProgress(image,LoadImageTag,1,5);
690 if (status == MagickFalse)
693 (void) CloseBlob(image);
694 AppendImageFormat("G",image->filename);
695 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
696 if (status == MagickFalse)
698 canvas_image=DestroyImageList(canvas_image);
699 image=DestroyImageList(image);
700 return((Image *) NULL);
702 length=GetQuantumExtent(canvas_image,quantum_info,GreenQuantum);
703 for (i=0; i < (ssize_t) scene; i++)
704 for (y=0; y < (ssize_t) image->extract_info.height; y++)
705 if (ReadBlob(image,length,pixels) != (ssize_t) length)
707 ThrowFileException(exception,CorruptImageError,
708 "UnexpectedEndOfFile",image->filename);
711 count=ReadBlob(image,length,pixels);
712 for (y=0; y < (ssize_t) image->extract_info.height; y++)
714 register const PixelPacket
723 if (count != (ssize_t) length)
725 ThrowFileException(exception,CorruptImageError,
726 "UnexpectedEndOfFile",image->filename);
729 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
731 if (q == (PixelPacket *) NULL)
733 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
734 quantum_info,GreenQuantum,pixels,exception);
735 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
737 if (((y-image->extract_info.y) >= 0) &&
738 ((y-image->extract_info.y) < (ssize_t) image->rows))
740 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
741 canvas_image->columns,1,exception);
742 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
743 image->columns,1,exception);
744 if ((p == (const PixelPacket *) NULL) ||
745 (q == (PixelPacket *) NULL))
747 for (x=0; x < (ssize_t) image->columns; x++)
749 SetGreenPixelComponent(q,GetGreenPixelComponent(p));
753 if (SyncAuthenticPixels(image,exception) == MagickFalse)
756 count=ReadBlob(image,length,pixels);
758 if (image->previous == (Image *) NULL)
760 status=SetImageProgress(image,LoadImageTag,2,5);
761 if (status == MagickFalse)
764 (void) CloseBlob(image);
765 AppendImageFormat("R",image->filename);
766 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
767 if (status == MagickFalse)
769 canvas_image=DestroyImageList(canvas_image);
770 image=DestroyImageList(image);
771 return((Image *) NULL);
773 length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
774 for (i=0; i < (ssize_t) scene; i++)
775 for (y=0; y < (ssize_t) image->extract_info.height; y++)
776 if (ReadBlob(image,length,pixels) != (ssize_t) length)
778 ThrowFileException(exception,CorruptImageError,
779 "UnexpectedEndOfFile",image->filename);
782 count=ReadBlob(image,length,pixels);
783 for (y=0; y < (ssize_t) image->extract_info.height; y++)
785 register const PixelPacket
794 if (count != (ssize_t) length)
796 ThrowFileException(exception,CorruptImageError,
797 "UnexpectedEndOfFile",image->filename);
800 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
802 if (q == (PixelPacket *) NULL)
804 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
805 quantum_info,RedQuantum,pixels,exception);
806 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
808 if (((y-image->extract_info.y) >= 0) &&
809 ((y-image->extract_info.y) < (ssize_t) image->rows))
811 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
812 canvas_image->columns,1,exception);
813 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
814 image->columns,1,exception);
815 if ((p == (const PixelPacket *) NULL) ||
816 (q == (PixelPacket *) NULL))
818 for (x=0; x < (ssize_t) image->columns; x++)
820 SetBluePixelComponent(q,GetBluePixelComponent(p));
824 if (SyncAuthenticPixels(image,exception) == MagickFalse)
827 count=ReadBlob(image,length,pixels);
829 if (image->previous == (Image *) NULL)
831 status=SetImageProgress(image,LoadImageTag,3,5);
832 if (status == MagickFalse)
835 if (image->matte != MagickFalse)
837 (void) CloseBlob(image);
838 AppendImageFormat("A",image->filename);
839 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
840 if (status == MagickFalse)
842 canvas_image=DestroyImageList(canvas_image);
843 image=DestroyImageList(image);
844 return((Image *) NULL);
846 length=GetQuantumExtent(canvas_image,quantum_info,AlphaQuantum);
847 for (i=0; i < (ssize_t) scene; i++)
848 for (y=0; y < (ssize_t) image->extract_info.height; y++)
849 if (ReadBlob(image,length,pixels) != (ssize_t) length)
851 ThrowFileException(exception,CorruptImageError,
852 "UnexpectedEndOfFile",image->filename);
855 count=ReadBlob(image,length,pixels);
856 for (y=0; y < (ssize_t) image->extract_info.height; y++)
858 register const PixelPacket
867 if (count != (ssize_t) length)
869 ThrowFileException(exception,CorruptImageError,
870 "UnexpectedEndOfFile",image->filename);
873 q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
875 if (q == (PixelPacket *) NULL)
877 length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
878 quantum_info,BlueQuantum,pixels,exception);
879 if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
881 if (((y-image->extract_info.y) >= 0) &&
882 ((y-image->extract_info.y) < (ssize_t) image->rows))
884 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
885 0,canvas_image->columns,1,exception);
886 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
887 image->columns,1,exception);
888 if ((p == (const PixelPacket *) NULL) ||
889 (q == (PixelPacket *) NULL))
891 for (x=0; x < (ssize_t) image->columns; x++)
893 SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
897 if (SyncAuthenticPixels(image,exception) == MagickFalse)
900 count=ReadBlob(image,length,pixels);
902 if (image->previous == (Image *) NULL)
904 status=SetImageProgress(image,LoadImageTag,4,5);
905 if (status == MagickFalse)
909 (void) CloseBlob(image);
910 if (image->previous == (Image *) NULL)
912 status=SetImageProgress(image,LoadImageTag,5,5);
913 if (status == MagickFalse)
919 SetQuantumImageType(image,quantum_type);
921 Proceed to next image.
923 if (image_info->number_scenes != 0)
924 if (image->scene >= (image_info->scene+image_info->number_scenes-1))
926 if (count == (ssize_t) length)
929 Allocate next image structure.
931 AcquireNextImage(image_info,image);
932 if (GetNextImageInList(image) == (Image *) NULL)
934 image=DestroyImageList(image);
935 return((Image *) NULL);
937 image=SyncNextImageInList(image);
938 status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
940 if (status == MagickFalse)
944 } while (count == (ssize_t) length);
945 quantum_info=DestroyQuantumInfo(quantum_info);
946 InheritException(&image->exception,&canvas_image->exception);
947 canvas_image=DestroyImage(canvas_image);
948 (void) CloseBlob(image);
949 return(GetFirstImageInList(image));
953 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
957 % R e g i s t e r B G R I m a g e %
961 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
963 % RegisterBGRImage() adds attributes for the BGR image format to
964 % the list of supported formats. The attributes include the image format
965 % tag, a method to read and/or write the format, whether the format
966 % supports the saving of more than one frame to the same file or blob,
967 % whether the format supports native in-memory I/O, and a brief
968 % description of the format.
970 % The format of the RegisterBGRImage method is:
972 % size_t RegisterBGRImage(void)
975 ModuleExport size_t RegisterBGRImage(void)
980 entry=SetMagickInfo("BGR");
981 entry->decoder=(DecodeImageHandler *) ReadBGRImage;
982 entry->encoder=(EncodeImageHandler *) WriteBGRImage;
983 entry->raw=MagickTrue;
984 entry->endian_support=MagickTrue;
985 entry->description=ConstantString("Raw blue, green, and red samples");
986 entry->module=ConstantString("BGR");
987 (void) RegisterMagickInfo(entry);
988 entry=SetMagickInfo("BGRA");
989 entry->decoder=(DecodeImageHandler *) ReadBGRImage;
990 entry->encoder=(EncodeImageHandler *) WriteBGRImage;
991 entry->raw=MagickTrue;
992 entry->endian_support=MagickTrue;
993 entry->description=ConstantString("Raw blue, green, red, and alpha samples");
994 entry->module=ConstantString("BGR");
995 (void) RegisterMagickInfo(entry);
996 return(MagickImageCoderSignature);
1000 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1004 % U n r e g i s t e r B G R I m a g e %
1008 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1010 % UnregisterBGRImage() removes format registrations made by the BGR module
1011 % from the list of supported formats.
1013 % The format of the UnregisterBGRImage method is:
1015 % UnregisterBGRImage(void)
1018 ModuleExport void UnregisterBGRImage(void)
1020 (void) UnregisterMagickInfo("BGRA");
1021 (void) UnregisterMagickInfo("BGR");
1025 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1029 % W r i t e B G R I m a g e %
1033 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1035 % WriteBGRImage() writes an image to a file in the BGR or BGRA
1036 % rasterfile format.
1038 % The format of the WriteBGRImage method is:
1040 % MagickBooleanType WriteBGRImage(const ImageInfo *image_info,
1043 % A description of each parameter follows.
1045 % o image_info: the image info.
1047 % o image: The image.
1050 static MagickBooleanType WriteBGRImage(const ImageInfo *image_info,
1076 Allocate memory for pixels.
1078 assert(image_info != (const ImageInfo *) NULL);
1079 assert(image_info->signature == MagickSignature);
1080 assert(image != (Image *) NULL);
1081 assert(image->signature == MagickSignature);
1082 if (image->debug != MagickFalse)
1083 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1084 if (image_info->interlace != PartitionInterlace)
1087 Open output image file.
1089 status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
1090 if (status == MagickFalse)
1093 quantum_type=BGRQuantum;
1094 if (LocaleCompare(image_info->magick,"BGRA") == 0)
1096 quantum_type=BGRAQuantum;
1097 image->matte=MagickTrue;
1103 Convert MIFF to BGR raster pixels.
1105 if (image->colorspace != RGBColorspace)
1106 (void) TransformImageColorspace(image,RGBColorspace);
1107 if ((LocaleCompare(image_info->magick,"BGRA") == 0) &&
1108 (image->matte == MagickFalse))
1109 (void) SetImageAlphaChannel(image,ResetAlphaChannel);
1110 quantum_info=AcquireQuantumInfo(image_info,image);
1111 if (quantum_info == (QuantumInfo *) NULL)
1112 ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1113 pixels=GetQuantumPixels(quantum_info);
1114 switch (image_info->interlace)
1120 No interlacing: BGRBGRBGRBGRBGRBGR...
1122 for (y=0; y < (ssize_t) image->rows; y++)
1124 register const PixelPacket
1127 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1128 if (p == (const PixelPacket *) NULL)
1130 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1131 quantum_info,quantum_type,pixels,&image->exception);
1132 count=WriteBlob(image,length,pixels);
1133 if (count != (ssize_t) length)
1135 if (image->previous == (Image *) NULL)
1137 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1139 if (status == MagickFalse)
1148 Line interlacing: BBB...GGG...RRR...RRR...GGG...BBB...
1150 for (y=0; y < (ssize_t) image->rows; y++)
1152 register const PixelPacket
1155 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1156 if (p == (const PixelPacket *) NULL)
1158 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1159 quantum_info,BlueQuantum,pixels,&image->exception);
1160 count=WriteBlob(image,length,pixels);
1161 if (count != (ssize_t) length)
1163 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1164 quantum_info,GreenQuantum,pixels,&image->exception);
1165 count=WriteBlob(image,length,pixels);
1166 if (count != (ssize_t) length)
1168 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1169 quantum_info,RedQuantum,pixels,&image->exception);
1170 count=WriteBlob(image,length,pixels);
1171 if (count != (ssize_t) length)
1173 if (quantum_type == BGRAQuantum)
1175 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1176 quantum_info,AlphaQuantum,pixels,&image->exception);
1177 count=WriteBlob(image,length,pixels);
1178 if (count != (ssize_t) length)
1181 if (image->previous == (Image *) NULL)
1183 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1185 if (status == MagickFalse)
1191 case PlaneInterlace:
1194 Plane interlacing: RRRRRR...GGGGGG...BBBBBB...
1196 for (y=0; y < (ssize_t) image->rows; y++)
1198 register const PixelPacket
1201 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1202 if (p == (const PixelPacket *) NULL)
1204 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1205 quantum_info,RedQuantum,pixels,&image->exception);
1206 count=WriteBlob(image,length,pixels);
1207 if (count != (ssize_t) length)
1210 if (image->previous == (Image *) NULL)
1212 status=SetImageProgress(image,SaveImageTag,1,6);
1213 if (status == MagickFalse)
1216 for (y=0; y < (ssize_t) image->rows; y++)
1218 register const PixelPacket
1221 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1222 if (p == (const PixelPacket *) NULL)
1224 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1225 quantum_info,GreenQuantum,pixels,&image->exception);
1226 count=WriteBlob(image,length,pixels);
1227 if (count != (ssize_t) length)
1230 if (image->previous == (Image *) NULL)
1232 status=SetImageProgress(image,SaveImageTag,2,6);
1233 if (status == MagickFalse)
1236 for (y=0; y < (ssize_t) image->rows; y++)
1238 register const PixelPacket
1241 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1242 if (p == (const PixelPacket *) NULL)
1244 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1245 quantum_info,BlueQuantum,pixels,&image->exception);
1246 count=WriteBlob(image,length,pixels);
1247 if (count != (ssize_t) length)
1250 if (image->previous == (Image *) NULL)
1252 status=SetImageProgress(image,SaveImageTag,3,6);
1253 if (status == MagickFalse)
1256 if (quantum_type == BGRAQuantum)
1258 for (y=0; y < (ssize_t) image->rows; y++)
1260 register const PixelPacket
1263 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1264 if (p == (const PixelPacket *) NULL)
1266 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1267 quantum_info,AlphaQuantum,pixels,&image->exception);
1268 count=WriteBlob(image,length,pixels);
1269 if (count != (ssize_t) length)
1272 if (image->previous == (Image *) NULL)
1274 status=SetImageProgress(image,SaveImageTag,5,6);
1275 if (status == MagickFalse)
1279 if (image_info->interlace == PartitionInterlace)
1280 (void) CopyMagickString(image->filename,image_info->filename,
1282 if (image->previous == (Image *) NULL)
1284 status=SetImageProgress(image,SaveImageTag,6,6);
1285 if (status == MagickFalse)
1290 case PartitionInterlace:
1293 Partition interlacing: BBBBBB..., GGGGGG..., RRRRRR...
1295 AppendImageFormat("B",image->filename);
1296 status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1297 AppendBinaryBlobMode,&image->exception);
1298 if (status == MagickFalse)
1300 for (y=0; y < (ssize_t) image->rows; y++)
1302 register const PixelPacket
1305 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1306 if (p == (const PixelPacket *) NULL)
1308 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1309 quantum_info,BlueQuantum,pixels,&image->exception);
1310 count=WriteBlob(image,length,pixels);
1311 if (count != (ssize_t) length)
1314 if (image->previous == (Image *) NULL)
1316 status=SetImageProgress(image,SaveImageTag,1,6);
1317 if (status == MagickFalse)
1320 (void) CloseBlob(image);
1321 AppendImageFormat("G",image->filename);
1322 status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1323 AppendBinaryBlobMode,&image->exception);
1324 if (status == MagickFalse)
1326 for (y=0; y < (ssize_t) image->rows; y++)
1328 register const PixelPacket
1331 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1332 if (p == (const PixelPacket *) NULL)
1334 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1335 quantum_info,GreenQuantum,pixels,&image->exception);
1336 count=WriteBlob(image,length,pixels);
1337 if (count != (ssize_t) length)
1340 if (image->previous == (Image *) NULL)
1342 status=SetImageProgress(image,SaveImageTag,2,6);
1343 if (status == MagickFalse)
1346 (void) CloseBlob(image);
1347 AppendImageFormat("R",image->filename);
1348 status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1349 AppendBinaryBlobMode,&image->exception);
1350 if (status == MagickFalse)
1352 for (y=0; y < (ssize_t) image->rows; y++)
1354 register const PixelPacket
1357 p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
1358 if (p == (const PixelPacket *) NULL)
1360 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1361 quantum_info,RedQuantum,pixels,&image->exception);
1362 count=WriteBlob(image,length,pixels);
1363 if (count != (ssize_t) length)
1366 if (image->previous == (Image *) NULL)
1368 status=SetImageProgress(image,SaveImageTag,3,6);
1369 if (status == MagickFalse)
1372 (void) CloseBlob(image);
1373 if (quantum_type == BGRAQuantum)
1375 (void) CloseBlob(image);
1376 AppendImageFormat("A",image->filename);
1377 status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1378 AppendBinaryBlobMode,&image->exception);
1379 if (status == MagickFalse)
1381 for (y=0; y < (ssize_t) image->rows; y++)
1383 register const PixelPacket
1386 p=GetVirtualPixels(image,0,y,image->columns,1,
1388 if (p == (const PixelPacket *) NULL)
1390 length=ExportQuantumPixels(image,(const CacheView *) NULL,
1391 quantum_info,AlphaQuantum,pixels,&image->exception);
1392 count=WriteBlob(image,length,pixels);
1393 if (count != (ssize_t) length)
1396 if (image->previous == (Image *) NULL)
1398 status=SetImageProgress(image,SaveImageTag,5,6);
1399 if (status == MagickFalse)
1403 (void) CloseBlob(image);
1404 (void) CopyMagickString(image->filename,image_info->filename,
1406 if (image->previous == (Image *) NULL)
1408 status=SetImageProgress(image,SaveImageTag,6,6);
1409 if (status == MagickFalse)
1415 quantum_info=DestroyQuantumInfo(quantum_info);
1416 if (GetNextImageInList(image) == (Image *) NULL)
1418 image=SyncNextImageInList(image);
1419 status=SetImageProgress(image,SaveImagesTag,scene++,
1420 GetImageListLength(image));
1421 if (status == MagickFalse)
1423 } while (image_info->adjoin != MagickFalse);
1424 (void) CloseBlob(image);