1 /* General codec for all MPEG-4 derived encoding. */
2 /* Uses ffmpeg and encore50. */
3 /* Encore50 still seemed to provide better results than ffmpeg for encoding */
4 /* so it does all the generic MPEG-4 encoding. */
10 #include "colormodels.h"
11 #include "funcprotos.h"
13 #include "quicktime.h"
14 #include "workarounds.h"
15 #include ENCORE_INCLUDE
16 //#include DECORE_INCLUDE
22 #define FRAME_RATE_BASE 10000
30 quicktime_ffmpeg_t *decoder;
41 int encode_initialized[FIELDS];
42 // Information for picking the right library routines.
43 // ID out of avcodec.h for the codec used.
44 // Invalid if encore50 is used.
46 // True if encore50 is being used.
50 AVCodec *encoder[FIELDS];
51 AVCodecContext *encoder_context[FIELDS];
52 AVFrame picture[FIELDS];
56 int encode_handle[FIELDS];
57 ENC_PARAM enc_param[FIELDS];
58 // Must count pframes in VBR
62 // Encoding parameters
64 // For heroine 60 encoding, we want different streams for each field.
66 long rc_period; // the intended rate control averaging period
67 long rc_reaction_period; // the reation period for rate control
68 long rc_reaction_ratio; // the ratio for down/up rate control
69 long max_key_interval; // the maximum interval between key frames
70 int bitrate_tolerance;
73 int max_quantizer; // the upper limit of the quantizer
74 int min_quantizer; // the lower limit of the quantizer
75 int quantizer; // For vbr
76 int quality; // the forward search range for motion estimation
81 // Temporary storage for color conversions
83 // Storage of compressed data
84 unsigned char *work_buffer;
85 // Allocation of work_buffer
87 } quicktime_mpeg4_codec_t;
91 // Decore needs the user to specify handles
92 static int encode_handle = 0;
102 // Direct copy routines
105 // Determine of the compressed frame is a keyframe for direct copy
106 int quicktime_mpeg4_is_key(unsigned char *data, long size, char *codec_id)
111 if(quicktime_match_32(codec_id, QUICKTIME_DIVX) ||
112 quicktime_match_32(codec_id, QUICKTIME_MP4V) ||
113 quicktime_match_32(codec_id, QUICKTIME_HV60))
115 for(i = 0; i < size - 5; i++)
117 if( data[i] == 0x00 &&
118 data[i + 1] == 0x00 &&
119 data[i + 2] == 0x01 &&
122 if((data[i + 4] & 0xc0) == 0x0)
133 // Test for VOL header in frame
134 int quicktime_mpeg4_has_vol(unsigned char *data)
136 if( data[0] == 0x00 &&
152 static void putbits(unsigned char **data,
159 value &= 0xffffffffffffffffLL >> (64 - count);
161 while(64 - *bit_pos < count)
163 *(*data)++ = (*bit_store) >> 56;
168 (*bit_store) |= value << (64 - count - *bit_pos);
174 static void flushbits(unsigned char **data,
178 //printf("flushbits %llx\n", (*bit_store));
179 while((*bit_pos) > 0)
181 *(*data)++ = (*bit_store) >> 56;
190 #define VO_START_CODE 0x8
191 #define VO_START_CODE_LENGTH 27
192 #define VOL_START_CODE 0x12 /* 25-MAR-97 JDL : according to WD2 */
193 #define VOL_START_CODE_LENGTH 28
197 int quicktime_mpeg4_write_vol(unsigned char *data_start,
200 int time_increment_resolution,
204 int bits, fixed_vop_time_increment;
205 unsigned char *data = data_start;
211 vol_width = quicktime_quantize16(vol_width);
212 vol_height = quicktime_quantize16(vol_height);
219 VO_START_CODE_LENGTH, VO_START_CODE);
224 5, 0); /* vo_id = 0 */
230 VOL_START_CODE_LENGTH, VOL_START_CODE);
238 4, 0); /* vol_id = 0 */
244 1, 0); /* random_accessible_vol = 0 */
249 8, 1); /* video_object_type_indication = 1 video */
254 1, 1); /* is_object_layer_identifier = 1 */
259 4, 2); /* visual_object_layer_ver_id = 2 */
264 3, 1); /* visual_object_layer_priority = 1 */
269 4, 1); /* aspect_ratio_info = 1 */
281 1, 0); /* vol_control_parameter = 0 */
286 2, 0); /* vol_shape = 0 rectangular */
303 16, time_increment_resolution);
313 1, 1); /* fixed_vop_rate = 1 */
317 while((1 << bits) < time_increment_resolution) bits++;
319 // Log calculation fails for some reason
320 // bits = (int)ceil(log((double)time_increment_resolution) / log(2.0));
321 // if (bits < 1) bits=1;
323 fixed_vop_time_increment =
324 (int)(time_increment_resolution / frame_rate + 0.1);
330 bits, fixed_vop_time_increment);
363 1, 0); /* interlaced = 0 */
368 1, 1); /* OBMC_disabled = 1 */
373 2, 0); /* vol_sprite_usage = 0 */
378 1, 0); /* not_8_bit = 0 */
384 1, 0); /* vol_quant_type = 0 */
389 1, 0); /* vol_quarter_pixel = 0 */
394 1, 1); /* complexity_estimation_disabled = 1 */
399 1, 1); /* resync_marker_disabled = 1 */
404 1, 0); /* data_partitioning_enabled = 0 */
409 1, 0); /* scalability = 0 */
417 * for(i = 0; i < data - data_start; i++)
418 * for(j = 0x80; j >= 1; j /= 2)
419 * printf("%d", (data_start[i] & j) ? 1 : 0);
425 return data - data_start;
430 // Create the header for the esds block which is used in mp4v.
431 // Taken from libavcodec
433 static int write_mp4v_header(unsigned char *data,
438 unsigned char *start = data;
442 * static unsigned char test[] =
445 * 0x00, 0x00, 0x01, 0xb0, 0x01, 0x00, 0x00, 0x01, 0xb5, 0x89, 0x13,
446 * 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0xc4, 0x8d,
447 * 0x8a, 0xee, 0x05, 0x28, 0x04, 0x5a, 0x14, 0x63, 0x00, 0x00, 0x01, 0xb2,
448 * 0x46, 0x46, 0x6d, 0x70, 0x65, 0x67, 0x43, 0x56, 0x53, 0x62, 0x34, 0x37,
452 * memcpy(data, test, sizeof(test));
454 * return sizeof(test);
458 // Advanced simple level 1
459 // int profile_level = 0xf3;
461 int profile_level = 0x1;
462 // int vo_version_id = 5;
463 int vo_version_id = 1;
474 *data++ = profile_level;
476 // Visual object startcode
481 *data++ = ((unsigned char)0x1 << 7) |
482 ((unsigned char)vo_version_id << 3) |
485 // visual object type video
486 *data++ = (0x1 << 4) |
497 int vol_size = quicktime_mpeg4_write_vol(data,
515 static int reads_colormodel(quicktime_t *file,
519 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
520 quicktime_codec_t *codec = (quicktime_codec_t*)vtrack->codec;
521 return (colormodel == BC_YUV420P &&
522 !quicktime_match_32(QUICKTIME_SVQ1, codec->fourcc));
525 static int writes_colormodel(quicktime_t *file,
529 return colormodel == BC_YUV420P;
534 static int decode(quicktime_t *file, unsigned char **row_pointers, int track)
536 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
537 quicktime_trak_t *trak = vtrack->track;
538 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
539 quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
540 int width = trak->tkhd.track_width;
541 int height = trak->tkhd.track_height;
545 if(!codec->decoder) codec->decoder = quicktime_new_ffmpeg(
553 if(codec->decoder) result = quicktime_ffmpeg_decode(
564 static int encode_video2(AVCodecContext *avctx, uint8_t *buf, int buf_size,
568 av_init_packet(&pkt);
573 int ret = avcodec_encode_video2(avctx, &pkt, pict, &got_packet);
574 if (!ret && got_packet && avctx->coded_frame) {
575 avctx->coded_frame->pts = pkt.pts;
576 avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
579 if( pkt.side_data_elems > 0 ) {
580 int i = pkt.side_data_elems;
581 while( --i >= 0 ) av_free(pkt.side_data[i].data);
582 av_freep(&pkt.side_data);
583 pkt.side_data_elems = 0;
586 return ret ? ret : pkt.size;
590 static void frame_defaults(AVFrame *frame)
592 memset(frame, 0, sizeof(AVFrame));
593 av_frame_unref(frame);
597 static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
599 // int64_t offset = quicktime_position(file);
600 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
601 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
602 quicktime_trak_t *trak = vtrack->track;
603 int width = trak->tkhd.track_width;
604 int height = trak->tkhd.track_height;
605 int width_i = quicktime_quantize16(width);
606 int height_i = quicktime_quantize16(height);
611 int current_field = vtrack->current_position % codec->total_fields;
612 quicktime_atom_t chunk_atom;
618 pthread_mutex_lock(&ffmpeg_lock);
622 if(!codec->encode_initialized[current_field])
625 if(codec->ffmpeg_id == AV_CODEC_ID_MPEG4 && codec->use_encore)
627 codec->encode_initialized[current_field] = 1;
628 codec->encode_handle[current_field] = encode_handle++;
629 codec->enc_param[current_field].x_dim = width_i;
630 codec->enc_param[current_field].y_dim = height_i;
631 codec->enc_param[current_field].framerate =
632 quicktime_frame_rate(file, track) / codec->total_fields;
633 codec->enc_param[current_field].bitrate =
634 codec->bitrate / codec->total_fields;
635 codec->enc_param[current_field].rc_period = codec->rc_period;
636 codec->enc_param[current_field].rc_reaction_period = codec->rc_reaction_period;
637 codec->enc_param[current_field].rc_reaction_ratio = codec->rc_reaction_ratio;
638 codec->enc_param[current_field].max_quantizer = codec->max_quantizer;
639 codec->enc_param[current_field].min_quantizer = codec->min_quantizer;
640 codec->enc_param[current_field].max_key_interval = codec->max_key_interval;
642 codec->enc_param[current_field].search_range = codec->quality * 3;
643 if(codec->enc_param[current_field].search_range > 15)
644 codec->enc_param[current_field].search_range = 15;
646 encore(codec->encode_handle[current_field],
648 &codec->enc_param[current_field], NULL);
654 codec->encode_initialized[current_field] = 1;
655 if(!ffmpeg_initialized)
657 ffmpeg_initialized = 1;
661 AVCodec *av_codec = avcodec_find_encoder(codec->ffmpeg_id);
662 codec->encoder[current_field] = av_codec;
664 if(!codec->encoder[current_field])
666 printf("encode: avcodec_find_encoder returned NULL.\n");
667 pthread_mutex_unlock(&ffmpeg_lock);
671 AVCodecContext *context = avcodec_alloc_context3(av_codec);
672 codec->encoder_context[current_field] = context;
674 context->width = width_i;
675 context->height = height_i;
676 context->gop_size = codec->gop_size;
677 context->pix_fmt = PIX_FMT_YUV420P;
678 context->bit_rate = codec->bitrate / codec->total_fields;
679 context->bit_rate_tolerance = codec->bitrate_tolerance;
681 (!codec->fix_bitrate ? codec->quantizer : 2);
683 (!codec->fix_bitrate ? codec->quantizer : 31);
684 // It needs the time per frame, not the frame rate.
685 context->time_base.den = quicktime_frame_rate_n(file, track);
686 context->time_base.num = quicktime_frame_rate_d(file, track);
688 context->profile= FF_PROFILE_UNKNOWN;
689 context->level= FF_LEVEL_UNKNOWN;
690 // context->flags |= CODEC_FLAG_H263P_UMV;
691 context->flags |= CODEC_FLAG_AC_PRED;
693 if( codec->ffmpeg_id == AV_CODEC_ID_MPEG4 ||
694 codec->ffmpeg_id == AV_CODEC_ID_H263 ||
695 codec->ffmpeg_id == AV_CODEC_ID_H263P ||
696 codec->ffmpeg_id == AV_CODEC_ID_FLV1 )
697 context->flags |= CODEC_FLAG_4MV;
699 if( codec->ffmpeg_id == AV_CODEC_ID_MPEG4)
700 context->flags |= CODEC_FLAG_QPEL;
702 // All the forbidden settings can be extracted from libavcodec/mpegvideo.c of ffmpeg...
704 // Not compatible with Win
705 // context->flags |= CODEC_FLAG_QPEL;
709 // avcodec_thread_init(context, file->cpus);
710 context->thread_count = file->cpus;
713 if(!codec->fix_bitrate)
714 context->flags |= CODEC_FLAG_QSCALE;
716 if(codec->interlaced)
718 context->flags |= CODEC_FLAG_INTERLACED_DCT;
719 context->flags |= CODEC_FLAG_INTERLACED_ME;
724 * printf("encode gop_size=%d fix_bitrate=%d quantizer=%d\n",
726 * codec->fix_bitrate,
729 avcodec_open2(context, codec->encoder[current_field], 0);
730 frame_defaults(&codec->picture[current_field]);
735 if(!codec->work_buffer)
737 codec->buffer_size = width_i * height_i;
738 codec->work_buffer = malloc(codec->buffer_size);
744 if(codec->use_encore)
747 ENC_FRAME encore_input;
748 ENC_RESULT encore_result;
751 // Assume planes are contiguous.
752 // Encode directly from function arguments
753 if(file->color_model == BC_YUV420P &&
757 encore_input.image = row_pointers[0];
759 // Convert to YUV420P
760 // Encode from temporary.
763 if(!codec->temp_frame)
765 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
767 unsigned char *utmp_frame = (unsigned char *)codec->temp_frame;
768 cmodel_transfer(0, /* Leave NULL if non existent */
770 utmp_frame, /* Leave NULL if non existent */
771 utmp_frame + width_i * height_i,
772 utmp_frame + width_i * height_i + width_i * height_i / 4,
773 row_pointers[0], /* Leave NULL if non existent */
776 0, /* Dimensions to capture from input frame */
780 0, /* Dimensions to project on output frame */
786 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
787 width, /* For planar use the luma rowspan */
791 encore_input.image = codec->temp_frame;
796 bzero(codec->work_buffer, codec->buffer_size);
797 encore_input.bitstream = codec->work_buffer;
798 encore_input.length = 0;
799 encore_input.quant = !codec->fix_bitrate ? codec->quantizer : 0;
801 if(codec->p_count == 0)
803 codec->p_count[current_field]++;
807 codec->p_count[current_field]++;
808 if(codec->p_count[current_field] >= codec->max_key_interval)
809 codec->p_count[current_field] = 0;
813 encore(codec->encode_handle[current_field],
818 bytes = encore_input.length;
819 is_keyframe = encore_result.isKeyFrame;
824 AVCodecContext *context = codec->encoder_context[current_field];
825 AVFrame *picture = &codec->picture[current_field];
827 if(width_i == width &&
828 height_i == height &&
829 file->color_model == BC_YUV420P)
831 picture->data[0] = row_pointers[0];
832 picture->data[1] = row_pointers[1];
833 picture->data[2] = row_pointers[2];
834 picture->linesize[0] = width_i;
835 picture->linesize[1] = width_i / 2;
836 picture->linesize[2] = width_i / 2;
840 if(!codec->temp_frame)
842 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
844 unsigned char *utmp_frame = (unsigned char *)codec->temp_frame;
846 cmodel_transfer(0, /* Leave NULL if non existent */
848 utmp_frame, /* Leave NULL if non existent */
849 utmp_frame + width_i * height_i,
850 utmp_frame + width_i * height_i + width_i * height_i / 4,
851 row_pointers[0], /* Leave NULL if non existent */
854 0, /* Dimensions to capture from input frame */
858 0, /* Dimensions to project on output frame */
864 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
865 width, /* For planar use the luma rowspan */
868 picture->data[0] = utmp_frame;
869 picture->data[1] = utmp_frame + width_i * height_i;
870 picture->data[2] = utmp_frame + width_i * height_i + width_i * height_i / 4;
871 picture->linesize[0] = width_i;
872 picture->linesize[1] = width_i / 2;
873 picture->linesize[2] = width_i / 2;
877 picture->pict_type = 0;
878 picture->quality = 0;
879 picture->pts = vtrack->current_position * quicktime_frame_rate_d(file, track);
880 picture->key_frame = 0;
881 bytes = encode_video2(context, codec->work_buffer, codec->buffer_size, picture);
882 is_keyframe = context->coded_frame && context->coded_frame->key_frame;
884 * printf("encode current_position=%d is_keyframe=%d\n",
885 * vtrack->current_position,
889 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
890 !strcmp(((quicktime_codec_t*)vtrack->codec)->fourcc, QUICKTIME_MP4V))
892 unsigned char temp[1024];
893 unsigned char *ptr = temp;
894 for(i = 0; i < bytes - 4; i++)
896 if(!(codec->work_buffer[i] == 0x00 &&
897 codec->work_buffer[i + 1] == 0x00 &&
898 codec->work_buffer[i + 2] == 0x01 &&
899 codec->work_buffer[i + 3] == 0xb3))
901 *ptr++ = codec->work_buffer[i];
906 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
909 trak->mdia.minf.stbl.stsd.table[0].version = 0;
918 pthread_mutex_unlock(&ffmpeg_lock);
919 quicktime_write_chunk_header(file, trak, &chunk_atom);
920 result = !quicktime_write_data(file, (char*)codec->work_buffer, bytes);
921 quicktime_write_chunk_footer(file, trak, vtrack->current_chunk, &chunk_atom, 1);
922 if(is_keyframe || vtrack->current_position == 0)
923 quicktime_insert_keyframe(file, vtrack->current_position, track);
925 vtrack->current_chunk++;
934 static void flush(quicktime_t *file, int track)
936 quicktime_video_map_t *track_map = &(file->vtracks[track]);
937 quicktime_trak_t *trak = track_map->track;
940 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
941 !strcmp(((quicktime_codec_t*)track_map->codec)->fourcc, QUICKTIME_MP4V))
943 int width = trak->tkhd.track_width;
944 int height = trak->tkhd.track_height;
945 int width_i = quicktime_quantize16(width);
946 int height_i = quicktime_quantize16(height);
948 unsigned char temp[1024];
949 int size = write_mp4v_header(temp, width_i, height_i,
950 quicktime_frame_rate(file, track));
951 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0], temp, size);
955 file->moov.udta.require = strdup("QuickTime 6.0 or greater");
956 file->moov.udta.require_len = strlen(file->moov.udta.require);
966 static int set_parameter(quicktime_t *file,
971 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
972 char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
974 if(quicktime_match_32(compressor, QUICKTIME_DIVX) ||
975 quicktime_match_32(compressor, QUICKTIME_MP42) ||
976 quicktime_match_32(compressor, QUICKTIME_MPG4) ||
977 quicktime_match_32(compressor, QUICKTIME_DX50) ||
978 quicktime_match_32(compressor, QUICKTIME_HV60))
980 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
982 if(!strcasecmp(key, "divx_bitrate"))
983 codec->bitrate = *(int*)value;
985 if(!strcasecmp(key, "divx_rc_period"))
986 codec->rc_period = *(int*)value;
988 if(!strcasecmp(key, "divx_rc_reaction_ratio"))
989 codec->rc_reaction_ratio = *(int*)value;
991 if(!strcasecmp(key, "divx_rc_reaction_period"))
992 codec->rc_reaction_period = *(int*)value;
994 if(!strcasecmp(key, "divx_max_key_interval"))
995 codec->max_key_interval = *(int*)value;
997 if(!strcasecmp(key, "divx_max_quantizer"))
998 codec->max_quantizer = *(int*)value;
1000 if(!strcasecmp(key, "divx_min_quantizer"))
1001 codec->min_quantizer = *(int*)value;
1003 if(!strcasecmp(key, "divx_quantizer"))
1004 codec->quantizer = *(int*)value;
1006 if(!strcasecmp(key, "divx_quality"))
1007 codec->quality = *(int*)value;
1009 if(!strcasecmp(key, "divx_fix_bitrate"))
1010 codec->fix_bitrate = *(int*)value;
1012 if(!strcasecmp(key, "divx_use_deblocking"))
1013 codec->use_deblocking = *(int*)value;
1016 if(quicktime_match_32(compressor, QUICKTIME_DIV3) ||
1017 quicktime_match_32(compressor, QUICKTIME_MP4V))
1019 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1020 if(!strcasecmp(key, "ffmpeg_bitrate"))
1021 codec->bitrate = *(int*)value;
1023 if(!strcasecmp(key, "ffmpeg_bitrate_tolerance"))
1024 codec->bitrate_tolerance = *(int*)value;
1026 if(!strcasecmp(key, "ffmpeg_interlaced"))
1027 codec->interlaced = *(int*)value;
1029 if(!strcasecmp(key, "ffmpeg_gop_size"))
1030 codec->gop_size = *(int*)value;
1032 if(!strcasecmp(key, "ffmpeg_quantizer"))
1033 codec->quantizer = *(int*)value;
1035 if(!strcasecmp(key, "ffmpeg_fix_bitrate"))
1036 codec->fix_bitrate = *(int*)value;
1043 static void delete_codec(quicktime_video_map_t *vtrack)
1045 quicktime_mpeg4_codec_t *codec;
1049 codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1050 for(i = 0; i < codec->total_fields; i++)
1052 if(codec->encode_initialized[i])
1054 pthread_mutex_lock(&ffmpeg_lock);
1055 if(codec->use_encore)
1057 encore(codec->encode_handle[i],
1064 avcodec_close(codec->encoder_context[i]);
1065 free(codec->encoder_context[i]);
1067 pthread_mutex_unlock(&ffmpeg_lock);
1072 if(codec->temp_frame) free(codec->temp_frame);
1073 if(codec->work_buffer) free(codec->work_buffer);
1074 if(codec->decoder) quicktime_delete_ffmpeg(codec->decoder);
1082 static quicktime_mpeg4_codec_t* init_common(quicktime_video_map_t *vtrack,
1087 quicktime_codec_t *codec_base = (quicktime_codec_t*)vtrack->codec;
1088 quicktime_mpeg4_codec_t *codec;
1090 codec_base->priv = calloc(1, sizeof(quicktime_mpeg4_codec_t));
1091 codec_base->delete_vcodec = delete_codec;
1092 codec_base->decode_video = decode;
1093 codec_base->encode_video = encode;
1094 codec_base->flush = flush;
1095 codec_base->reads_colormodel = reads_colormodel;
1096 codec_base->writes_colormodel = writes_colormodel;
1097 codec_base->set_parameter = set_parameter;
1098 codec_base->fourcc = compressor;
1099 codec_base->title = title;
1100 codec_base->desc = description;
1102 codec = (quicktime_mpeg4_codec_t*)codec_base->priv;
1107 codec->bitrate = 1000000;
1108 codec->bitrate_tolerance = 1000000;
1109 codec->rc_period = 50;
1110 codec->rc_reaction_ratio = 45;
1111 codec->rc_reaction_period = 10;
1112 codec->max_key_interval = 45;
1113 codec->max_quantizer = 31;
1114 codec->min_quantizer = 1;
1115 codec->quantizer = 10;
1117 codec->fix_bitrate = 1;
1118 codec->total_fields = 1;
1128 // Mike Rowe Soft MPEG-4
1129 void quicktime_init_codec_div3(quicktime_video_map_t *vtrack)
1131 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1134 "Mike Row Soft MPEG4 Version 3");
1135 result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V3;
1138 void quicktime_init_codec_div5(quicktime_video_map_t *vtrack)
1140 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1143 "Mike Row Soft MPEG4 Version 5");
1144 result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1147 // Mike Rowe Soft MPEG-4
1148 void quicktime_init_codec_div3lower(quicktime_video_map_t *vtrack)
1150 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1151 QUICKTIME_DIV3_LOWER,
1153 "Mike Row Soft MPEG4 Version 3");
1154 result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V3;
1157 void quicktime_init_codec_div3v2(quicktime_video_map_t *vtrack)
1159 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1162 "Mike Row Soft MPEG4 Version 2");
1163 result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V2;
1167 void quicktime_init_codec_divx(quicktime_video_map_t *vtrack)
1169 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1172 "Generic MPEG Four");
1173 result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1174 result->use_encore = 1;
1177 void quicktime_init_codec_mpg4(quicktime_video_map_t *vtrack)
1179 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1182 "FFMPEG (msmpeg4)");
1183 result->ffmpeg_id = AV_CODEC_ID_MSMPEG4V1;
1186 void quicktime_init_codec_dx50(quicktime_video_map_t *vtrack)
1188 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1192 result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1196 void quicktime_init_codec_mp4v(quicktime_video_map_t *vtrack)
1198 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1201 "Generic MPEG Four");
1202 result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1203 // result->use_encore = 1;
1208 void quicktime_init_codec_svq1(quicktime_video_map_t *vtrack)
1210 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1212 "Sorenson Version 1",
1213 "From the chearch of codecs of yesterday's sights");
1214 result->ffmpeg_id = AV_CODEC_ID_SVQ1;
1217 void quicktime_init_codec_svq3(quicktime_video_map_t *vtrack)
1219 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1221 "Sorenson Version 3",
1222 "From the chearch of codecs of yesterday's sights");
1223 result->ffmpeg_id = AV_CODEC_ID_SVQ3;
1226 void quicktime_init_codec_h263(quicktime_video_map_t *vtrack)
1228 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1232 result->ffmpeg_id = AV_CODEC_ID_H263;
1235 void quicktime_init_codec_xvid(quicktime_video_map_t *vtrack)
1237 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1241 result->ffmpeg_id = AV_CODEC_ID_MPEG4;
1244 void quicktime_init_codec_dnxhd(quicktime_video_map_t *vtrack)
1246 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1250 result->ffmpeg_id = AV_CODEC_ID_DNXHD;
1253 // field based MPEG-4
1254 void quicktime_init_codec_hv60(quicktime_video_map_t *vtrack)
1256 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1259 "MPEG 4 with alternating streams every other frame. (Not standardized)");
1260 result->total_fields = 2;
1261 result->ffmpeg_id = AV_CODEC_ID_MPEG4;