Mercurial > libavcodec.hg

comparison mpegvideo.c @ 1042:a78f6f72d54e libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
--disable-risky support
author michaelni
date Wed, 29 Jan 2003 12:00:11 +0000
parents d6ba0641cc36
children 75a659fae7e0
comparison
equal deleted inserted replaced
1041:1d906a29afb6 1042:a78f6f72d54e
623 if (mjpeg_init(s) < 0) 623 if (mjpeg_init(s) < 0)
624 return -1; 624 return -1;
625 avctx->delay=0; 625 avctx->delay=0;
626 s->low_delay=1; 626 s->low_delay=1;
627 break; 627 break;
628 #ifdef CONFIG_RISKY
628 case CODEC_ID_H263: 629 case CODEC_ID_H263:
629 if (h263_get_picture_format(s->width, s->height) == 7) { 630 if (h263_get_picture_format(s->width, s->height) == 7) {
630 printf("Input picture size isn't suitable for h263 codec! try h263+\n"); 631 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
631 return -1; 632 return -1;
632 } 633 }
702 s->unrestricted_mv = 1; 703 s->unrestricted_mv = 1;
703 s->msmpeg4_version= 5; 704 s->msmpeg4_version= 5;
704 avctx->delay=0; 705 avctx->delay=0;
705 s->low_delay=1; 706 s->low_delay=1;
706 break; 707 break;
708 #endif
707 default: 709 default:
708 return -1; 710 return -1;
709 } 711 }
710 712
711 { /* set up some save defaults, some codecs might override them later */ 713 { /* set up some save defaults, some codecs might override them later */
739 return -1; 741 return -1;
740 742
741 ff_init_me(s); 743 ff_init_me(s);
742 744
743 #ifdef CONFIG_ENCODERS 745 #ifdef CONFIG_ENCODERS
746 #ifdef CONFIG_RISKY
744 if (s->out_format == FMT_H263) 747 if (s->out_format == FMT_H263)
745 h263_encode_init(s); 748 h263_encode_init(s);
746 else if (s->out_format == FMT_MPEG1)
747 ff_mpeg1_encode_init(s);
748 if(s->msmpeg4_version) 749 if(s->msmpeg4_version)
749 ff_msmpeg4_encode_init(s); 750 ff_msmpeg4_encode_init(s);
750 #endif 751 #endif
752 if (s->out_format == FMT_MPEG1)
753 ff_mpeg1_encode_init(s);
754 #endif
751 755
752 /* init default q matrix */ 756 /* init default q matrix */
753 for(i=0;i<64;i++) { 757 for(i=0;i<64;i++) {
754 int j= s->idct_permutation[i]; 758 int j= s->idct_permutation[i];
759 #ifdef CONFIG_RISKY
755 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){ 760 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
756 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i]; 761 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
757 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i]; 762 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
758 }else if(s->out_format == FMT_H263){ 763 }else if(s->out_format == FMT_H263){
759 s->intra_matrix[j] = 764 s->intra_matrix[j] =
760 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; 765 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
761 }else{ /* mpeg1 */ 766 }else
767 #endif
768 { /* mpeg1 */
762 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i]; 769 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
763 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; 770 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
764 } 771 }
765 } 772 }
766 773
799 MPV_common_end(s); 806 MPV_common_end(s);
800 if (s->out_format == FMT_MJPEG) 807 if (s->out_format == FMT_MJPEG)
801 mjpeg_close(s); 808 mjpeg_close(s);
802 809
803 return 0; 810 return 0;
811 }
812
813 void init_rl(RLTable *rl)
814 {
815 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
816 UINT8 index_run[MAX_RUN+1];
817 int last, run, level, start, end, i;
818
819 /* compute max_level[], max_run[] and index_run[] */
820 for(last=0;last<2;last++) {
821 if (last == 0) {
822 start = 0;
823 end = rl->last;
824 } else {
825 start = rl->last;
826 end = rl->n;
827 }
828
829 memset(max_level, 0, MAX_RUN + 1);
830 memset(max_run, 0, MAX_LEVEL + 1);
831 memset(index_run, rl->n, MAX_RUN + 1);
832 for(i=start;i<end;i++) {
833 run = rl->table_run[i];
834 level = rl->table_level[i];
835 if (index_run[run] == rl->n)
836 index_run[run] = i;
837 if (level > max_level[run])
838 max_level[run] = level;
839 if (run > max_run[level])
840 max_run[level] = run;
841 }
842 rl->max_level[last] = av_malloc(MAX_RUN + 1);
843 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
844 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
845 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
846 rl->index_run[last] = av_malloc(MAX_RUN + 1);
847 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
848 }
804 } 849 }
805 850
806 /* draw the edges of width 'w' of an image of size width, height */ 851 /* draw the edges of width 'w' of an image of size width, height */
807 //FIXME check that this is ok for mpeg4 interlaced 852 //FIXME check that this is ok for mpeg4 interlaced
808 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w) 853 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
1697 mb_x = s->mb_x; 1742 mb_x = s->mb_x;
1698 mb_y = s->mb_y; 1743 mb_y = s->mb_y;
1699 1744
1700 switch(s->mv_type) { 1745 switch(s->mv_type) {
1701 case MV_TYPE_16X16: 1746 case MV_TYPE_16X16:
1747 #ifdef CONFIG_RISKY
1702 if(s->mcsel){ 1748 if(s->mcsel){
1703 if(s->real_sprite_warping_points==1){ 1749 if(s->real_sprite_warping_points==1){
1704 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0, 1750 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1705 ref_picture, 0); 1751 ref_picture, 0);
1706 }else{ 1752 }else{
1714 s->mv[dir][0][0], s->mv[dir][0][1], 16); 1760 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1715 }else if(s->mspel){ 1761 }else if(s->mspel){
1716 ff_mspel_motion(s, dest_y, dest_cb, dest_cr, 1762 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
1717 ref_picture, pix_op, 1763 ref_picture, pix_op,
1718 s->mv[dir][0][0], s->mv[dir][0][1], 16); 1764 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1719 }else{ 1765 }else
1766 #endif
1767 {
1720 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0, 1768 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1721 ref_picture, 0, 1769 ref_picture, 0,
1722 0, pix_op, 1770 0, pix_op,
1723 s->mv[dir][0][0], s->mv[dir][0][1], 16); 1771 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1724 } 1772 }
2100 2148
2101 if(!(s->flags&CODEC_FLAG_GRAY)){ 2149 if(!(s->flags&CODEC_FLAG_GRAY)){
2102 add_dct(s, block[4], 4, dest_cb, s->uvlinesize); 2150 add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
2103 add_dct(s, block[5], 5, dest_cr, s->uvlinesize); 2151 add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
2104 } 2152 }
2105 } else{ 2153 }
2154 #ifdef CONFIG_RISKY
2155 else{
2106 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); 2156 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2107 } 2157 }
2158 #endif
2108 } else { 2159 } else {
2109 /* dct only in intra block */ 2160 /* dct only in intra block */
2110 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){ 2161 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2111 put_dct(s, block[0], 0, dest_y, dct_linesize); 2162 put_dct(s, block[0], 0, dest_y, dct_linesize);
2112 put_dct(s, block[1], 1, dest_y + 8, dct_linesize); 2163 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2605 #ifdef CONFIG_ENCODERS 2656 #ifdef CONFIG_ENCODERS
2606 /* huffman encode */ 2657 /* huffman encode */
2607 switch(s->codec_id){ //FIXME funct ptr could be slightly faster 2658 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2608 case CODEC_ID_MPEG1VIDEO: 2659 case CODEC_ID_MPEG1VIDEO:
2609 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break; 2660 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2661 #ifdef CONFIG_RISKY
2610 case CODEC_ID_MPEG4: 2662 case CODEC_ID_MPEG4:
2611 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break; 2663 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2612 case CODEC_ID_MSMPEG4V2: 2664 case CODEC_ID_MSMPEG4V2:
2613 case CODEC_ID_MSMPEG4V3: 2665 case CODEC_ID_MSMPEG4V3:
2614 case CODEC_ID_WMV1: 2666 case CODEC_ID_WMV1:
2615 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break; 2667 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
2616 case CODEC_ID_WMV2: 2668 case CODEC_ID_WMV2:
2617 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break; 2669 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
2618 case CODEC_ID_MJPEG:
2619 mjpeg_encode_mb(s, s->block); break;
2620 case CODEC_ID_H263: 2670 case CODEC_ID_H263:
2621 case CODEC_ID_H263P: 2671 case CODEC_ID_H263P:
2622 case CODEC_ID_RV10: 2672 case CODEC_ID_RV10:
2623 h263_encode_mb(s, s->block, motion_x, motion_y); break; 2673 h263_encode_mb(s, s->block, motion_x, motion_y); break;
2674 #endif
2675 case CODEC_ID_MJPEG:
2676 mjpeg_encode_mb(s, s->block); break;
2624 default: 2677 default:
2625 assert(0); 2678 assert(0);
2626 } 2679 }
2627 #endif 2680 #endif
2628 } 2681 }
2810 2863
2811 /* Reset the average MB variance */ 2864 /* Reset the average MB variance */
2812 s->current_picture.mb_var_sum = 0; 2865 s->current_picture.mb_var_sum = 0;
2813 s->current_picture.mc_mb_var_sum = 0; 2866 s->current_picture.mc_mb_var_sum = 0;
2814 2867
2868 #ifdef CONFIG_RISKY
2815 /* we need to initialize some time vars before we can encode b-frames */ 2869 /* we need to initialize some time vars before we can encode b-frames */
2816 if (s->h263_pred && !s->h263_msmpeg4) 2870 if (s->h263_pred && !s->h263_msmpeg4)
2817 ff_set_mpeg4_time(s, s->picture_number); 2871 ff_set_mpeg4_time(s, s->picture_number);
2818 2872 #endif
2873
2819 s->scene_change_score=0; 2874 s->scene_change_score=0;
2820 2875
2821 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration 2876 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2822 2877
2823 if(s->msmpeg4_version){ 2878 if(s->msmpeg4_version){
2922 s->frame_qscale = s->current_picture.quality; 2977 s->frame_qscale = s->current_picture.quality;
2923 else 2978 else
2924 s->frame_qscale = ff_rate_estimate_qscale(s); 2979 s->frame_qscale = ff_rate_estimate_qscale(s);
2925 2980
2926 if(s->adaptive_quant){ 2981 if(s->adaptive_quant){
2982 #ifdef CONFIG_RISKY
2927 switch(s->codec_id){ 2983 switch(s->codec_id){
2928 case CODEC_ID_MPEG4: 2984 case CODEC_ID_MPEG4:
2929 ff_clean_mpeg4_qscales(s); 2985 ff_clean_mpeg4_qscales(s);
2930 break; 2986 break;
2931 case CODEC_ID_H263: 2987 case CODEC_ID_H263:
2932 case CODEC_ID_H263P: 2988 case CODEC_ID_H263P:
2933 ff_clean_h263_qscales(s); 2989 ff_clean_h263_qscales(s);
2934 break; 2990 break;
2935 } 2991 }
2992 #endif
2936 2993
2937 s->qscale= s->current_picture.qscale_table[0]; 2994 s->qscale= s->current_picture.qscale_table[0];
2938 }else 2995 }else
2939 s->qscale= (int)(s->frame_qscale + 0.5); 2996 s->qscale= (int)(s->frame_qscale + 0.5);
2940 2997
2960 s->last_bits= get_bit_count(&s->pb); 3017 s->last_bits= get_bit_count(&s->pb);
2961 switch(s->out_format) { 3018 switch(s->out_format) {
2962 case FMT_MJPEG: 3019 case FMT_MJPEG:
2963 mjpeg_picture_header(s); 3020 mjpeg_picture_header(s);
2964 break; 3021 break;
3022 #ifdef CONFIG_RISKY
2965 case FMT_H263: 3023 case FMT_H263:
2966 if (s->codec_id == CODEC_ID_WMV2) 3024 if (s->codec_id == CODEC_ID_WMV2)
2967 ff_wmv2_encode_picture_header(s, picture_number); 3025 ff_wmv2_encode_picture_header(s, picture_number);
2968 else if (s->h263_msmpeg4) 3026 else if (s->h263_msmpeg4)
2969 msmpeg4_encode_picture_header(s, picture_number); 3027 msmpeg4_encode_picture_header(s, picture_number);
2972 else if (s->h263_rv10) 3030 else if (s->h263_rv10)
2973 rv10_encode_picture_header(s, picture_number); 3031 rv10_encode_picture_header(s, picture_number);
2974 else 3032 else
2975 h263_encode_picture_header(s, picture_number); 3033 h263_encode_picture_header(s, picture_number);
2976 break; 3034 break;
3035 #endif
2977 case FMT_MPEG1: 3036 case FMT_MPEG1:
2978 mpeg1_encode_picture_header(s, picture_number); 3037 mpeg1_encode_picture_header(s, picture_number);
2979 break; 3038 break;
2980 } 3039 }
2981 bits= get_bit_count(&s->pb); 3040 bits= get_bit_count(&s->pb);
2999 } 3058 }
3000 s->mb_incr = 1; 3059 s->mb_incr = 1;
3001 s->last_mv[0][0][0] = 0; 3060 s->last_mv[0][0][0] = 0;
3002 s->last_mv[0][0][1] = 0; 3061 s->last_mv[0][0][1] = 0;
3003 3062
3063 #ifdef CONFIG_RISKY
3004 if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P) 3064 if (s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)
3005 s->gob_index = ff_h263_get_gob_height(s); 3065 s->gob_index = ff_h263_get_gob_height(s);
3006 3066
3007 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame) 3067 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3008 ff_mpeg4_init_partitions(s); 3068 ff_mpeg4_init_partitions(s);
3069 #endif
3009 3070
3010 s->resync_mb_x=0; 3071 s->resync_mb_x=0;
3011 s->resync_mb_y=0; 3072 s->resync_mb_y=0;
3012 s->first_slice_line = 1; 3073 s->first_slice_line = 1;
3013 s->ptr_lastgob = s->pb.buf; 3074 s->ptr_lastgob = s->pb.buf;
3036 s->block_index[3]+=2; 3097 s->block_index[3]+=2;
3037 s->block_index[4]++; 3098 s->block_index[4]++;
3038 s->block_index[5]++; 3099 s->block_index[5]++;
3039 3100
3040 /* write gob / video packet header */ 3101 /* write gob / video packet header */
3102 #ifdef CONFIG_RISKY
3041 if(s->rtp_mode){ 3103 if(s->rtp_mode){
3042 int current_packet_size, is_gob_start; 3104 int current_packet_size, is_gob_start;
3043 3105
3044 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; 3106 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3045 is_gob_start=0; 3107 is_gob_start=0;
3076 s->first_slice_line=1; 3138 s->first_slice_line=1;
3077 s->resync_mb_x=mb_x; 3139 s->resync_mb_x=mb_x;
3078 s->resync_mb_y=mb_y; 3140 s->resync_mb_y=mb_y;
3079 } 3141 }
3080 } 3142 }
3143 #endif
3081 3144
3082 if( (s->resync_mb_x == s->mb_x) 3145 if( (s->resync_mb_x == s->mb_x)
3083 && s->resync_mb_y+1 == s->mb_y){ 3146 && s->resync_mb_y+1 == s->mb_y){
3084 s->first_slice_line=0; 3147 s->first_slice_line=0;
3085 } 3148 }
3150 int mx= s->b_direct_mv_table[xy][0]; 3213 int mx= s->b_direct_mv_table[xy][0];
3151 int my= s->b_direct_mv_table[xy][1]; 3214 int my= s->b_direct_mv_table[xy][1];
3152 3215
3153 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 3216 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3154 s->mb_intra= 0; 3217 s->mb_intra= 0;
3218 #ifdef CONFIG_RISKY
3155 ff_mpeg4_set_direct_mv(s, mx, my); 3219 ff_mpeg4_set_direct_mv(s, mx, my);
3220 #endif
3156 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb, 3221 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3157 &dmin, &next_block, mx, my); 3222 &dmin, &next_block, mx, my);
3158 } 3223 }
3159 if(mb_type&MB_TYPE_INTRA){ 3224 if(mb_type&MB_TYPE_INTRA){
3160 s->mv_dir = MV_DIR_FORWARD; 3225 s->mv_dir = MV_DIR_FORWARD;
3302 case MB_TYPE_DIRECT: 3367 case MB_TYPE_DIRECT:
3303 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 3368 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3304 s->mb_intra= 0; 3369 s->mb_intra= 0;
3305 motion_x=s->b_direct_mv_table[xy][0]; 3370 motion_x=s->b_direct_mv_table[xy][0];
3306 motion_y=s->b_direct_mv_table[xy][1]; 3371 motion_y=s->b_direct_mv_table[xy][1];
3372 #ifdef CONFIG_RISKY
3307 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); 3373 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3374 #endif
3308 break; 3375 break;
3309 case MB_TYPE_BIDIR: 3376 case MB_TYPE_BIDIR:
3310 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 3377 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3311 s->mb_intra= 0; 3378 s->mb_intra= 0;
3312 motion_x=0; 3379 motion_x=0;
3380 s->ptr_last_mb_line = pbBufPtr(&s->pb); 3447 s->ptr_last_mb_line = pbBufPtr(&s->pb);
3381 } 3448 }
3382 } 3449 }
3383 emms_c(); 3450 emms_c();
3384 3451
3452 #ifdef CONFIG_RISKY
3385 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame) 3453 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3386 ff_mpeg4_merge_partitions(s); 3454 ff_mpeg4_merge_partitions(s);
3387 3455
3388 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE) 3456 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3389 msmpeg4_encode_ext_header(s); 3457 msmpeg4_encode_ext_header(s);
3390 3458
3391 if(s->codec_id==CODEC_ID_MPEG4) 3459 if(s->codec_id==CODEC_ID_MPEG4)
3392 ff_mpeg4_stuffing(&s->pb); 3460 ff_mpeg4_stuffing(&s->pb);
3461 #endif
3393 3462
3394 //if (s->gob_number) 3463 //if (s->gob_number)
3395 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number); 3464 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3396 3465
3397 /* Send the last GOB if RTP */ 3466 /* Send the last GOB if RTP */
3910 MPV_encode_init, 3979 MPV_encode_init,
3911 MPV_encode_picture, 3980 MPV_encode_picture,
3912 MPV_encode_end, 3981 MPV_encode_end,
3913 }; 3982 };
3914 3983
3984 #ifdef CONFIG_RISKY
3985
3915 AVCodec h263_encoder = { 3986 AVCodec h263_encoder = {
3916 "h263", 3987 "h263",
3917 CODEC_TYPE_VIDEO, 3988 CODEC_TYPE_VIDEO,
3918 CODEC_ID_H263, 3989 CODEC_ID_H263,
3919 sizeof(MpegEncContext), 3990 sizeof(MpegEncContext),
3940 MPV_encode_init, 4011 MPV_encode_init,
3941 MPV_encode_picture, 4012 MPV_encode_picture,
3942 MPV_encode_end, 4013 MPV_encode_end,
3943 }; 4014 };
3944 4015
4016 AVCodec mpeg4_encoder = {
4017 "mpeg4",
4018 CODEC_TYPE_VIDEO,
4019 CODEC_ID_MPEG4,
4020 sizeof(MpegEncContext),
4021 MPV_encode_init,
4022 MPV_encode_picture,
4023 MPV_encode_end,
4024 };
4025
4026 AVCodec msmpeg4v1_encoder = {
4027 "msmpeg4v1",
4028 CODEC_TYPE_VIDEO,
4029 CODEC_ID_MSMPEG4V1,
4030 sizeof(MpegEncContext),
4031 MPV_encode_init,
4032 MPV_encode_picture,
4033 MPV_encode_end,
4034 };
4035
4036 AVCodec msmpeg4v2_encoder = {
4037 "msmpeg4v2",
4038 CODEC_TYPE_VIDEO,
4039 CODEC_ID_MSMPEG4V2,
4040 sizeof(MpegEncContext),
4041 MPV_encode_init,
4042 MPV_encode_picture,
4043 MPV_encode_end,
4044 };
4045
4046 AVCodec msmpeg4v3_encoder = {
4047 "msmpeg4",
4048 CODEC_TYPE_VIDEO,
4049 CODEC_ID_MSMPEG4V3,
4050 sizeof(MpegEncContext),
4051 MPV_encode_init,
4052 MPV_encode_picture,
4053 MPV_encode_end,
4054 };
4055
4056 AVCodec wmv1_encoder = {
4057 "wmv1",
4058 CODEC_TYPE_VIDEO,
4059 CODEC_ID_WMV1,
4060 sizeof(MpegEncContext),
4061 MPV_encode_init,
4062 MPV_encode_picture,
4063 MPV_encode_end,
4064 };
4065
4066 #endif
4067
3945 AVCodec mjpeg_encoder = { 4068 AVCodec mjpeg_encoder = {
3946 "mjpeg", 4069 "mjpeg",
3947 CODEC_TYPE_VIDEO, 4070 CODEC_TYPE_VIDEO,
3948 CODEC_ID_MJPEG, 4071 CODEC_ID_MJPEG,
3949 sizeof(MpegEncContext), 4072 sizeof(MpegEncContext),
3950 MPV_encode_init, 4073 MPV_encode_init,
3951 MPV_encode_picture, 4074 MPV_encode_picture,
3952 MPV_encode_end, 4075 MPV_encode_end,
3953 }; 4076 };
3954
3955 AVCodec mpeg4_encoder = {
3956 "mpeg4",
3957 CODEC_TYPE_VIDEO,
3958 CODEC_ID_MPEG4,
3959 sizeof(MpegEncContext),
3960 MPV_encode_init,
3961 MPV_encode_picture,
3962 MPV_encode_end,
3963 };
3964
3965 AVCodec msmpeg4v1_encoder = {
3966 "msmpeg4v1",
3967 CODEC_TYPE_VIDEO,
3968 CODEC_ID_MSMPEG4V1,
3969 sizeof(MpegEncContext),
3970 MPV_encode_init,
3971 MPV_encode_picture,
3972 MPV_encode_end,
3973 };
3974
3975 AVCodec msmpeg4v2_encoder = {
3976 "msmpeg4v2",
3977 CODEC_TYPE_VIDEO,
3978 CODEC_ID_MSMPEG4V2,
3979 sizeof(MpegEncContext),
3980 MPV_encode_init,
3981 MPV_encode_picture,
3982 MPV_encode_end,
3983 };
3984
3985 AVCodec msmpeg4v3_encoder = {
3986 "msmpeg4",
3987 CODEC_TYPE_VIDEO,
3988 CODEC_ID_MSMPEG4V3,
3989 sizeof(MpegEncContext),
3990 MPV_encode_init,
3991 MPV_encode_picture,
3992 MPV_encode_end,
3993 };
3994
3995 AVCodec wmv1_encoder = {
3996 "wmv1",
3997 CODEC_TYPE_VIDEO,
3998 CODEC_ID_WMV1,
3999 sizeof(MpegEncContext),
4000 MPV_encode_init,
4001 MPV_encode_picture,
4002 MPV_encode_end,
4003 };
4004