FFmpeg: libavcodec/lcldec.c Source File

00001 /*
00002  * LCL (LossLess Codec Library) Codec
00003  * Copyright (c) 2002-2004 Roberto Togni
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00041 #include <stdio.h>
00042 #include <stdlib.h>
00043 
00044 #include "libavutil/mem.h"
00045 #include "avcodec.h"
00046 #include "bytestream.h"
00047 #include "internal.h"
00048 #include "lcl.h"
00049 
00050 #if CONFIG_ZLIB_DECODER
00051 #include <zlib.h>
00052 #endif
00053 
00054 /*
00055  * Decoder context
00056  */
00057 typedef struct LclDecContext {
00058     AVFrame pic;
00059 
00060     // Image type
00061     int imgtype;
00062     // Compression type
00063     int compression;
00064     // Flags
00065     int flags;
00066     // Decompressed data size
00067     unsigned int decomp_size;
00068     // Decompression buffer
00069     unsigned char* decomp_buf;
00070 #if CONFIG_ZLIB_DECODER
00071     z_stream zstream;
00072 #endif
00073 } LclDecContext;
00074 
00075 
00080 static unsigned int mszh_decomp(const unsigned char * srcptr, int srclen, unsigned char * destptr, unsigned int destsize)
00081 {
00082     unsigned char *destptr_bak = destptr;
00083     unsigned char *destptr_end = destptr + destsize;
00084     const unsigned char *srcptr_end = srcptr + srclen;
00085     unsigned mask = *srcptr++;
00086     unsigned maskbit = 0x80;
00087 
00088     while (srcptr < srcptr_end && destptr < destptr_end) {
00089         if (!(mask & maskbit)) {
00090             memcpy(destptr, srcptr, 4);
00091             destptr += 4;
00092             srcptr += 4;
00093         } else {
00094             unsigned ofs = bytestream_get_le16(&srcptr);
00095             unsigned cnt = (ofs >> 11) + 1;
00096             ofs &= 0x7ff;
00097             ofs = FFMIN(ofs, destptr - destptr_bak);
00098             cnt *= 4;
00099             cnt = FFMIN(cnt, destptr_end - destptr);
00100             if (ofs) {
00101                 av_memcpy_backptr(destptr, ofs, cnt);
00102             } else {
00103                 // Not known what the correct behaviour is, but
00104                 // this at least avoids uninitialized data.
00105                 memset(destptr, 0, cnt);
00106             }
00107             destptr += cnt;
00108         }
00109         maskbit >>= 1;
00110         if (!maskbit) {
00111             mask = *srcptr++;
00112             while (!mask) {
00113                 if (destptr_end - destptr < 32 || srcptr_end - srcptr < 32) break;
00114                 memcpy(destptr, srcptr, 32);
00115                 destptr += 32;
00116                 srcptr += 32;
00117                 mask = *srcptr++;
00118             }
00119             maskbit = 0x80;
00120         }
00121     }
00122 
00123     return destptr - destptr_bak;
00124 }
00125 
00126 
00127 #if CONFIG_ZLIB_DECODER
00128 
00135 static int zlib_decomp(AVCodecContext *avctx, const uint8_t *src, int src_len, int offset, int expected)
00136 {
00137     LclDecContext *c = avctx->priv_data;
00138     int zret = inflateReset(&c->zstream);
00139     if (zret != Z_OK) {
00140         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
00141         return -1;
00142     }
00143     c->zstream.next_in = src;
00144     c->zstream.avail_in = src_len;
00145     c->zstream.next_out = c->decomp_buf + offset;
00146     c->zstream.avail_out = c->decomp_size - offset;
00147     zret = inflate(&c->zstream, Z_FINISH);
00148     if (zret != Z_OK && zret != Z_STREAM_END) {
00149         av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", zret);
00150         return -1;
00151     }
00152     if (expected != (unsigned int)c->zstream.total_out) {
00153         av_log(avctx, AV_LOG_ERROR, "Decoded size differs (%d != %lu)\n",
00154                expected, c->zstream.total_out);
00155         return -1;
00156     }
00157     return c->zstream.total_out;
00158 }
00159 #endif
00160 
00161 
00162 /*
00163  *
00164  * Decode a frame
00165  *
00166  */
00167 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
00168 {
00169     const uint8_t *buf = avpkt->data;
00170     int buf_size = avpkt->size;
00171     LclDecContext * const c = avctx->priv_data;
00172     unsigned char *encoded = (unsigned char *)buf;
00173     unsigned int pixel_ptr;
00174     int row, col;
00175     unsigned char *outptr;
00176     uint8_t *y_out, *u_out, *v_out;
00177     unsigned int width = avctx->width; // Real image width
00178     unsigned int height = avctx->height; // Real image height
00179     unsigned int mszh_dlen;
00180     unsigned char yq, y1q, uq, vq;
00181     int uqvq;
00182     unsigned int mthread_inlen, mthread_outlen;
00183     unsigned int len = buf_size;
00184 
00185     if(c->pic.data[0])
00186         avctx->release_buffer(avctx, &c->pic);
00187 
00188     c->pic.reference = 0;
00189     c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
00190     if(ff_get_buffer(avctx, &c->pic) < 0){
00191         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00192         return -1;
00193     }
00194 
00195     outptr = c->pic.data[0]; // Output image pointer
00196 
00197     /* Decompress frame */
00198     switch (avctx->codec_id) {
00199     case AV_CODEC_ID_MSZH:
00200         switch (c->compression) {
00201         case COMP_MSZH:
00202             if (c->imgtype == IMGTYPE_RGB24 && len == width * height * 3) {
00203                 ;
00204             } else if (c->flags & FLAG_MULTITHREAD) {
00205                 mthread_inlen = AV_RL32(encoded);
00206                 mthread_inlen = FFMIN(mthread_inlen, len - 8);
00207                 mthread_outlen = AV_RL32(encoded+4);
00208                 mthread_outlen = FFMIN(mthread_outlen, c->decomp_size);
00209                 mszh_dlen = mszh_decomp(encoded + 8, mthread_inlen, c->decomp_buf, c->decomp_size);
00210                 if (mthread_outlen != mszh_dlen) {
00211                     av_log(avctx, AV_LOG_ERROR, "Mthread1 decoded size differs (%d != %d)\n",
00212                            mthread_outlen, mszh_dlen);
00213                     return -1;
00214                 }
00215                 mszh_dlen = mszh_decomp(encoded + 8 + mthread_inlen, len - 8 - mthread_inlen,
00216                                         c->decomp_buf + mthread_outlen, c->decomp_size - mthread_outlen);
00217                 if (mthread_outlen != mszh_dlen) {
00218                     av_log(avctx, AV_LOG_ERROR, "Mthread2 decoded size differs (%d != %d)\n",
00219                            mthread_outlen, mszh_dlen);
00220                     return -1;
00221                 }
00222                 encoded = c->decomp_buf;
00223                 len = c->decomp_size;
00224             } else {
00225                 mszh_dlen = mszh_decomp(encoded, len, c->decomp_buf, c->decomp_size);
00226                 if (c->decomp_size != mszh_dlen) {
00227                     av_log(avctx, AV_LOG_ERROR, "Decoded size differs (%d != %d)\n",
00228                            c->decomp_size, mszh_dlen);
00229                     return -1;
00230                 }
00231                 encoded = c->decomp_buf;
00232                 len = mszh_dlen;
00233             }
00234             break;
00235         case COMP_MSZH_NOCOMP: {
00236             int bppx2;
00237             switch (c->imgtype) {
00238             case IMGTYPE_YUV111:
00239             case IMGTYPE_RGB24:
00240                 bppx2 = 6;
00241                 break;
00242             case IMGTYPE_YUV422:
00243             case IMGTYPE_YUV211:
00244                 bppx2 = 4;
00245                 break;
00246             case IMGTYPE_YUV411:
00247             case IMGTYPE_YUV420:
00248                 bppx2 = 3;
00249                 break;
00250             default:
00251                 bppx2 = 0; // will error out below
00252                 break;
00253             }
00254             if (len < ((width * height * bppx2) >> 1))
00255                 return AVERROR_INVALIDDATA;
00256             break;
00257         }
00258         default:
00259             av_log(avctx, AV_LOG_ERROR, "BUG! Unknown MSZH compression in frame decoder.\n");
00260             return -1;
00261         }
00262         break;
00263 #if CONFIG_ZLIB_DECODER
00264     case AV_CODEC_ID_ZLIB:
00265         /* Using the original dll with normal compression (-1) and RGB format
00266          * gives a file with ZLIB fourcc, but frame is really uncompressed.
00267          * To be sure that's true check also frame size */
00268         if (c->compression == COMP_ZLIB_NORMAL && c->imgtype == IMGTYPE_RGB24 &&
00269             len == width * height * 3) {
00270             if (c->flags & FLAG_PNGFILTER) {
00271                 memcpy(c->decomp_buf, encoded, len);
00272                 encoded = c->decomp_buf;
00273             } else {
00274                 break;
00275             }
00276         } else if (c->flags & FLAG_MULTITHREAD) {
00277             int ret;
00278             mthread_inlen = AV_RL32(encoded);
00279             mthread_inlen = FFMIN(mthread_inlen, len - 8);
00280             mthread_outlen = AV_RL32(encoded+4);
00281             mthread_outlen = FFMIN(mthread_outlen, c->decomp_size);
00282             ret = zlib_decomp(avctx, encoded + 8, mthread_inlen, 0, mthread_outlen);
00283             if (ret < 0) return ret;
00284             ret = zlib_decomp(avctx, encoded + 8 + mthread_inlen, len - 8 - mthread_inlen,
00285                               mthread_outlen, mthread_outlen);
00286             if (ret < 0) return ret;
00287         } else {
00288             int ret = zlib_decomp(avctx, encoded, len, 0, c->decomp_size);
00289             if (ret < 0) return ret;
00290         }
00291         encoded = c->decomp_buf;
00292         len = c->decomp_size;
00293         break;
00294 #endif
00295     default:
00296         av_log(avctx, AV_LOG_ERROR, "BUG! Unknown codec in frame decoder compression switch.\n");
00297         return -1;
00298     }
00299 
00300 
00301     /* Apply PNG filter */
00302     if (avctx->codec_id == AV_CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER)) {
00303         switch (c->imgtype) {
00304         case IMGTYPE_YUV111:
00305         case IMGTYPE_RGB24:
00306             for (row = 0; row < height; row++) {
00307                 pixel_ptr = row * width * 3;
00308                 yq = encoded[pixel_ptr++];
00309                 uqvq = AV_RL16(encoded+pixel_ptr);
00310                 pixel_ptr += 2;
00311                 for (col = 1; col < width; col++) {
00312                     encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
00313                     uqvq -= AV_RL16(encoded+pixel_ptr+1);
00314                     AV_WL16(encoded+pixel_ptr+1, uqvq);
00315                     pixel_ptr += 3;
00316                 }
00317             }
00318             break;
00319         case IMGTYPE_YUV422:
00320             for (row = 0; row < height; row++) {
00321                 pixel_ptr = row * width * 2;
00322                 yq = uq = vq =0;
00323                 for (col = 0; col < width/4; col++) {
00324                     encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
00325                     encoded[pixel_ptr+1] = yq -= encoded[pixel_ptr+1];
00326                     encoded[pixel_ptr+2] = yq -= encoded[pixel_ptr+2];
00327                     encoded[pixel_ptr+3] = yq -= encoded[pixel_ptr+3];
00328                     encoded[pixel_ptr+4] = uq -= encoded[pixel_ptr+4];
00329                     encoded[pixel_ptr+5] = uq -= encoded[pixel_ptr+5];
00330                     encoded[pixel_ptr+6] = vq -= encoded[pixel_ptr+6];
00331                     encoded[pixel_ptr+7] = vq -= encoded[pixel_ptr+7];
00332                     pixel_ptr += 8;
00333                 }
00334             }
00335             break;
00336         case IMGTYPE_YUV411:
00337             for (row = 0; row < height; row++) {
00338                 pixel_ptr = row * width / 2 * 3;
00339                 yq = uq = vq =0;
00340                 for (col = 0; col < width/4; col++) {
00341                     encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
00342                     encoded[pixel_ptr+1] = yq -= encoded[pixel_ptr+1];
00343                     encoded[pixel_ptr+2] = yq -= encoded[pixel_ptr+2];
00344                     encoded[pixel_ptr+3] = yq -= encoded[pixel_ptr+3];
00345                     encoded[pixel_ptr+4] = uq -= encoded[pixel_ptr+4];
00346                     encoded[pixel_ptr+5] = vq -= encoded[pixel_ptr+5];
00347                     pixel_ptr += 6;
00348                 }
00349             }
00350             break;
00351         case IMGTYPE_YUV211:
00352             for (row = 0; row < height; row++) {
00353                 pixel_ptr = row * width * 2;
00354                 yq = uq = vq =0;
00355                 for (col = 0; col < width/2; col++) {
00356                     encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
00357                     encoded[pixel_ptr+1] = yq -= encoded[pixel_ptr+1];
00358                     encoded[pixel_ptr+2] = uq -= encoded[pixel_ptr+2];
00359                     encoded[pixel_ptr+3] = vq -= encoded[pixel_ptr+3];
00360                     pixel_ptr += 4;
00361                 }
00362             }
00363             break;
00364         case IMGTYPE_YUV420:
00365             for (row = 0; row < height/2; row++) {
00366                 pixel_ptr = row * width * 3;
00367                 yq = y1q = uq = vq =0;
00368                 for (col = 0; col < width/2; col++) {
00369                     encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
00370                     encoded[pixel_ptr+1] = yq -= encoded[pixel_ptr+1];
00371                     encoded[pixel_ptr+2] = y1q -= encoded[pixel_ptr+2];
00372                     encoded[pixel_ptr+3] = y1q -= encoded[pixel_ptr+3];
00373                     encoded[pixel_ptr+4] = uq -= encoded[pixel_ptr+4];
00374                     encoded[pixel_ptr+5] = vq -= encoded[pixel_ptr+5];
00375                     pixel_ptr += 6;
00376                 }
00377             }
00378             break;
00379         default:
00380             av_log(avctx, AV_LOG_ERROR, "BUG! Unknown imagetype in pngfilter switch.\n");
00381             return -1;
00382         }
00383     }
00384 
00385     /* Convert colorspace */
00386     y_out = c->pic.data[0] + (height - 1) * c->pic.linesize[0];
00387     u_out = c->pic.data[1] + (height - 1) * c->pic.linesize[1];
00388     v_out = c->pic.data[2] + (height - 1) * c->pic.linesize[2];
00389     switch (c->imgtype) {
00390     case IMGTYPE_YUV111:
00391         for (row = 0; row < height; row++) {
00392             for (col = 0; col < width; col++) {
00393                 y_out[col] = *encoded++;
00394                 u_out[col] = *encoded++ + 128;
00395                 v_out[col] = *encoded++ + 128;
00396             }
00397             y_out -= c->pic.linesize[0];
00398             u_out -= c->pic.linesize[1];
00399             v_out -= c->pic.linesize[2];
00400         }
00401         break;
00402     case IMGTYPE_YUV422:
00403         for (row = 0; row < height; row++) {
00404             for (col = 0; col < width - 3; col += 4) {
00405                 memcpy(y_out + col, encoded, 4);
00406                 encoded += 4;
00407                 u_out[ col >> 1     ] = *encoded++ + 128;
00408                 u_out[(col >> 1) + 1] = *encoded++ + 128;
00409                 v_out[ col >> 1     ] = *encoded++ + 128;
00410                 v_out[(col >> 1) + 1] = *encoded++ + 128;
00411             }
00412             y_out -= c->pic.linesize[0];
00413             u_out -= c->pic.linesize[1];
00414             v_out -= c->pic.linesize[2];
00415         }
00416         break;
00417     case IMGTYPE_RGB24:
00418         for (row = height - 1; row >= 0; row--) {
00419             pixel_ptr = row * c->pic.linesize[0];
00420             memcpy(outptr + pixel_ptr, encoded, 3 * width);
00421             encoded += 3 * width;
00422         }
00423         break;
00424     case IMGTYPE_YUV411:
00425         for (row = 0; row < height; row++) {
00426             for (col = 0; col < width - 3; col += 4) {
00427                 memcpy(y_out + col, encoded, 4);
00428                 encoded += 4;
00429                 u_out[col >> 2] = *encoded++ + 128;
00430                 v_out[col >> 2] = *encoded++ + 128;
00431             }
00432             y_out -= c->pic.linesize[0];
00433             u_out -= c->pic.linesize[1];
00434             v_out -= c->pic.linesize[2];
00435         }
00436         break;
00437     case IMGTYPE_YUV211:
00438         for (row = 0; row < height; row++) {
00439             for (col = 0; col < width - 1; col += 2) {
00440                 memcpy(y_out + col, encoded, 2);
00441                 encoded += 2;
00442                 u_out[col >> 1] = *encoded++ + 128;
00443                 v_out[col >> 1] = *encoded++ + 128;
00444             }
00445             y_out -= c->pic.linesize[0];
00446             u_out -= c->pic.linesize[1];
00447             v_out -= c->pic.linesize[2];
00448         }
00449         break;
00450     case IMGTYPE_YUV420:
00451         u_out = c->pic.data[1] + ((height >> 1) - 1) * c->pic.linesize[1];
00452         v_out = c->pic.data[2] + ((height >> 1) - 1) * c->pic.linesize[2];
00453         for (row = 0; row < height - 1; row += 2) {
00454             for (col = 0; col < width - 1; col += 2) {
00455                 memcpy(y_out + col, encoded, 2);
00456                 encoded += 2;
00457                 memcpy(y_out + col - c->pic.linesize[0], encoded, 2);
00458                 encoded += 2;
00459                 u_out[col >> 1] = *encoded++ + 128;
00460                 v_out[col >> 1] = *encoded++ + 128;
00461             }
00462             y_out -= c->pic.linesize[0] << 1;
00463             u_out -= c->pic.linesize[1];
00464             v_out -= c->pic.linesize[2];
00465         }
00466         break;
00467     default:
00468         av_log(avctx, AV_LOG_ERROR, "BUG! Unknown imagetype in image decoder.\n");
00469         return -1;
00470     }
00471 
00472     *got_frame = 1;
00473     *(AVFrame*)data = c->pic;
00474 
00475     /* always report that the buffer was completely consumed */
00476     return buf_size;
00477 }
00478 
00479 /*
00480  *
00481  * Init lcl decoder
00482  *
00483  */
00484 static av_cold int decode_init(AVCodecContext *avctx)
00485 {
00486     LclDecContext * const c = avctx->priv_data;
00487     unsigned int basesize = avctx->width * avctx->height;
00488     unsigned int max_basesize = FFALIGN(avctx->width,  4) *
00489                                 FFALIGN(avctx->height, 4);
00490     unsigned int max_decomp_size;
00491 
00492     avcodec_get_frame_defaults(&c->pic);
00493     if (avctx->extradata_size < 8) {
00494         av_log(avctx, AV_LOG_ERROR, "Extradata size too small.\n");
00495         return AVERROR_INVALIDDATA;
00496     }
00497 
00498     /* Check codec type */
00499     if ((avctx->codec_id == AV_CODEC_ID_MSZH  && avctx->extradata[7] != CODEC_MSZH) ||
00500         (avctx->codec_id == AV_CODEC_ID_ZLIB  && avctx->extradata[7] != CODEC_ZLIB)) {
00501         av_log(avctx, AV_LOG_ERROR, "Codec id and codec type mismatch. This should not happen.\n");
00502     }
00503 
00504     /* Detect image type */
00505     switch (c->imgtype = avctx->extradata[4]) {
00506     case IMGTYPE_YUV111:
00507         c->decomp_size = basesize * 3;
00508         max_decomp_size = max_basesize * 3;
00509         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
00510         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 1:1:1.\n");
00511         break;
00512     case IMGTYPE_YUV422:
00513         c->decomp_size = basesize * 2;
00514         max_decomp_size = max_basesize * 2;
00515         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
00516         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 4:2:2.\n");
00517         break;
00518     case IMGTYPE_RGB24:
00519         c->decomp_size = basesize * 3;
00520         max_decomp_size = max_basesize * 3;
00521         avctx->pix_fmt = AV_PIX_FMT_BGR24;
00522         av_log(avctx, AV_LOG_DEBUG, "Image type is RGB 24.\n");
00523         break;
00524     case IMGTYPE_YUV411:
00525         c->decomp_size = basesize / 2 * 3;
00526         max_decomp_size = max_basesize / 2 * 3;
00527         avctx->pix_fmt = AV_PIX_FMT_YUV411P;
00528         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 4:1:1.\n");
00529         break;
00530     case IMGTYPE_YUV211:
00531         c->decomp_size = basesize * 2;
00532         max_decomp_size = max_basesize * 2;
00533         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
00534         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 2:1:1.\n");
00535         break;
00536     case IMGTYPE_YUV420:
00537         c->decomp_size = basesize / 2 * 3;
00538         max_decomp_size = max_basesize / 2 * 3;
00539         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
00540         av_log(avctx, AV_LOG_DEBUG, "Image type is YUV 4:2:0.\n");
00541         break;
00542     default:
00543         av_log(avctx, AV_LOG_ERROR, "Unsupported image format %d.\n", c->imgtype);
00544         return AVERROR_INVALIDDATA;
00545     }
00546 
00547     /* Detect compression method */
00548     c->compression = (int8_t)avctx->extradata[5];
00549     switch (avctx->codec_id) {
00550     case AV_CODEC_ID_MSZH:
00551         switch (c->compression) {
00552         case COMP_MSZH:
00553             av_log(avctx, AV_LOG_DEBUG, "Compression enabled.\n");
00554             break;
00555         case COMP_MSZH_NOCOMP:
00556             c->decomp_size = 0;
00557             av_log(avctx, AV_LOG_DEBUG, "No compression.\n");
00558             break;
00559         default:
00560             av_log(avctx, AV_LOG_ERROR, "Unsupported compression format for MSZH (%d).\n", c->compression);
00561             return AVERROR_INVALIDDATA;
00562         }
00563         break;
00564 #if CONFIG_ZLIB_DECODER
00565     case AV_CODEC_ID_ZLIB:
00566         switch (c->compression) {
00567         case COMP_ZLIB_HISPEED:
00568             av_log(avctx, AV_LOG_DEBUG, "High speed compression.\n");
00569             break;
00570         case COMP_ZLIB_HICOMP:
00571             av_log(avctx, AV_LOG_DEBUG, "High compression.\n");
00572             break;
00573         case COMP_ZLIB_NORMAL:
00574             av_log(avctx, AV_LOG_DEBUG, "Normal compression.\n");
00575             break;
00576         default:
00577             if (c->compression < Z_NO_COMPRESSION || c->compression > Z_BEST_COMPRESSION) {
00578                 av_log(avctx, AV_LOG_ERROR, "Unsupported compression level for ZLIB: (%d).\n", c->compression);
00579                 return AVERROR_INVALIDDATA;
00580             }
00581             av_log(avctx, AV_LOG_DEBUG, "Compression level for ZLIB: (%d).\n", c->compression);
00582         }
00583         break;
00584 #endif
00585     default:
00586         av_log(avctx, AV_LOG_ERROR, "BUG! Unknown codec in compression switch.\n");
00587         return AVERROR_INVALIDDATA;
00588     }
00589 
00590     /* Allocate decompression buffer */
00591     if (c->decomp_size) {
00592         if ((c->decomp_buf = av_malloc(max_decomp_size)) == NULL) {
00593             av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
00594             return AVERROR(ENOMEM);
00595         }
00596     }
00597 
00598     /* Detect flags */
00599     c->flags = avctx->extradata[6];
00600     if (c->flags & FLAG_MULTITHREAD)
00601         av_log(avctx, AV_LOG_DEBUG, "Multithread encoder flag set.\n");
00602     if (c->flags & FLAG_NULLFRAME)
00603         av_log(avctx, AV_LOG_DEBUG, "Nullframe insertion flag set.\n");
00604     if (avctx->codec_id == AV_CODEC_ID_ZLIB && (c->flags & FLAG_PNGFILTER))
00605         av_log(avctx, AV_LOG_DEBUG, "PNG filter flag set.\n");
00606     if (c->flags & FLAGMASK_UNUSED)
00607         av_log(avctx, AV_LOG_ERROR, "Unknown flag set (%d).\n", c->flags);
00608 
00609     /* If needed init zlib */
00610 #if CONFIG_ZLIB_DECODER
00611     if (avctx->codec_id == AV_CODEC_ID_ZLIB) {
00612         int zret;
00613         c->zstream.zalloc = Z_NULL;
00614         c->zstream.zfree = Z_NULL;
00615         c->zstream.opaque = Z_NULL;
00616         zret = inflateInit(&c->zstream);
00617         if (zret != Z_OK) {
00618             av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
00619             av_freep(&c->decomp_buf);
00620             return AVERROR_UNKNOWN;
00621         }
00622     }
00623 #endif
00624 
00625     return 0;
00626 }
00627 
00628 /*
00629  *
00630  * Uninit lcl decoder
00631  *
00632  */
00633 static av_cold int decode_end(AVCodecContext *avctx)
00634 {
00635     LclDecContext * const c = avctx->priv_data;
00636 
00637     av_freep(&c->decomp_buf);
00638     if (c->pic.data[0])
00639         avctx->release_buffer(avctx, &c->pic);
00640 #if CONFIG_ZLIB_DECODER
00641     if (avctx->codec_id == AV_CODEC_ID_ZLIB)
00642         inflateEnd(&c->zstream);
00643 #endif
00644 
00645     return 0;
00646 }
00647 
00648 #if CONFIG_MSZH_DECODER
00649 AVCodec ff_mszh_decoder = {
00650     .name           = "mszh",
00651     .type           = AVMEDIA_TYPE_VIDEO,
00652     .id             = AV_CODEC_ID_MSZH,
00653     .priv_data_size = sizeof(LclDecContext),
00654     .init           = decode_init,
00655     .close          = decode_end,
00656     .decode         = decode_frame,
00657     .capabilities   = CODEC_CAP_DR1,
00658     .long_name      = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"),
00659 };
00660 #endif
00661 
00662 #if CONFIG_ZLIB_DECODER
00663 AVCodec ff_zlib_decoder = {
00664     .name           = "zlib",
00665     .type           = AVMEDIA_TYPE_VIDEO,
00666     .id             = AV_CODEC_ID_ZLIB,
00667     .priv_data_size = sizeof(LclDecContext),
00668     .init           = decode_init,
00669     .close          = decode_end,
00670     .decode         = decode_frame,
00671     .capabilities   = CODEC_CAP_DR1,
00672     .long_name      = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
00673 };
00674 #endif