← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/rv10.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/rv10.c
40
40
 
41
41
#define DC_VLC_BITS 14 //FIXME find a better solution
42
42
 
 
43
typedef struct RVDecContext {
 
44
    MpegEncContext m;
 
45
    int sub_id;
 
46
} RVDecContext;
 
47
 
43
48
static const uint16_t rv_lum_code[256] =
44
49
{
45
50
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
186
191
 
187
192
static VLC rv_dc_lum, rv_dc_chrom;
188
193
 
189
 
int rv_decode_dc(MpegEncContext *s, int n)
 
194
int ff_rv_decode_dc(MpegEncContext *s, int n)
190
195
{
191
196
    int code;
192
197
 
293
298
    return mb_count;
294
299
}
295
300
 
296
 
static int rv20_decode_picture_header(MpegEncContext *s)
 
301
static int rv20_decode_picture_header(RVDecContext *rv)
297
302
{
 
303
    MpegEncContext *s = &rv->m;
298
304
    int seq, mb_pos, i;
299
305
    int rpr_bits;
300
306
 
325
331
        return -1;
326
332
    }
327
333
 
328
 
    if(RV_GET_MINOR_VER(s->avctx->sub_id) >= 2)
 
334
    if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
329
335
        s->loop_filter = get_bits1(&s->gb);
330
336
 
331
 
    if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1)
 
337
    if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
332
338
        seq = get_bits(&s->gb, 8) << 7;
333
339
    else
334
340
        seq = get_bits(&s->gb, 13) << 2;
356
362
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
357
363
            if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
358
364
                return -1;
359
 
            MPV_common_end(s);
 
365
            ff_MPV_common_end(s);
360
366
            avcodec_set_dimensions(s->avctx, new_w, new_h);
361
367
            s->width  = new_w;
362
368
            s->height = new_h;
363
 
            if (MPV_common_init(s) < 0)
 
369
            if (ff_MPV_common_init(s) < 0)
364
370
                return -1;
365
371
        }
366
372
 
372
378
 
373
379
    mb_pos = ff_h263_decode_mba(s);
374
380
 
375
 
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
376
381
    seq |= s->time &~0x7FFF;
377
382
    if(seq - s->time >  0x4000) seq -= 0x8000;
378
383
    if(seq - s->time < -0x4000) seq += 0x8000;
391
396
            ff_mpeg4_init_direct_mv(s);
392
397
        }
393
398
    }
394
 
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
395
 
/*for(i=0; i<32; i++){
396
 
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
397
 
}
398
 
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 
399
 
399
400
    s->no_rounding= get_bits1(&s->gb);
400
401
 
401
 
    if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
 
402
    if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
402
403
        skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
403
404
 
404
405
    s->f_code = 1;
408
409
//    s->obmc=1;
409
410
//    s->umvplus=1;
410
411
    s->modified_quant=1;
411
 
    if(!s->avctx->lowres)
412
 
        s->loop_filter=1;
 
412
    s->loop_filter=1;
413
413
 
414
414
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
415
415
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
423
423
 
424
424
static av_cold int rv10_decode_init(AVCodecContext *avctx)
425
425
{
426
 
    MpegEncContext *s = avctx->priv_data;
 
426
    RVDecContext  *rv = avctx->priv_data;
 
427
    MpegEncContext *s = &rv->m;
427
428
    static int done=0;
428
429
    int major_ver, minor_ver, micro_ver;
429
430
 
432
433
        return -1;
433
434
    }
434
435
 
435
 
    MPV_decode_defaults(s);
 
436
    ff_MPV_decode_defaults(s);
436
437
 
437
438
    s->avctx= avctx;
438
439
    s->out_format = FMT_H263;
443
444
    s->orig_height= s->height = avctx->coded_height;
444
445
 
445
446
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
446
 
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
 
447
    rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
447
448
 
448
 
    major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
449
 
    minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
450
 
    micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
 
449
    major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 
450
    minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 
451
    micro_ver = RV_GET_MICRO_VER(rv->sub_id);
451
452
 
452
453
    s->low_delay = 1;
453
454
    switch (major_ver) {
462
463
        }
463
464
        break;
464
465
    default:
465
 
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 
466
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
466
467
        av_log_missing_feature(avctx, "RV1/2 version", 1);
467
468
        return AVERROR_PATCHWELCOME;
468
469
    }
469
470
 
470
471
    if(avctx->debug & FF_DEBUG_PICT_INFO){
471
 
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 
472
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
472
473
    }
473
474
 
474
 
    avctx->pix_fmt = PIX_FMT_YUV420P;
 
475
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
475
476
 
476
 
    if (MPV_common_init(s) < 0)
 
477
    if (ff_MPV_common_init(s) < 0)
477
478
        return -1;
478
479
 
479
480
    ff_h263_decode_init_vlc(s);
496
497
{
497
498
    MpegEncContext *s = avctx->priv_data;
498
499
 
499
 
    MPV_common_end(s);
 
500
    ff_MPV_common_end(s);
500
501
    return 0;
501
502
}
502
503
 
503
504
static int rv10_decode_packet(AVCodecContext *avctx,
504
505
                             const uint8_t *buf, int buf_size, int buf_size2)
505
506
{
506
 
    MpegEncContext *s = avctx->priv_data;
 
507
    RVDecContext  *rv = avctx->priv_data;
 
508
    MpegEncContext *s = &rv->m;
507
509
    int mb_count, mb_pos, left, start_mb_x, active_bits_size;
508
510
 
509
511
    active_bits_size = buf_size * 8;
510
512
    init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
511
 
    if(s->codec_id ==CODEC_ID_RV10)
 
513
    if(s->codec_id ==AV_CODEC_ID_RV10)
512
514
        mb_count = rv10_decode_picture_header(s);
513
515
    else
514
 
        mb_count = rv20_decode_picture_header(s);
 
516
        mb_count = rv20_decode_picture_header(rv);
515
517
    if (mb_count < 0) {
516
518
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
517
519
        return -1;
532
534
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
533
535
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
534
536
            ff_er_frame_end(s);
535
 
            MPV_frame_end(s);
 
537
            ff_MPV_frame_end(s);
536
538
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
537
539
        }
538
 
        if(MPV_frame_start(s, avctx) < 0)
 
540
        if(ff_MPV_frame_start(s, avctx) < 0)
539
541
            return -1;
540
542
        ff_er_frame_start(s);
541
543
    } else {
548
550
    av_dlog(avctx, "qscale=%d\n", s->qscale);
549
551
 
550
552
    /* default quantization values */
551
 
    if(s->codec_id== CODEC_ID_RV10){
 
553
    if(s->codec_id== AV_CODEC_ID_RV10){
552
554
        if(s->mb_y==0) s->first_slice_line=1;
553
555
    }else{
554
556
        s->first_slice_line=1;
615
617
        }
616
618
        if(s->pict_type != AV_PICTURE_TYPE_B)
617
619
            ff_h263_update_motion_val(s);
618
 
        MPV_decode_mb(s, s->block);
 
620
        ff_MPV_decode_mb(s, s->block);
619
621
        if(s->loop_filter)
620
622
            ff_h263_loop_filter(s);
621
623
 
641
643
}
642
644
 
643
645
static int rv10_decode_frame(AVCodecContext *avctx,
644
 
                             void *data, int *data_size,
 
646
                             void *data, int *got_frame,
645
647
                             AVPacket *avpkt)
646
648
{
647
649
    const uint8_t *buf = avpkt->data;
671
673
        slice_count = avctx->slice_count;
672
674
 
673
675
    for(i=0; i<slice_count; i++){
674
 
        int offset= get_slice_offset(avctx, slices_hdr, i);
 
676
        unsigned offset = get_slice_offset(avctx, slices_hdr, i);
675
677
        int size, size2;
676
678
 
 
679
        if (offset >= buf_size)
 
680
            return AVERROR_INVALIDDATA;
 
681
 
677
682
        if(i+1 == slice_count)
678
683
            size= buf_size - offset;
679
684
        else
684
689
        else
685
690
            size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
686
691
 
 
692
        if (size <= 0 || size2 <= 0 ||
 
693
            offset + FFMAX(size, size2) > buf_size)
 
694
            return AVERROR_INVALIDDATA;
 
695
 
687
696
        if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
688
697
            i++;
689
698
    }
690
699
 
691
700
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
692
701
        ff_er_frame_end(s);
693
 
        MPV_frame_end(s);
 
702
        ff_MPV_frame_end(s);
694
703
 
695
704
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
696
 
            *pict= *(AVFrame*)s->current_picture_ptr;
 
705
            *pict = s->current_picture_ptr->f;
697
706
        } else if (s->last_picture_ptr != NULL) {
698
 
            *pict= *(AVFrame*)s->last_picture_ptr;
 
707
            *pict = s->last_picture_ptr->f;
699
708
        }
700
709
 
701
710
        if(s->last_picture_ptr || s->low_delay){
702
 
            *data_size = sizeof(AVFrame);
 
711
            *got_frame = 1;
703
712
            ff_print_debug_info(s, pict);
704
713
        }
705
 
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 
714
        s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
706
715
    }
707
716
 
708
717
    return avpkt->size;
711
720
AVCodec ff_rv10_decoder = {
712
721
    .name           = "rv10",
713
722
    .type           = AVMEDIA_TYPE_VIDEO,
714
 
    .id             = CODEC_ID_RV10,
715
 
    .priv_data_size = sizeof(MpegEncContext),
 
723
    .id             = AV_CODEC_ID_RV10,
 
724
    .priv_data_size = sizeof(RVDecContext),
716
725
    .init           = rv10_decode_init,
717
726
    .close          = rv10_decode_end,
718
727
    .decode         = rv10_decode_frame,
719
728
    .capabilities   = CODEC_CAP_DR1,
720
 
    .max_lowres = 3,
721
 
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
722
 
    .pix_fmts= ff_pixfmt_list_420,
 
729
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 
730
    .pix_fmts       = ff_pixfmt_list_420,
723
731
};
724
732
 
725
733
AVCodec ff_rv20_decoder = {
726
734
    .name           = "rv20",
727
735
    .type           = AVMEDIA_TYPE_VIDEO,
728
 
    .id             = CODEC_ID_RV20,
729
 
    .priv_data_size = sizeof(MpegEncContext),
 
736
    .id             = AV_CODEC_ID_RV20,
 
737
    .priv_data_size = sizeof(RVDecContext),
730
738
    .init           = rv10_decode_init,
731
739
    .close          = rv10_decode_end,
732
740
    .decode         = rv10_decode_frame,
733
741
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
734
 
    .flush= ff_mpeg_flush,
735
 
    .max_lowres = 3,
736
 
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
737
 
    .pix_fmts= ff_pixfmt_list_420,
 
742
    .flush          = ff_mpeg_flush,
 
743
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 
744
    .pix_fmts       = ff_pixfmt_list_420,
738
745
};