1/* 2 * FLV demuxer 3 * Copyright (c) 2003 The FFmpeg Project 4 * 5 * This demuxer will generate a 1 byte extradata for VP6F content. 6 * It is composed of: 7 * - upper 4bits: difference between encoded width and visible width 8 * - lower 4bits: difference between encoded height and visible height 9 * 10 * This file is part of FFmpeg. 11 * 12 * FFmpeg is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU Lesser General Public 14 * License as published by the Free Software Foundation; either 15 * version 2.1 of the License, or (at your option) any later version. 16 * 17 * FFmpeg is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * Lesser General Public License for more details. 21 * 22 * You should have received a copy of the GNU Lesser General Public 23 * License along with FFmpeg; if not, write to the Free Software 24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 25 */ 26 27#include "libavcodec/mpeg4audio.h" 28#include "avformat.h" 29#include "flv.h" 30 31typedef struct { 32 int wrong_dts; ///< wrong dts due to negative cts 33} FLVContext; 34 35static int flv_probe(AVProbeData *p) 36{ 37 const uint8_t *d; 38 39 d = p->buf; 40 if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) { 41 return AVPROBE_SCORE_MAX; 42 } 43 return 0; 44} 45 46static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, int flv_codecid) { 47 AVCodecContext *acodec = astream->codec; 48 switch(flv_codecid) { 49 //no distinction between S16 and S8 PCM codec flags 50 case FLV_CODECID_PCM: 51 acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 : 52#ifdef WORDS_BIGENDIAN 53 CODEC_ID_PCM_S16BE; 54#else 55 CODEC_ID_PCM_S16LE; 56#endif 57 break; 58 case FLV_CODECID_PCM_LE: 59 acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break; 60 case FLV_CODECID_AAC : acodec->codec_id = CODEC_ID_AAC; break; 61 case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF; break; 62 case FLV_CODECID_SPEEX: 63 acodec->codec_id = CODEC_ID_SPEEX; 64 acodec->sample_rate = 16000; 65 break; 66 case FLV_CODECID_MP3 : acodec->codec_id = CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break; 67 case FLV_CODECID_NELLYMOSER_8KHZ_MONO: 68 acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate 69 case FLV_CODECID_NELLYMOSER: 70 acodec->codec_id = CODEC_ID_NELLYMOSER; 71 break; 72 default: 73 av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET); 74 acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET; 75 } 76} 77 78static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid) { 79 AVCodecContext *vcodec = vstream->codec; 80 switch(flv_codecid) { 81 case FLV_CODECID_H263 : vcodec->codec_id = CODEC_ID_FLV1 ; break; 82 case FLV_CODECID_SCREEN: vcodec->codec_id = CODEC_ID_FLASHSV; break; 83 case FLV_CODECID_VP6 : vcodec->codec_id = CODEC_ID_VP6F ; 84 case FLV_CODECID_VP6A : 85 if(flv_codecid == FLV_CODECID_VP6A) 86 vcodec->codec_id = CODEC_ID_VP6A; 87 if(vcodec->extradata_size != 1) { 88 vcodec->extradata_size = 1; 89 vcodec->extradata = av_malloc(1); 90 } 91 vcodec->extradata[0] = get_byte(s->pb); 92 return 1; // 1 byte body size adjustment for flv_read_packet() 93 case FLV_CODECID_H264: 94 vcodec->codec_id = CODEC_ID_H264; 95 return 3; // not 4, reading packet type will consume one byte 96 default: 97 av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid); 98 vcodec->codec_tag = flv_codecid; 99 } 100 101 return 0; 102} 103 104static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) { 105 int length = get_be16(ioc); 106 if(length >= buffsize) { 107 url_fskip(ioc, length); 108 return -1; 109 } 110 111 get_buffer(ioc, buffer, length); 112 113 buffer[length] = '\0'; 114 115 return length; 116} 117 118static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) { 119 AVCodecContext *acodec, *vcodec; 120 ByteIOContext *ioc; 121 AMFDataType amf_type; 122 char str_val[256]; 123 double num_val; 124 125 num_val = 0; 126 ioc = s->pb; 127 128 amf_type = get_byte(ioc); 129 130 switch(amf_type) { 131 case AMF_DATA_TYPE_NUMBER: 132 num_val = av_int2dbl(get_be64(ioc)); break; 133 case AMF_DATA_TYPE_BOOL: 134 num_val = get_byte(ioc); break; 135 case AMF_DATA_TYPE_STRING: 136 if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0) 137 return -1; 138 break; 139 case AMF_DATA_TYPE_OBJECT: { 140 unsigned int keylen; 141 142 while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) { 143 url_fskip(ioc, keylen); //skip key string 144 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0) 145 return -1; //if we couldn't skip, bomb out. 146 } 147 if(get_byte(ioc) != AMF_END_OF_OBJECT) 148 return -1; 149 } 150 break; 151 case AMF_DATA_TYPE_NULL: 152 case AMF_DATA_TYPE_UNDEFINED: 153 case AMF_DATA_TYPE_UNSUPPORTED: 154 break; //these take up no additional space 155 case AMF_DATA_TYPE_MIXEDARRAY: 156 url_fskip(ioc, 4); //skip 32-bit max array index 157 while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) { 158 //this is the only case in which we would want a nested parse to not skip over the object 159 if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0) 160 return -1; 161 } 162 if(get_byte(ioc) != AMF_END_OF_OBJECT) 163 return -1; 164 break; 165 case AMF_DATA_TYPE_ARRAY: { 166 unsigned int arraylen, i; 167 168 arraylen = get_be32(ioc); 169 for(i = 0; i < arraylen && url_ftell(ioc) < max_pos - 1; i++) { 170 if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0) 171 return -1; //if we couldn't skip, bomb out. 172 } 173 } 174 break; 175 case AMF_DATA_TYPE_DATE: 176 url_fskip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16) 177 break; 178 default: //unsupported type, we couldn't skip 179 return -1; 180 } 181 182 if(depth == 1 && key) { //only look for metadata values when we are not nested and key != NULL 183 acodec = astream ? astream->codec : NULL; 184 vcodec = vstream ? vstream->codec : NULL; 185 186 if(amf_type == AMF_DATA_TYPE_BOOL) { 187 if(!strcmp(key, "stereo") && acodec) acodec->channels = num_val > 0 ? 2 : 1; 188 } else if(amf_type == AMF_DATA_TYPE_NUMBER) { 189 if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE; 190// else if(!strcmp(key, "width") && vcodec && num_val > 0) vcodec->width = num_val; 191// else if(!strcmp(key, "height") && vcodec && num_val > 0) vcodec->height = num_val; 192 else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0)) 193 vcodec->bit_rate = num_val * 1024.0; 194 else if(!strcmp(key, "audiocodecid") && acodec && 0 <= (int)num_val) 195 flv_set_audio_codec(s, astream, (int)num_val << FLV_AUDIO_CODECID_OFFSET); 196 else if(!strcmp(key, "videocodecid") && vcodec && 0 <= (int)num_val) 197 flv_set_video_codec(s, vstream, (int)num_val); 198 else if(!strcmp(key, "audiosamplesize") && acodec && 0 < (int)num_val) { 199 acodec->bits_per_coded_sample = num_val; 200 //we may have to rewrite a previously read codecid because FLV only marks PCM endianness. 201 if(num_val == 8 && (acodec->codec_id == CODEC_ID_PCM_S16BE || acodec->codec_id == CODEC_ID_PCM_S16LE)) 202 acodec->codec_id = CODEC_ID_PCM_S8; 203 } 204 else if(!strcmp(key, "audiosamplerate") && acodec && num_val >= 0) { 205 //some tools, like FLVTool2, write consistently approximate metadata sample rates 206 if (!acodec->sample_rate) { 207 switch((int)num_val) { 208 case 44000: acodec->sample_rate = 44100 ; break; 209 case 22000: acodec->sample_rate = 22050 ; break; 210 case 11000: acodec->sample_rate = 11025 ; break; 211 case 5000 : acodec->sample_rate = 5512 ; break; 212 default : acodec->sample_rate = num_val; 213 } 214 } 215 } 216 } 217 } 218 219 return 0; 220} 221 222static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) { 223 AMFDataType type; 224 AVStream *stream, *astream, *vstream; 225 ByteIOContext *ioc; 226 int i, keylen; 227 char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want. 228 229 astream = NULL; 230 vstream = NULL; 231 keylen = 0; 232 ioc = s->pb; 233 234 //first object needs to be "onMetaData" string 235 type = get_byte(ioc); 236 if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData")) 237 return -1; 238 239 //find the streams now so that amf_parse_object doesn't need to do the lookup every time it is called. 240 for(i = 0; i < s->nb_streams; i++) { 241 stream = s->streams[i]; 242 if (stream->codec->codec_type == CODEC_TYPE_AUDIO) astream = stream; 243 else if(stream->codec->codec_type == CODEC_TYPE_VIDEO) vstream = stream; 244 } 245 246 //parse the second object (we want a mixed array) 247 if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0) 248 return -1; 249 250 return 0; 251} 252 253static AVStream *create_stream(AVFormatContext *s, int is_audio){ 254 AVStream *st = av_new_stream(s, is_audio); 255 if (!st) 256 return NULL; 257 st->codec->codec_type = is_audio ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO; 258 av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ 259 return st; 260} 261 262static int flv_read_header(AVFormatContext *s, 263 AVFormatParameters *ap) 264{ 265 int offset, flags; 266 267 url_fskip(s->pb, 4); 268 flags = get_byte(s->pb); 269 /* old flvtool cleared this field */ 270 /* FIXME: better fix needed */ 271 if (!flags) { 272 flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO; 273 av_log(s, AV_LOG_WARNING, "Broken FLV file, which says no streams present, this might fail\n"); 274 } 275 276 if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO)) 277 != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO)) 278 s->ctx_flags |= AVFMTCTX_NOHEADER; 279 280 if(flags & FLV_HEADER_FLAG_HASVIDEO){ 281 if(!create_stream(s, 0)) 282 return AVERROR(ENOMEM); 283 } 284 if(flags & FLV_HEADER_FLAG_HASAUDIO){ 285 if(!create_stream(s, 1)) 286 return AVERROR(ENOMEM); 287 } 288 289 offset = get_be32(s->pb); 290 url_fseek(s->pb, offset, SEEK_SET); 291 292 s->start_time = 0; 293 294 return 0; 295} 296 297static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size) 298{ 299 av_free(st->codec->extradata); 300 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); 301 if (!st->codec->extradata) 302 return AVERROR(ENOMEM); 303 st->codec->extradata_size = size; 304 get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size); 305 return 0; 306} 307 308static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) 309{ 310 FLVContext *flv = s->priv_data; 311 int ret, i, type, size, flags, is_audio; 312 int64_t next, pos; 313 int64_t dts, pts = AV_NOPTS_VALUE; 314 AVStream *st = NULL; 315 316 retry: 317 for(;;){ 318 pos = url_ftell(s->pb); 319 url_fskip(s->pb, 4); /* size of previous packet */ 320 type = get_byte(s->pb); 321 size = get_be24(s->pb); 322 dts = get_be24(s->pb); 323 dts |= get_byte(s->pb) << 24; 324// av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts); 325 if (url_feof(s->pb)) 326 return AVERROR_EOF; 327 url_fskip(s->pb, 3); /* stream id, always 0 */ 328 flags = 0; 329 330 if(size == 0) 331 continue; 332 333 next= size + url_ftell(s->pb); 334 335 if (type == FLV_TAG_TYPE_AUDIO) { 336 is_audio=1; 337 flags = get_byte(s->pb); 338 size--; 339 } else if (type == FLV_TAG_TYPE_VIDEO) { 340 is_audio=0; 341 flags = get_byte(s->pb); 342 size--; 343 if ((flags & 0xf0) == 0x50) /* video info / command frame */ 344 goto skip; 345 } else { 346 if (type == FLV_TAG_TYPE_META && size > 13+1+4) 347 flv_read_metabody(s, next); 348 else /* skip packet */ 349 av_log(s, AV_LOG_ERROR, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags); 350 skip: 351 url_fseek(s->pb, next, SEEK_SET); 352 continue; 353 } 354 355 /* skip empty data packets */ 356 if (!size) 357 continue; 358 359 /* now find stream */ 360 for(i=0;i<s->nb_streams;i++) { 361 st = s->streams[i]; 362 if (st->id == is_audio) 363 break; 364 } 365 if(i == s->nb_streams){ 366 av_log(s, AV_LOG_ERROR, "invalid stream\n"); 367 st= create_stream(s, is_audio); 368 s->ctx_flags &= ~AVFMTCTX_NOHEADER; 369 } 370// av_log(s, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard); 371 if( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || is_audio)) 372 ||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && !is_audio)) 373 || st->discard >= AVDISCARD_ALL 374 ){ 375 url_fseek(s->pb, next, SEEK_SET); 376 continue; 377 } 378 if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY) 379 av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME); 380 break; 381 } 382 383 // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps 384 if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){ 385 int size; 386 const int64_t pos= url_ftell(s->pb); 387 const int64_t fsize= url_fsize(s->pb); 388 url_fseek(s->pb, fsize-4, SEEK_SET); 389 size= get_be32(s->pb); 390 url_fseek(s->pb, fsize-3-size, SEEK_SET); 391 if(size == get_be24(s->pb) + 11){ 392 s->duration= get_be24(s->pb) * (int64_t)AV_TIME_BASE / 1000; 393 } 394 url_fseek(s->pb, pos, SEEK_SET); 395 } 396 397 if(is_audio){ 398 if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) { 399 st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1; 400 st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3); 401 st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8; 402 } 403 if(!st->codec->codec_id){ 404 flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK); 405 } 406 }else{ 407 size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK); 408 } 409 410 if (st->codec->codec_id == CODEC_ID_AAC || 411 st->codec->codec_id == CODEC_ID_H264) { 412 int type = get_byte(s->pb); 413 size--; 414 if (st->codec->codec_id == CODEC_ID_H264) { 415 int32_t cts = (get_be24(s->pb)+0xff800000)^0xff800000; // sign extension 416 pts = dts + cts; 417 if (cts < 0) { // dts are wrong 418 flv->wrong_dts = 1; 419 av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n"); 420 } 421 if (flv->wrong_dts) 422 dts = AV_NOPTS_VALUE; 423 } 424 if (type == 0) { 425 if ((ret = flv_get_extradata(s, st, size)) < 0) 426 return ret; 427 if (st->codec->codec_id == CODEC_ID_AAC) { 428 MPEG4AudioConfig cfg; 429 ff_mpeg4audio_get_config(&cfg, st->codec->extradata, 430 st->codec->extradata_size); 431 if (cfg.chan_config > 7) 432 return -1; 433 st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config]; 434 st->codec->sample_rate = cfg.sample_rate; 435 dprintf(s, "mp4a config channels %d sample rate %d\n", 436 st->codec->channels, st->codec->sample_rate); 437 } 438 439 goto retry; 440 } 441 } 442 443 ret= av_get_packet(s->pb, pkt, size); 444 if (ret <= 0) { 445 return AVERROR(EIO); 446 } 447 /* note: we need to modify the packet size here to handle the last 448 packet */ 449 pkt->size = ret; 450 pkt->dts = dts; 451 pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts; 452 pkt->stream_index = st->index; 453 454 if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)) 455 pkt->flags |= PKT_FLAG_KEY; 456 457 return ret; 458} 459 460AVInputFormat flv_demuxer = { 461 "flv", 462 NULL_IF_CONFIG_SMALL("FLV format"), 463 sizeof(FLVContext), 464 flv_probe, 465 flv_read_header, 466 flv_read_packet, 467 .extensions = "flv", 468 .value = CODEC_ID_FLV1, 469}; 470