X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=coders%2Fuyvy.c;h=f4283b9b47b1edc813e136994c6e376c6b4940ac;hb=77b33baacfae08c3794dd19df1862fb645ebe265;hp=d30cb93fde0afe033a4952cb189b113748628592;hpb=16af1cbdffcc02e7239d432e5fb51734fcf9f9ff;p=imagemagick diff --git a/coders/uyvy.c b/coders/uyvy.c index d30cb93fd..f4283b9b4 100644 --- a/coders/uyvy.c +++ b/coders/uyvy.c @@ -17,7 +17,7 @@ % July 1992 % % % % % -% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization % +% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization % % dedicated to making software imaging solutions freely available. % % % % You may not use this file except in compliance with the License. You may % @@ -39,31 +39,32 @@ /* Include declarations. */ -#include "magick/studio.h" -#include "magick/blob.h" -#include "magick/blob-private.h" -#include "magick/cache.h" -#include "magick/color.h" -#include "magick/colorspace.h" -#include "magick/exception.h" -#include "magick/exception-private.h" -#include "magick/image.h" -#include "magick/image-private.h" -#include "magick/list.h" -#include "magick/magick.h" -#include "magick/memory_.h" -#include "magick/monitor.h" -#include "magick/monitor-private.h" -#include "magick/quantum-private.h" -#include "magick/static.h" -#include "magick/string_.h" -#include "magick/module.h" +#include "MagickCore/studio.h" +#include "MagickCore/blob.h" +#include "MagickCore/blob-private.h" +#include "MagickCore/cache.h" +#include "MagickCore/color.h" +#include "MagickCore/colorspace.h" +#include "MagickCore/exception.h" +#include "MagickCore/exception-private.h" +#include "MagickCore/image.h" +#include "MagickCore/image-private.h" +#include "MagickCore/list.h" +#include "MagickCore/magick.h" +#include "MagickCore/memory_.h" +#include "MagickCore/monitor.h" +#include "MagickCore/monitor-private.h" +#include "MagickCore/pixel-accessor.h" +#include "MagickCore/quantum-private.h" +#include "MagickCore/static.h" +#include "MagickCore/string_.h" +#include "MagickCore/module.h" /* Forward declarations. */ static MagickBooleanType - WriteUYVYImage(const ImageInfo *,Image *); + WriteUYVYImage(const ImageInfo *,Image *,ExceptionInfo *); /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -91,7 +92,6 @@ static MagickBooleanType % % o exception: return any errors or warnings in this structure. % -% */ static Image *ReadUYVYImage(const ImageInfo *image_info, ExceptionInfo *exception) @@ -99,20 +99,17 @@ static Image *ReadUYVYImage(const ImageInfo *image_info, Image *image; - long - y; - MagickBooleanType status; - register long + register ssize_t x; - register PixelPacket + register Quantum *q; - register long - i; + ssize_t + y; unsigned char u, @@ -130,7 +127,7 @@ static Image *ReadUYVYImage(const ImageInfo *image_info, image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); - image=AcquireImage(image_info); + image=AcquireImage(image_info,exception); if ((image->columns == 0) || (image->rows == 0)) ThrowReaderException(OptionError,"MustSpecifyImageSize"); if ((image->columns % 2) != 0) @@ -139,13 +136,9 @@ static Image *ReadUYVYImage(const ImageInfo *image_info, status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) return((Image *) NULL); - for (i=0; i < image->offset; i++) - if (ReadBlobByte(image) == EOF) - { - ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", - image->filename); - break; - } + if (DiscardBlobBytes(image,image->offset) == MagickFalse) + ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", + image->filename); image->depth=8; if (image_info->ping != MagickFalse) { @@ -155,33 +148,34 @@ static Image *ReadUYVYImage(const ImageInfo *image_info, /* Accumulate UYVY, then unpack into two pixels. */ - for (y=0; y < (long) image->rows; y++) + for (y=0; y < (ssize_t) image->rows; y++) { q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); - if (q == (PixelPacket *) NULL) + if (q == (Quantum *) NULL) break; - for (x=0; x < (long) (image->columns >> 1); x++) + for (x=0; x < (ssize_t) (image->columns >> 1); x++) { u=(unsigned char) ReadBlobByte(image); y1=(unsigned char) ReadBlobByte(image); v=(unsigned char) ReadBlobByte(image); y2=(unsigned char) ReadBlobByte(image); - q->red=ScaleCharToQuantum(y1); - q->green=ScaleCharToQuantum(u); - q->blue=ScaleCharToQuantum(v); - q++; - q->red=ScaleCharToQuantum(y2); - q->green=ScaleCharToQuantum(u); - q->blue=ScaleCharToQuantum(v); - q++; + SetPixelRed(image,ScaleCharToQuantum(y1),q); + SetPixelGreen(image,ScaleCharToQuantum(u),q); + SetPixelBlue(image,ScaleCharToQuantum(v),q); + q+=GetPixelChannels(image); + SetPixelRed(image,ScaleCharToQuantum(y2),q); + SetPixelGreen(image,ScaleCharToQuantum(u),q); + SetPixelBlue(image,ScaleCharToQuantum(v),q); + q+=GetPixelChannels(image); } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; - status=SetImageProgress(image,LoadImageTag,y,image->rows); + status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, + image->rows); if (status == MagickFalse) break; } - image->colorspace=YCbCrColorspace; + SetImageColorspace(image,YCbCrColorspace,exception); if (EOFBlob(image) != MagickFalse) ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", image->filename); @@ -209,10 +203,10 @@ static Image *ReadUYVYImage(const ImageInfo *image_info, % % The format of the RegisterUYVYImage method is: % -% unsigned long RegisterUYVYImage(void) +% size_t RegisterUYVYImage(void) % */ -ModuleExport unsigned long RegisterUYVYImage(void) +ModuleExport size_t RegisterUYVYImage(void) { MagickInfo *entry; @@ -281,38 +275,39 @@ ModuleExport void UnregisterUYVYImage(void) % The format of the WriteUYVYImage method is: % % MagickBooleanType WriteUYVYImage(const ImageInfo *image_info, -% Image *image) +% Image *image,ExceptionInfo *exception) % % A description of each parameter follows. % % o image_info: the image info. % -% o image: The image. -% Implicit assumption: number of columns is even. +% o image: The image. Implicit assumption: number of columns is even. +% +% o exception: return any errors or warnings in this structure. % */ static MagickBooleanType WriteUYVYImage(const ImageInfo *image_info, - Image *image) + Image *image,ExceptionInfo *exception) { - MagickPixelPacket + PixelInfo pixel; Image *uyvy_image; - long - y; - MagickBooleanType full, status; - register const PixelPacket + register const Quantum *p; - register long + register ssize_t x; + ssize_t + y; + /* Open output image file. */ @@ -324,41 +319,45 @@ static MagickBooleanType WriteUYVYImage(const ImageInfo *image_info, (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); if ((image->columns % 2) != 0) image->columns++; - status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); + assert(exception != (ExceptionInfo *) NULL); + assert(exception->signature == MagickSignature); + status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception); if (status == MagickFalse) return(status); /* Accumulate two pixels, then output. */ - uyvy_image=CloneImage(image,0,0,MagickTrue,&image->exception); + uyvy_image=CloneImage(image,0,0,MagickTrue,exception); if (uyvy_image == (Image *) NULL) - ThrowWriterException(ResourceLimitError,image->exception.reason); - (void) TransformImageColorspace(uyvy_image,YCbCrColorspace); + return(MagickFalse); + (void) TransformImageColorspace(uyvy_image,YCbCrColorspace,exception); full=MagickFalse; - (void) ResetMagickMemory(&pixel,0,sizeof(MagickPixelPacket)); - for (y=0; y < (long) image->rows; y++) + (void) ResetMagickMemory(&pixel,0,sizeof(PixelInfo)); + for (y=0; y < (ssize_t) image->rows; y++) { - p=GetVirtualPixels(uyvy_image,0,y,image->columns,1,&image->exception); - if (p == (const PixelPacket *) NULL) + p=GetVirtualPixels(uyvy_image,0,y,image->columns,1,exception); + if (p == (const Quantum *) NULL) break; - for (x=0; x < (long) image->columns; x++) + for (x=0; x < (ssize_t) image->columns; x++) { if (full != MagickFalse) { - pixel.green=(pixel.green+p->green)/2; - pixel.blue=(pixel.blue+p->blue)/2; + pixel.green=(pixel.green+GetPixelGreen(uyvy_image,p))/2; + pixel.blue=(pixel.blue+GetPixelBlue(uyvy_image,p))/2; (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.green)); (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red)); (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.blue)); - (void) WriteBlobByte(image,ScaleQuantumToChar(p->red)); + (void) WriteBlobByte(image,ScaleQuantumToChar( + GetPixelRed(uyvy_image,p))); } - pixel.red=(double) p->red; - pixel.green=(double) p->green; - pixel.blue=(double) p->blue; + pixel.red=(double) GetPixelRed(uyvy_image,p); + pixel.green=(double) GetPixelGreen(uyvy_image,p); + pixel.blue=(double) GetPixelBlue(uyvy_image,p); full=full == MagickFalse ? MagickTrue : MagickFalse; - p++; + p+=GetPixelChannels(uyvy_image); } - status=SetImageProgress(image,LoadImageTag,y,image->rows); + status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, + image->rows); if (status == MagickFalse) break; }