00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include "avformat.h"
00027 #include "flv.h"
00028
00029 static int flv_probe(AVProbeData *p)
00030 {
00031 const uint8_t *d;
00032
00033 d = p->buf;
00034 if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) {
00035 return AVPROBE_SCORE_MAX;
00036 }
00037 return 0;
00038 }
00039
00040 static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, int flv_codecid) {
00041 AVCodecContext *acodec = astream->codec;
00042 switch(flv_codecid) {
00043
00044 case FLV_CODECID_PCM_BE:
00045 acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16BE; break;
00046 case FLV_CODECID_PCM_LE:
00047 acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break;
00048 case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF; break;
00049 case FLV_CODECID_MP3 : acodec->codec_id = CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
00050 case FLV_CODECID_NELLYMOSER_8HZ_MONO:
00051 acodec->sample_rate = 8000;
00052 case FLV_CODECID_NELLYMOSER:
00053 acodec->codec_id = CODEC_ID_NELLYMOSER;
00054 break;
00055 default:
00056 av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
00057 acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
00058 }
00059 }
00060
00061 static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid) {
00062 AVCodecContext *vcodec = vstream->codec;
00063 switch(flv_codecid) {
00064 case FLV_CODECID_H263 : vcodec->codec_id = CODEC_ID_FLV1 ; break;
00065 case FLV_CODECID_SCREEN: vcodec->codec_id = CODEC_ID_FLASHSV; break;
00066 case FLV_CODECID_VP6 : vcodec->codec_id = CODEC_ID_VP6F ;
00067 case FLV_CODECID_VP6A :
00068 if(flv_codecid == FLV_CODECID_VP6A)
00069 vcodec->codec_id = CODEC_ID_VP6A;
00070 if(vcodec->extradata_size != 1) {
00071 vcodec->extradata_size = 1;
00072 vcodec->extradata = av_malloc(1);
00073 }
00074 vcodec->extradata[0] = get_byte(s->pb);
00075 return 1;
00076 default:
00077 av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
00078 vcodec->codec_tag = flv_codecid;
00079 }
00080
00081 return 0;
00082 }
00083
00084 static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
00085 int length = get_be16(ioc);
00086 if(length >= buffsize) {
00087 url_fskip(ioc, length);
00088 return -1;
00089 }
00090
00091 get_buffer(ioc, buffer, length);
00092
00093 buffer[length] = '\0';
00094
00095 return length;
00096 }
00097
00098 static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, unsigned int max_pos, int depth) {
00099 AVCodecContext *acodec, *vcodec;
00100 ByteIOContext *ioc;
00101 AMFDataType amf_type;
00102 char str_val[256];
00103 double num_val;
00104
00105 num_val = 0;
00106 ioc = s->pb;
00107
00108 amf_type = get_byte(ioc);
00109
00110 switch(amf_type) {
00111 case AMF_DATA_TYPE_NUMBER:
00112 num_val = av_int2dbl(get_be64(ioc)); break;
00113 case AMF_DATA_TYPE_BOOL:
00114 num_val = get_byte(ioc); break;
00115 case AMF_DATA_TYPE_STRING:
00116 if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
00117 return -1;
00118 break;
00119 case AMF_DATA_TYPE_OBJECT: {
00120 unsigned int keylen;
00121
00122 while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) {
00123 url_fskip(ioc, keylen);
00124 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
00125 return -1;
00126 }
00127 if(get_byte(ioc) != AMF_END_OF_OBJECT)
00128 return -1;
00129 }
00130 break;
00131 case AMF_DATA_TYPE_NULL:
00132 case AMF_DATA_TYPE_UNDEFINED:
00133 case AMF_DATA_TYPE_UNSUPPORTED:
00134 break;
00135 case AMF_DATA_TYPE_MIXEDARRAY:
00136 url_fskip(ioc, 4);
00137 while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
00138
00139 if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
00140 return -1;
00141 }
00142 if(get_byte(ioc) != AMF_END_OF_OBJECT)
00143 return -1;
00144 break;
00145 case AMF_DATA_TYPE_ARRAY: {
00146 unsigned int arraylen, i;
00147
00148 arraylen = get_be32(ioc);
00149 for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) {
00150 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
00151 return -1;
00152 }
00153 }
00154 break;
00155 case AMF_DATA_TYPE_DATE:
00156 url_fskip(ioc, 8 + 2);
00157 break;
00158 default:
00159 return -1;
00160 }
00161
00162 if(depth == 1 && key) {
00163 acodec = astream ? astream->codec : NULL;
00164 vcodec = vstream ? vstream->codec : NULL;
00165
00166 if(amf_type == AMF_DATA_TYPE_BOOL) {
00167 if(!strcmp(key, "stereo") && acodec) acodec->channels = num_val > 0 ? 2 : 1;
00168 } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
00169 if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
00170
00171
00172 else if(!strcmp(key, "audiocodecid") && acodec) flv_set_audio_codec(s, astream, (int)num_val << FLV_AUDIO_CODECID_OFFSET);
00173 else if(!strcmp(key, "videocodecid") && vcodec) flv_set_video_codec(s, vstream, (int)num_val);
00174 else if(!strcmp(key, "audiosamplesize") && acodec && num_val >= 0) {
00175 acodec->bits_per_sample = num_val;
00176
00177 if(num_val == 8 && (acodec->codec_id == CODEC_ID_PCM_S16BE || acodec->codec_id == CODEC_ID_PCM_S16LE))
00178 acodec->codec_id = CODEC_ID_PCM_S8;
00179 }
00180 else if(!strcmp(key, "audiosamplerate") && acodec && num_val >= 0) {
00181
00182 if (!acodec->sample_rate) {
00183 switch((int)num_val) {
00184 case 44000: acodec->sample_rate = 44100 ; break;
00185 case 22000: acodec->sample_rate = 22050 ; break;
00186 case 11000: acodec->sample_rate = 11025 ; break;
00187 case 5000 : acodec->sample_rate = 5512 ; break;
00188 default : acodec->sample_rate = num_val;
00189 }
00190 }
00191 }
00192 }
00193 }
00194
00195 return 0;
00196 }
00197
00198 static int flv_read_metabody(AVFormatContext *s, unsigned int next_pos) {
00199 AMFDataType type;
00200 AVStream *stream, *astream, *vstream;
00201 ByteIOContext *ioc;
00202 int i, keylen;
00203 char buffer[11];
00204
00205 astream = NULL;
00206 vstream = NULL;
00207 keylen = 0;
00208 ioc = s->pb;
00209
00210
00211 type = get_byte(ioc);
00212 if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
00213 return -1;
00214
00215
00216 for(i = 0; i < s->nb_streams; i++) {
00217 stream = s->streams[i];
00218 if (stream->codec->codec_type == CODEC_TYPE_AUDIO) astream = stream;
00219 else if(stream->codec->codec_type == CODEC_TYPE_VIDEO) vstream = stream;
00220 }
00221
00222
00223 if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
00224 return -1;
00225
00226 return 0;
00227 }
00228
00229 static AVStream *create_stream(AVFormatContext *s, int is_audio){
00230 AVStream *st = av_new_stream(s, is_audio);
00231 if (!st)
00232 return NULL;
00233 st->codec->codec_type = is_audio ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
00234 av_set_pts_info(st, 24, 1, 1000);
00235 return st;
00236 }
00237
00238 static int flv_read_header(AVFormatContext *s,
00239 AVFormatParameters *ap)
00240 {
00241 int offset, flags;
00242
00243 url_fskip(s->pb, 4);
00244 flags = get_byte(s->pb);
00245
00246
00247 if (!flags) {
00248 flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
00249 av_log(s, AV_LOG_WARNING, "Broken FLV file, which says no streams present, this might fail\n");
00250 }
00251
00252 if(flags & FLV_HEADER_FLAG_HASVIDEO){
00253 if(!create_stream(s, 0))
00254 return AVERROR(ENOMEM);
00255 }
00256 if(flags & FLV_HEADER_FLAG_HASAUDIO){
00257 if(!create_stream(s, 1))
00258 return AVERROR(ENOMEM);
00259 }
00260
00261 offset = get_be32(s->pb);
00262 url_fseek(s->pb, offset, SEEK_SET);
00263
00264 s->start_time = 0;
00265
00266 return 0;
00267 }
00268
00269 static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
00270 {
00271 int ret, i, type, size, pts, flags, is_audio, next, pos;
00272 AVStream *st = NULL;
00273
00274 for(;;){
00275 pos = url_ftell(s->pb);
00276 url_fskip(s->pb, 4);
00277 type = get_byte(s->pb);
00278 size = get_be24(s->pb);
00279 pts = get_be24(s->pb);
00280 pts |= get_byte(s->pb) << 24;
00281
00282 if (url_feof(s->pb))
00283 return AVERROR(EIO);
00284 url_fskip(s->pb, 3);
00285 flags = 0;
00286
00287 if(size == 0)
00288 continue;
00289
00290 next= size + url_ftell(s->pb);
00291
00292 if (type == FLV_TAG_TYPE_AUDIO) {
00293 is_audio=1;
00294 flags = get_byte(s->pb);
00295 } else if (type == FLV_TAG_TYPE_VIDEO) {
00296 is_audio=0;
00297 flags = get_byte(s->pb);
00298 } else {
00299 if (type == FLV_TAG_TYPE_META && size > 13+1+4)
00300 flv_read_metabody(s, next);
00301 else
00302 av_log(s, AV_LOG_ERROR, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
00303 url_fseek(s->pb, next, SEEK_SET);
00304 continue;
00305 }
00306
00307
00308 for(i=0;i<s->nb_streams;i++) {
00309 st = s->streams[i];
00310 if (st->id == is_audio)
00311 break;
00312 }
00313 if(i == s->nb_streams){
00314 av_log(NULL, AV_LOG_ERROR, "invalid stream\n");
00315 st= create_stream(s, is_audio);
00316 }
00317
00318 if( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || is_audio))
00319 ||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && !is_audio))
00320 || st->discard >= AVDISCARD_ALL
00321 ){
00322 url_fseek(s->pb, next, SEEK_SET);
00323 continue;
00324 }
00325 if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
00326 av_add_index_entry(st, pos, pts, size, 0, AVINDEX_KEYFRAME);
00327 break;
00328 }
00329
00330
00331 if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
00332 int size;
00333 const int pos= url_ftell(s->pb);
00334 const int fsize= url_fsize(s->pb);
00335 url_fseek(s->pb, fsize-4, SEEK_SET);
00336 size= get_be32(s->pb);
00337 url_fseek(s->pb, fsize-3-size, SEEK_SET);
00338 if(size == get_be24(s->pb) + 11){
00339 s->duration= get_be24(s->pb) * (int64_t)AV_TIME_BASE / 1000;
00340 }
00341 url_fseek(s->pb, pos, SEEK_SET);
00342 }
00343
00344 if(is_audio){
00345 if(!st->codec->sample_rate || !st->codec->bits_per_sample || (!st->codec->codec_id && !st->codec->codec_tag)) {
00346 st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
00347 if((flags & FLV_AUDIO_CODECID_MASK) == FLV_CODECID_NELLYMOSER_8HZ_MONO)
00348 st->codec->sample_rate= 8000;
00349 else
00350 st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
00351 st->codec->bits_per_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
00352 flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
00353 }
00354 }else{
00355 size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
00356 }
00357
00358 ret= av_get_packet(s->pb, pkt, size - 1);
00359 if (ret <= 0) {
00360 return AVERROR(EIO);
00361 }
00362
00363
00364 pkt->size = ret;
00365 pkt->pts = pts;
00366 pkt->stream_index = st->index;
00367
00368 if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
00369 pkt->flags |= PKT_FLAG_KEY;
00370
00371 return ret;
00372 }
00373
00374 static int flv_read_close(AVFormatContext *s)
00375 {
00376 return 0;
00377 }
00378
00379 static int flv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
00380 {
00381 AVStream *st = s->streams[stream_index];
00382 int index = av_index_search_timestamp(st, timestamp, flags);
00383 if (index < 0)
00384 return -1;
00385 url_fseek(s->pb, st->index_entries[index].pos, SEEK_SET);
00386
00387 return 0;
00388 }
00389
00390 AVInputFormat flv_demuxer = {
00391 "flv",
00392 "flv format",
00393 0,
00394 flv_probe,
00395 flv_read_header,
00396 flv_read_packet,
00397 flv_read_close,
00398 flv_read_seek,
00399 .extensions = "flv",
00400 .value = CODEC_ID_FLV1,
00401 };