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
00027 #include "libavutil/avstring.h"
00028 #include "libavcodec/bytestream.h"
00029 #include "libavcodec/mpeg4audio.h"
00030 #include "avformat.h"
00031 #include "flv.h"
00032
00033 typedef struct {
00034 int wrong_dts;
00035 } FLVContext;
00036
00037 static int flv_probe(AVProbeData *p)
00038 {
00039 const uint8_t *d;
00040
00041 d = p->buf;
00042 if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0 && AV_RB32(d+5)>8) {
00043 return AVPROBE_SCORE_MAX;
00044 }
00045 return 0;
00046 }
00047
00048 static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, int flv_codecid) {
00049 AVCodecContext *acodec = astream->codec;
00050 switch(flv_codecid) {
00051
00052 case FLV_CODECID_PCM:
00053 acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 :
00054 #if HAVE_BIGENDIAN
00055 CODEC_ID_PCM_S16BE;
00056 #else
00057 CODEC_ID_PCM_S16LE;
00058 #endif
00059 break;
00060 case FLV_CODECID_PCM_LE:
00061 acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_U8 : CODEC_ID_PCM_S16LE; break;
00062 case FLV_CODECID_AAC : acodec->codec_id = CODEC_ID_AAC; break;
00063 case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF; break;
00064 case FLV_CODECID_SPEEX:
00065 acodec->codec_id = CODEC_ID_SPEEX;
00066 acodec->sample_rate = 16000;
00067 break;
00068 case FLV_CODECID_MP3 : acodec->codec_id = CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
00069 case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
00070 acodec->sample_rate = 8000;
00071 acodec->codec_id = CODEC_ID_NELLYMOSER;
00072 break;
00073 case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
00074 acodec->sample_rate = 16000;
00075 acodec->codec_id = CODEC_ID_NELLYMOSER;
00076 break;
00077 case FLV_CODECID_NELLYMOSER:
00078 acodec->codec_id = CODEC_ID_NELLYMOSER;
00079 break;
00080 default:
00081 av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
00082 acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
00083 }
00084 }
00085
00086 static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid) {
00087 AVCodecContext *vcodec = vstream->codec;
00088 switch(flv_codecid) {
00089 case FLV_CODECID_H263 : vcodec->codec_id = CODEC_ID_FLV1 ; break;
00090 case FLV_CODECID_SCREEN: vcodec->codec_id = CODEC_ID_FLASHSV; break;
00091 case FLV_CODECID_SCREEN2: vcodec->codec_id = CODEC_ID_FLASHSV2; break;
00092 case FLV_CODECID_VP6 : vcodec->codec_id = CODEC_ID_VP6F ;
00093 case FLV_CODECID_VP6A :
00094 if(flv_codecid == FLV_CODECID_VP6A)
00095 vcodec->codec_id = CODEC_ID_VP6A;
00096 if(vcodec->extradata_size != 1) {
00097 vcodec->extradata_size = 1;
00098 vcodec->extradata = av_malloc(1);
00099 }
00100 vcodec->extradata[0] = avio_r8(s->pb);
00101 return 1;
00102 case FLV_CODECID_H264:
00103 vcodec->codec_id = CODEC_ID_H264;
00104 return 3;
00105 default:
00106 av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
00107 vcodec->codec_tag = flv_codecid;
00108 }
00109
00110 return 0;
00111 }
00112
00113 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) {
00114 int length = avio_rb16(ioc);
00115 if(length >= buffsize) {
00116 avio_seek(ioc, length, SEEK_CUR);
00117 return -1;
00118 }
00119
00120 avio_read(ioc, buffer, length);
00121
00122 buffer[length] = '\0';
00123
00124 return length;
00125 }
00126
00127 static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) {
00128 AVCodecContext *acodec, *vcodec;
00129 AVIOContext *ioc;
00130 AMFDataType amf_type;
00131 char str_val[256];
00132 double num_val;
00133
00134 num_val = 0;
00135 ioc = s->pb;
00136
00137 amf_type = avio_r8(ioc);
00138
00139 switch(amf_type) {
00140 case AMF_DATA_TYPE_NUMBER:
00141 num_val = av_int2dbl(avio_rb64(ioc)); break;
00142 case AMF_DATA_TYPE_BOOL:
00143 num_val = avio_r8(ioc); break;
00144 case AMF_DATA_TYPE_STRING:
00145 if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
00146 return -1;
00147 break;
00148 case AMF_DATA_TYPE_OBJECT: {
00149 unsigned int keylen;
00150
00151 while(avio_tell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) {
00152 avio_seek(ioc, keylen, SEEK_CUR);
00153 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
00154 return -1;
00155 }
00156 if(avio_r8(ioc) != AMF_END_OF_OBJECT)
00157 return -1;
00158 }
00159 break;
00160 case AMF_DATA_TYPE_NULL:
00161 case AMF_DATA_TYPE_UNDEFINED:
00162 case AMF_DATA_TYPE_UNSUPPORTED:
00163 break;
00164 case AMF_DATA_TYPE_MIXEDARRAY:
00165 avio_seek(ioc, 4, SEEK_CUR);
00166 while(avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
00167
00168 if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
00169 return -1;
00170 }
00171 if(avio_r8(ioc) != AMF_END_OF_OBJECT)
00172 return -1;
00173 break;
00174 case AMF_DATA_TYPE_ARRAY: {
00175 unsigned int arraylen, i;
00176
00177 arraylen = avio_rb32(ioc);
00178 for(i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
00179 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
00180 return -1;
00181 }
00182 }
00183 break;
00184 case AMF_DATA_TYPE_DATE:
00185 avio_seek(ioc, 8 + 2, SEEK_CUR);
00186 break;
00187 default:
00188 return -1;
00189 }
00190
00191 if(depth == 1 && key) {
00192 acodec = astream ? astream->codec : NULL;
00193 vcodec = vstream ? vstream->codec : NULL;
00194
00195 if(amf_type == AMF_DATA_TYPE_BOOL) {
00196 av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val));
00197 av_metadata_set2(&s->metadata, key, str_val, 0);
00198 } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
00199 snprintf(str_val, sizeof(str_val), "%.f", num_val);
00200 av_metadata_set2(&s->metadata, key, str_val, 0);
00201 if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
00202 else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
00203 vcodec->bit_rate = num_val * 1024.0;
00204 else if(!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0))
00205 acodec->bit_rate = num_val * 1024.0;
00206 } else if (amf_type == AMF_DATA_TYPE_STRING)
00207 av_metadata_set2(&s->metadata, key, str_val, 0);
00208 }
00209
00210 return 0;
00211 }
00212
00213 static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
00214 AMFDataType type;
00215 AVStream *stream, *astream, *vstream;
00216 AVIOContext *ioc;
00217 int i;
00218 char buffer[11];
00219
00220 astream = NULL;
00221 vstream = NULL;
00222 ioc = s->pb;
00223
00224
00225 type = avio_r8(ioc);
00226 if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
00227 return -1;
00228
00229
00230 for(i = 0; i < s->nb_streams; i++) {
00231 stream = s->streams[i];
00232 if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) astream = stream;
00233 else if(stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) vstream = stream;
00234 }
00235
00236
00237 if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
00238 return -1;
00239
00240 return 0;
00241 }
00242
00243 static AVStream *create_stream(AVFormatContext *s, int is_audio){
00244 AVStream *st = av_new_stream(s, is_audio);
00245 if (!st)
00246 return NULL;
00247 st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
00248 av_set_pts_info(st, 32, 1, 1000);
00249 return st;
00250 }
00251
00252 static int flv_read_header(AVFormatContext *s,
00253 AVFormatParameters *ap)
00254 {
00255 int offset, flags;
00256
00257 avio_seek(s->pb, 4, SEEK_CUR);
00258 flags = avio_r8(s->pb);
00259
00260
00261 if (!flags) {
00262 flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
00263 av_log(s, AV_LOG_WARNING, "Broken FLV file, which says no streams present, this might fail\n");
00264 }
00265
00266 if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
00267 != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
00268 s->ctx_flags |= AVFMTCTX_NOHEADER;
00269
00270 if(flags & FLV_HEADER_FLAG_HASVIDEO){
00271 if(!create_stream(s, 0))
00272 return AVERROR(ENOMEM);
00273 }
00274 if(flags & FLV_HEADER_FLAG_HASAUDIO){
00275 if(!create_stream(s, 1))
00276 return AVERROR(ENOMEM);
00277 }
00278
00279 offset = avio_rb32(s->pb);
00280 avio_seek(s->pb, offset, SEEK_SET);
00281 avio_seek(s->pb, 4, SEEK_CUR);
00282
00283 s->start_time = 0;
00284
00285 return 0;
00286 }
00287
00288 static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
00289 {
00290 av_free(st->codec->extradata);
00291 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
00292 if (!st->codec->extradata)
00293 return AVERROR(ENOMEM);
00294 st->codec->extradata_size = size;
00295 avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
00296 return 0;
00297 }
00298
00299 static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
00300 {
00301 FLVContext *flv = s->priv_data;
00302 int ret, i, type, size, flags, is_audio;
00303 int64_t next, pos;
00304 int64_t dts, pts = AV_NOPTS_VALUE;
00305 AVStream *st = NULL;
00306
00307 for(;;avio_seek(s->pb, 4, SEEK_CUR)){
00308 pos = avio_tell(s->pb);
00309 type = avio_r8(s->pb);
00310 size = avio_rb24(s->pb);
00311 dts = avio_rb24(s->pb);
00312 dts |= avio_r8(s->pb) << 24;
00313
00314 if (url_feof(s->pb))
00315 return AVERROR_EOF;
00316 avio_seek(s->pb, 3, SEEK_CUR);
00317 flags = 0;
00318
00319 if(size == 0)
00320 continue;
00321
00322 next= size + avio_tell(s->pb);
00323
00324 if (type == FLV_TAG_TYPE_AUDIO) {
00325 is_audio=1;
00326 flags = avio_r8(s->pb);
00327 size--;
00328 } else if (type == FLV_TAG_TYPE_VIDEO) {
00329 is_audio=0;
00330 flags = avio_r8(s->pb);
00331 size--;
00332 if ((flags & 0xf0) == 0x50)
00333 goto skip;
00334 } else {
00335 if (type == FLV_TAG_TYPE_META && size > 13+1+4)
00336 flv_read_metabody(s, next);
00337 else
00338 av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
00339 skip:
00340 avio_seek(s->pb, next, SEEK_SET);
00341 continue;
00342 }
00343
00344
00345 if (!size)
00346 continue;
00347
00348
00349 for(i=0;i<s->nb_streams;i++) {
00350 st = s->streams[i];
00351 if (st->id == is_audio)
00352 break;
00353 }
00354 if(i == s->nb_streams){
00355 av_log(s, AV_LOG_ERROR, "invalid stream\n");
00356 st= create_stream(s, is_audio);
00357 s->ctx_flags &= ~AVFMTCTX_NOHEADER;
00358 }
00359
00360 if( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || is_audio))
00361 ||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && !is_audio))
00362 || st->discard >= AVDISCARD_ALL
00363 ){
00364 avio_seek(s->pb, next, SEEK_SET);
00365 continue;
00366 }
00367 if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
00368 av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
00369 break;
00370 }
00371
00372
00373 if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){
00374 int size;
00375 const int64_t pos= avio_tell(s->pb);
00376 const int64_t fsize= avio_size(s->pb);
00377 avio_seek(s->pb, fsize-4, SEEK_SET);
00378 size= avio_rb32(s->pb);
00379 avio_seek(s->pb, fsize-3-size, SEEK_SET);
00380 if(size == avio_rb24(s->pb) + 11){
00381 uint32_t ts = avio_rb24(s->pb);
00382 ts |= avio_r8(s->pb) << 24;
00383 s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
00384 }
00385 avio_seek(s->pb, pos, SEEK_SET);
00386 }
00387
00388 if(is_audio){
00389 if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) {
00390 st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
00391 st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
00392 st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
00393 }
00394 if(!st->codec->codec_id){
00395 flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
00396 }
00397 }else{
00398 size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
00399 }
00400
00401 if (st->codec->codec_id == CODEC_ID_AAC ||
00402 st->codec->codec_id == CODEC_ID_H264) {
00403 int type = avio_r8(s->pb);
00404 size--;
00405 if (st->codec->codec_id == CODEC_ID_H264) {
00406 int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000;
00407 pts = dts + cts;
00408 if (cts < 0) {
00409 flv->wrong_dts = 1;
00410 av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n");
00411 }
00412 if (flv->wrong_dts)
00413 dts = AV_NOPTS_VALUE;
00414 }
00415 if (type == 0) {
00416 if ((ret = flv_get_extradata(s, st, size)) < 0)
00417 return ret;
00418 if (st->codec->codec_id == CODEC_ID_AAC) {
00419 MPEG4AudioConfig cfg;
00420 ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
00421 st->codec->extradata_size);
00422 st->codec->channels = cfg.channels;
00423 if (cfg.ext_sample_rate)
00424 st->codec->sample_rate = cfg.ext_sample_rate;
00425 else
00426 st->codec->sample_rate = cfg.sample_rate;
00427 av_dlog(s, "mp4a config channels %d sample rate %d\n",
00428 st->codec->channels, st->codec->sample_rate);
00429 }
00430
00431 ret = AVERROR(EAGAIN);
00432 goto leave;
00433 }
00434 }
00435
00436
00437 if (!size) {
00438 ret = AVERROR(EAGAIN);
00439 goto leave;
00440 }
00441
00442 ret= av_get_packet(s->pb, pkt, size);
00443 if (ret < 0) {
00444 return AVERROR(EIO);
00445 }
00446
00447
00448 pkt->size = ret;
00449 pkt->dts = dts;
00450 pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
00451 pkt->stream_index = st->index;
00452
00453 if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
00454 pkt->flags |= AV_PKT_FLAG_KEY;
00455
00456 leave:
00457 avio_seek(s->pb, 4, SEEK_CUR);
00458 return ret;
00459 }
00460
00461 static int flv_read_seek(AVFormatContext *s, int stream_index,
00462 int64_t ts, int flags)
00463 {
00464 return av_url_read_fseek(s->pb, stream_index, ts, flags);
00465 }
00466
00467 #if 0
00468 static int flv_read_seek2(AVFormatContext *s, int stream_index,
00469 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
00470 {
00471 int ret = AVERROR(ENOSYS);
00472
00473 if (ts - min_ts > (uint64_t)(max_ts - ts)) flags |= AVSEEK_FLAG_BACKWARD;
00474
00475 if (url_is_streamed(s->pb)) {
00476 if (stream_index < 0) {
00477 stream_index = av_find_default_stream_index(s);
00478 if (stream_index < 0)
00479 return -1;
00480
00481
00482 ts = av_rescale_rnd(ts, 1000, AV_TIME_BASE,
00483 flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP);
00484 }
00485 ret = av_url_read_fseek(s->pb, stream_index, ts, flags);
00486 }
00487
00488 if (ret == AVERROR(ENOSYS))
00489 ret = av_seek_frame(s, stream_index, ts, flags);
00490 return ret;
00491 }
00492 #endif
00493
00494 AVInputFormat ff_flv_demuxer = {
00495 "flv",
00496 NULL_IF_CONFIG_SMALL("FLV format"),
00497 sizeof(FLVContext),
00498 flv_probe,
00499 flv_read_header,
00500 flv_read_packet,
00501 .read_seek = flv_read_seek,
00502 #if 0
00503 .read_seek2 = flv_read_seek2,
00504 #endif
00505 .extensions = "flv",
00506 .value = CODEC_ID_FLV1,
00507 };