← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/lcl.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/lcl.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 *
19
19
 */
20
20
 
81
81
 */
82
82
typedef struct LclContext {
83
83
 
84
 
        AVCodecContext *avctx;
85
 
        AVFrame pic;
 
84
        AVCodecContext *avctx;
 
85
        AVFrame pic;
86
86
    PutBitContext pb;
87
87
 
88
88
    // Image type
152
152
    unsigned char mask = 0;
153
153
    unsigned char maskbit = 0;
154
154
    unsigned int ofs, cnt;
155
 
  
 
155
 
156
156
    while ((srclen > 0) && (destptr < destptr_end)) {
157
157
        if (maskbit == 0) {
158
158
            mask = *(srcptr++);
198
198
 */
199
199
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
200
200
{
201
 
        LclContext * const c = (LclContext *)avctx->priv_data;
202
 
        unsigned char *encoded = (unsigned char *)buf;
 
201
        LclContext * const c = (LclContext *)avctx->priv_data;
 
202
        unsigned char *encoded = (unsigned char *)buf;
203
203
    unsigned int pixel_ptr;
204
204
    int row, col;
205
205
    unsigned char *outptr;
214
214
#endif
215
215
    unsigned int len = buf_size;
216
216
 
217
 
        if(c->pic.data[0])
218
 
                avctx->release_buffer(avctx, &c->pic);
 
217
        if(c->pic.data[0])
 
218
                avctx->release_buffer(avctx, &c->pic);
219
219
 
220
 
        c->pic.reference = 0;
221
 
        c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
222
 
        if(avctx->get_buffer(avctx, &c->pic) < 0){
223
 
                av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
224
 
                return -1;
225
 
        }
 
220
        c->pic.reference = 0;
 
221
        c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
 
222
        if(avctx->get_buffer(avctx, &c->pic) < 0){
 
223
                av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
224
                return -1;
 
225
        }
226
226
 
227
227
    outptr = c->pic.data[0]; // Output image pointer
228
228
 
290
290
                c->zstream.next_in = encoded + 8;
291
291
                c->zstream.avail_in = mthread_inlen;
292
292
                c->zstream.next_out = c->decomp_buf;
293
 
                c->zstream.avail_out = c->decomp_size;    
 
293
                c->zstream.avail_out = c->decomp_size;
294
294
                zret = inflate(&(c->zstream), Z_FINISH);
295
295
                if ((zret != Z_OK) && (zret != Z_STREAM_END)) {
296
296
                    av_log(avctx, AV_LOG_ERROR, "Mthread1 inflate error: %d\n", zret);
309
309
                c->zstream.next_in = encoded + 8 + mthread_inlen;
310
310
                c->zstream.avail_in = len - mthread_inlen;
311
311
                c->zstream.next_out = c->decomp_buf + mthread_outlen;
312
 
                c->zstream.avail_out = c->decomp_size - mthread_outlen;    
 
312
                c->zstream.avail_out = c->decomp_size - mthread_outlen;
313
313
                zret = inflate(&(c->zstream), Z_FINISH);
314
314
                if ((zret != Z_OK) && (zret != Z_STREAM_END)) {
315
315
                    av_log(avctx, AV_LOG_ERROR, "Mthread2 inflate error: %d\n", zret);
358
358
                    pixel_ptr = row * width * 3;
359
359
                    yq = encoded[pixel_ptr++];
360
360
                    uqvq = encoded[pixel_ptr++];
361
 
                  uqvq+=(encoded[pixel_ptr++] << 8);
 
361
                    uqvq+=(encoded[pixel_ptr++] << 8);
362
362
                    for (col = 1; col < width; col++) {
363
363
                        encoded[pixel_ptr] = yq -= encoded[pixel_ptr];
364
364
                        uqvq -= (encoded[pixel_ptr+1] | (encoded[pixel_ptr+2]<<8));
565
565
#else
566
566
 
567
567
    init_put_bits(&c->pb, buf, buf_size);
568
 
    
 
568
 
569
569
    *p = *pict;
570
570
    p->pict_type= FF_I_TYPE;
571
571
    p->key_frame= 1;
572
 
    
 
572
 
573
573
    if(avctx->pix_fmt != PIX_FMT_BGR24){
574
574
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
575
575
        return -1;
588
588
        c->zstream.avail_in = avctx->width*3;
589
589
        zret = deflate(&(c->zstream), Z_NO_FLUSH);
590
590
        if (zret != Z_OK) {
591
 
            av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
592
 
            return -1;
 
591
            av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
 
592
            return -1;
593
593
        }
594
594
    }
595
595
    zret = deflate(&(c->zstream), Z_FINISH);
628
628
 
629
629
#ifdef CONFIG_ZLIB
630
630
    // Needed if zlib unused or init aborted before inflateInit
631
 
    memset(&(c->zstream), 0, sizeof(z_stream)); 
 
631
    memset(&(c->zstream), 0, sizeof(z_stream));
632
632
#endif
633
633
 
634
634
    if (avctx->extradata_size < 8) {
640
640
        return 1;
641
641
    }
642
642
 
643
 
    /* Check codec type */ 
 
643
    /* Check codec type */
644
644
    if (((avctx->codec_id == CODEC_ID_MSZH)  && (*((char *)avctx->extradata + 7) != CODEC_MSZH)) ||
645
645
        ((avctx->codec_id == CODEC_ID_ZLIB)  && (*((char *)avctx->extradata + 7) != CODEC_ZLIB))) {
646
646
        av_log(avctx, AV_LOG_ERROR, "Codec id and codec type mismatch. This should not happen.\n");
714
714
                    break;
715
715
                default:
716
716
                    if ((c->compression < Z_NO_COMPRESSION) || (c->compression > Z_BEST_COMPRESSION)) {
717
 
                            av_log(avctx, AV_LOG_ERROR, "Unsupported compression level for ZLIB: (%d).\n", c->compression);
 
717
                            av_log(avctx, AV_LOG_ERROR, "Unsupported compression level for ZLIB: (%d).\n", c->compression);
718
718
                        return 1;
719
719
                    }
720
720
                    av_log(avctx, AV_LOG_INFO, "Compression level for ZLIB: (%d).\n", c->compression);
736
736
            return 1;
737
737
        }
738
738
    }
739
 
  
740
 
    /* Detect flags */ 
 
739
 
 
740
    /* Detect flags */
741
741
    c->flags = *((char *)avctx->extradata + 6);
742
742
    if (c->flags & FLAG_MULTITHREAD)
743
743
        av_log(avctx, AV_LOG_INFO, "Multithread encoder flag set.\n");
788
788
#else
789
789
 
790
790
    c->avctx= avctx;
791
 
        
 
791
 
792
792
    assert(avctx->width && avctx->height);
793
 
    
 
793
 
794
794
    avctx->extradata= av_mallocz(8);
795
795
    avctx->coded_frame= &c->pic;
796
796
 
818
818
    ((uint8_t*)avctx->extradata)[6]= c->flags;
819
819
    ((uint8_t*)avctx->extradata)[7]= CODEC_ZLIB;
820
820
    c->avctx->extradata_size= 8;
821
 
    
 
821
 
822
822
    c->zstream.zalloc = Z_NULL;
823
823
    c->zstream.zfree = Z_NULL;
824
824
    c->zstream.opaque = Z_NULL;
851
851
 */
852
852
static int decode_end(AVCodecContext *avctx)
853
853
{
854
 
        LclContext * const c = (LclContext *)avctx->priv_data;
 
854
        LclContext * const c = (LclContext *)avctx->priv_data;
855
855
 
856
 
        if (c->pic.data[0])
857
 
                avctx->release_buffer(avctx, &c->pic);
 
856
        if (c->pic.data[0])
 
857
                avctx->release_buffer(avctx, &c->pic);
858
858
#ifdef CONFIG_ZLIB
859
859
    inflateEnd(&(c->zstream));
860
860
#endif
861
861
 
862
 
        return 0;
 
862
        return 0;
863
863
}
864
864
 
865
865
 
878
878
#ifdef CONFIG_ZLIB
879
879
    deflateEnd(&(c->zstream));
880
880
#endif
881
 
    
 
881
 
882
882
    return 0;
883
883
}
884
884
 
885
885
AVCodec mszh_decoder = {
886
 
        "mszh",
887
 
        CODEC_TYPE_VIDEO,
888
 
        CODEC_ID_MSZH,
889
 
        sizeof(LclContext),
890
 
        decode_init,
891
 
        NULL,
892
 
        decode_end,
893
 
        decode_frame,
894
 
        CODEC_CAP_DR1,
 
886
        "mszh",
 
887
        CODEC_TYPE_VIDEO,
 
888
        CODEC_ID_MSZH,
 
889
        sizeof(LclContext),
 
890
        decode_init,
 
891
        NULL,
 
892
        decode_end,
 
893
        decode_frame,
 
894
        CODEC_CAP_DR1,
895
895
};
896
896
 
897
897
 
898
898
AVCodec zlib_decoder = {
899
 
        "zlib",
900
 
        CODEC_TYPE_VIDEO,
901
 
        CODEC_ID_ZLIB,
902
 
        sizeof(LclContext),
903
 
        decode_init,
904
 
        NULL,
905
 
        decode_end,
906
 
        decode_frame,
907
 
        CODEC_CAP_DR1,
 
899
        "zlib",
 
900
        CODEC_TYPE_VIDEO,
 
901
        CODEC_ID_ZLIB,
 
902
        sizeof(LclContext),
 
903
        decode_init,
 
904
        NULL,
 
905
        decode_end,
 
906
        decode_frame,
 
907
        CODEC_CAP_DR1,
908
908
};
909
909
 
910
910
#ifdef CONFIG_ENCODERS