| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * RAW muxer and demuxer | |
| 3 * Copyright (c) 2001 Fabrice Bellard | |
| 4 * Copyright (c) 2005 Alex Beregszaszi | |
| 5 * | |
| 6 * This file is part of FFmpeg. | |
| 7 * | |
| 8 * FFmpeg is free software; you can redistribute it and/or | |
| 9 * modify it under the terms of the GNU Lesser General Public | |
| 10 * License as published by the Free Software Foundation; either | |
| 11 * version 2.1 of the License, or (at your option) any later version. | |
| 12 * | |
| 13 * FFmpeg is distributed in the hope that it will be useful, | |
| 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 16 * Lesser General Public License for more details. | |
| 17 * | |
| 18 * You should have received a copy of the GNU Lesser General Public | |
| 19 * License along with FFmpeg; if not, write to the Free Software | |
| 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
| 21 */ | |
| 22 | |
| 23 #include "libavutil/crc.h" | |
| 24 #include "libavcodec/ac3_parser.h" | |
| 25 #include "libavcodec/get_bits.h" | |
| 26 #include "libavcodec/bytestream.h" | |
| 27 #include "avformat.h" | |
| 28 #include "raw.h" | |
| 29 #include "id3v2.h" | |
| 30 #include "id3v1.h" | |
| 31 | |
| 32 /* simple formats */ | |
| 33 | |
| 34 #if CONFIG_ROQ_MUXER | |
| 35 static int roq_write_header(struct AVFormatContext *s) | |
| 36 { | |
| 37 static const uint8_t header[] = { | |
| 38 0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00 | |
| 39 }; | |
| 40 | |
| 41 put_buffer(s->pb, header, 8); | |
| 42 put_flush_packet(s->pb); | |
| 43 | |
| 44 return 0; | |
| 45 } | |
| 46 #endif | |
| 47 | |
| 48 #if CONFIG_NULL_MUXER | |
| 49 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt) | |
| 50 { | |
| 51 return 0; | |
| 52 } | |
| 53 #endif | |
| 54 | |
| 55 #if CONFIG_MUXERS | |
| 56 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt) | |
| 57 { | |
| 58 put_buffer(s->pb, pkt->data, pkt->size); | |
| 59 put_flush_packet(s->pb); | |
| 60 return 0; | |
| 61 } | |
| 62 #endif | |
| 63 | |
| 64 #if CONFIG_DEMUXERS | |
| 65 /* raw input */ | |
| 66 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap) | |
| 67 { | |
| 68 AVStream *st; | |
| 69 enum CodecID id; | |
| 70 | |
| 71 st = av_new_stream(s, 0); | |
| 72 if (!st) | |
| 73 return AVERROR(ENOMEM); | |
| 74 | |
| 75 id = s->iformat->value; | |
| 76 if (id == CODEC_ID_RAWVIDEO) { | |
| 77 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; | |
| 78 } else { | |
| 79 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; | |
| 80 } | |
| 81 st->codec->codec_id = id; | |
| 82 | |
| 83 switch(st->codec->codec_type) { | |
| 84 case AVMEDIA_TYPE_AUDIO: | |
| 85 st->codec->sample_rate = ap->sample_rate; | |
| 86 if(ap->channels) st->codec->channels = ap->channels; | |
| 87 else st->codec->channels = 1; | |
| 88 st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec-
>codec_id); | |
| 89 assert(st->codec->bits_per_coded_sample > 0); | |
| 90 st->codec->block_align = st->codec->bits_per_coded_sample*st->codec-
>channels/8; | |
| 91 av_set_pts_info(st, 64, 1, st->codec->sample_rate); | |
| 92 break; | |
| 93 case AVMEDIA_TYPE_VIDEO: | |
| 94 if(ap->time_base.num) | |
| 95 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den); | |
| 96 else | |
| 97 av_set_pts_info(st, 64, 1, 25); | |
| 98 st->codec->width = ap->width; | |
| 99 st->codec->height = ap->height; | |
| 100 st->codec->pix_fmt = ap->pix_fmt; | |
| 101 if(st->codec->pix_fmt == PIX_FMT_NONE) | |
| 102 st->codec->pix_fmt= PIX_FMT_YUV420P; | |
| 103 break; | |
| 104 default: | |
| 105 return -1; | |
| 106 } | |
| 107 return 0; | |
| 108 } | |
| 109 | |
| 110 #define RAW_PACKET_SIZE 1024 | |
| 111 #define RAW_SAMPLES 1024 | |
| 112 | |
| 113 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt) | |
| 114 { | |
| 115 int ret, size, bps; | |
| 116 // AVStream *st = s->streams[0]; | |
| 117 | |
| 118 size= RAW_SAMPLES*s->streams[0]->codec->block_align; | |
| 119 | |
| 120 ret= av_get_packet(s->pb, pkt, size); | |
| 121 | |
| 122 pkt->stream_index = 0; | |
| 123 if (ret < 0) | |
| 124 return ret; | |
| 125 | |
| 126 bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id); | |
| 127 assert(bps); // if false there IS a bug elsewhere (NOT in this function) | |
| 128 pkt->dts= | |
| 129 pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels); | |
| 130 | |
| 131 return ret; | |
| 132 } | |
| 133 | |
| 134 int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt) | |
| 135 { | |
| 136 int ret, size; | |
| 137 | |
| 138 size = RAW_PACKET_SIZE; | |
| 139 | |
| 140 if (av_new_packet(pkt, size) < 0) | |
| 141 return AVERROR(ENOMEM); | |
| 142 | |
| 143 pkt->pos= url_ftell(s->pb); | |
| 144 pkt->stream_index = 0; | |
| 145 ret = get_partial_buffer(s->pb, pkt->data, size); | |
| 146 if (ret < 0) { | |
| 147 av_free_packet(pkt); | |
| 148 return ret; | |
| 149 } | |
| 150 pkt->size = ret; | |
| 151 return ret; | |
| 152 } | |
| 153 #endif | |
| 154 | |
| 155 #if CONFIG_RAWVIDEO_DEMUXER | |
| 156 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt) | |
| 157 { | |
| 158 int packet_size, ret, width, height; | |
| 159 AVStream *st = s->streams[0]; | |
| 160 | |
| 161 width = st->codec->width; | |
| 162 height = st->codec->height; | |
| 163 | |
| 164 packet_size = avpicture_get_size(st->codec->pix_fmt, width, height); | |
| 165 if (packet_size < 0) | |
| 166 return -1; | |
| 167 | |
| 168 ret= av_get_packet(s->pb, pkt, packet_size); | |
| 169 pkt->pts= | |
| 170 pkt->dts= pkt->pos / packet_size; | |
| 171 | |
| 172 pkt->stream_index = 0; | |
| 173 if (ret < 0) | |
| 174 return ret; | |
| 175 return 0; | |
| 176 } | |
| 177 #endif | |
| 178 | |
| 179 #if CONFIG_INGENIENT_DEMUXER | |
| 180 // http://www.artificis.hu/files/texts/ingenient.txt | |
| 181 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt) | |
| 182 { | |
| 183 int ret, size, w, h, unk1, unk2; | |
| 184 | |
| 185 if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G')) | |
| 186 return AVERROR(EIO); // FIXME | |
| 187 | |
| 188 size = get_le32(s->pb); | |
| 189 | |
| 190 w = get_le16(s->pb); | |
| 191 h = get_le16(s->pb); | |
| 192 | |
| 193 url_fskip(s->pb, 8); // zero + size (padded?) | |
| 194 url_fskip(s->pb, 2); | |
| 195 unk1 = get_le16(s->pb); | |
| 196 unk2 = get_le16(s->pb); | |
| 197 url_fskip(s->pb, 22); // ASCII timestamp | |
| 198 | |
| 199 av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk
1=%d unk2=%d\n", | |
| 200 size, w, h, unk1, unk2); | |
| 201 | |
| 202 if (av_new_packet(pkt, size) < 0) | |
| 203 return AVERROR(ENOMEM); | |
| 204 | |
| 205 pkt->pos = url_ftell(s->pb); | |
| 206 pkt->stream_index = 0; | |
| 207 ret = get_buffer(s->pb, pkt->data, size); | |
| 208 if (ret < 0) { | |
| 209 av_free_packet(pkt); | |
| 210 return ret; | |
| 211 } | |
| 212 pkt->size = ret; | |
| 213 return ret; | |
| 214 } | |
| 215 #endif | |
| 216 | |
| 217 #if CONFIG_DEMUXERS | |
| 218 int pcm_read_seek(AVFormatContext *s, | |
| 219 int stream_index, int64_t timestamp, int flags) | |
| 220 { | |
| 221 AVStream *st; | |
| 222 int block_align, byte_rate; | |
| 223 int64_t pos, ret; | |
| 224 | |
| 225 st = s->streams[0]; | |
| 226 | |
| 227 block_align = st->codec->block_align ? st->codec->block_align : | |
| 228 (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3
; | |
| 229 byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 : | |
| 230 block_align * st->codec->sample_rate; | |
| 231 | |
| 232 if (block_align <= 0 || byte_rate <= 0) | |
| 233 return -1; | |
| 234 if (timestamp < 0) timestamp = 0; | |
| 235 | |
| 236 /* compute the position by aligning it to block_align */ | |
| 237 pos = av_rescale_rnd(timestamp * byte_rate, | |
| 238 st->time_base.num, | |
| 239 st->time_base.den * (int64_t)block_align, | |
| 240 (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROU
ND_UP); | |
| 241 pos *= block_align; | |
| 242 | |
| 243 /* recompute exact position */ | |
| 244 st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->ti
me_base.num); | |
| 245 if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0) | |
| 246 return ret; | |
| 247 return 0; | |
| 248 } | |
| 249 | |
| 250 static int audio_read_header(AVFormatContext *s, | |
| 251 AVFormatParameters *ap) | |
| 252 { | |
| 253 AVStream *st = av_new_stream(s, 0); | |
| 254 if (!st) | |
| 255 return AVERROR(ENOMEM); | |
| 256 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; | |
| 257 st->codec->codec_id = s->iformat->value; | |
| 258 st->need_parsing = AVSTREAM_PARSE_FULL; | |
| 259 /* the parameters will be extracted from the compressed bitstream */ | |
| 260 | |
| 261 return 0; | |
| 262 } | |
| 263 | |
| 264 /* MPEG-1/H.263 input */ | |
| 265 static int video_read_header(AVFormatContext *s, | |
| 266 AVFormatParameters *ap) | |
| 267 { | |
| 268 AVStream *st; | |
| 269 | |
| 270 st = av_new_stream(s, 0); | |
| 271 if (!st) | |
| 272 return AVERROR(ENOMEM); | |
| 273 | |
| 274 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; | |
| 275 st->codec->codec_id = s->iformat->value; | |
| 276 st->need_parsing = AVSTREAM_PARSE_FULL; | |
| 277 | |
| 278 /* for MJPEG, specify frame rate */ | |
| 279 /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop
_rate set ...)*/ | |
| 280 if (ap->time_base.num) { | |
| 281 st->codec->time_base= ap->time_base; | |
| 282 } else if ( st->codec->codec_id == CODEC_ID_MJPEG || | |
| 283 st->codec->codec_id == CODEC_ID_MPEG4 || | |
| 284 st->codec->codec_id == CODEC_ID_DIRAC || | |
| 285 st->codec->codec_id == CODEC_ID_DNXHD || | |
| 286 st->codec->codec_id == CODEC_ID_VC1 || | |
| 287 st->codec->codec_id == CODEC_ID_H264) { | |
| 288 st->codec->time_base= (AVRational){1,25}; | |
| 289 } | |
| 290 av_set_pts_info(st, 64, 1, 1200000); | |
| 291 | |
| 292 return 0; | |
| 293 } | |
| 294 #endif | |
| 295 | |
| 296 #if CONFIG_MPEGVIDEO_DEMUXER | |
| 297 #define SEQ_START_CODE 0x000001b3 | |
| 298 #define GOP_START_CODE 0x000001b8 | |
| 299 #define PICTURE_START_CODE 0x00000100 | |
| 300 #define SLICE_START_CODE 0x00000101 | |
| 301 #define PACK_START_CODE 0x000001ba | |
| 302 #define VIDEO_ID 0x000001e0 | |
| 303 #define AUDIO_ID 0x000001c0 | |
| 304 | |
| 305 static int mpegvideo_probe(AVProbeData *p) | |
| 306 { | |
| 307 uint32_t code= -1; | |
| 308 int pic=0, seq=0, slice=0, pspack=0, pes=0; | |
| 309 int i; | |
| 310 | |
| 311 for(i=0; i<p->buf_size; i++){ | |
| 312 code = (code<<8) + p->buf[i]; | |
| 313 if ((code & 0xffffff00) == 0x100) { | |
| 314 switch(code){ | |
| 315 case SEQ_START_CODE: seq++; break; | |
| 316 case PICTURE_START_CODE: pic++; break; | |
| 317 case SLICE_START_CODE: slice++; break; | |
| 318 case PACK_START_CODE: pspack++; break; | |
| 319 } | |
| 320 if ((code & 0x1f0) == VIDEO_ID) pes++; | |
| 321 else if((code & 0x1e0) == AUDIO_ID) pes++; | |
| 322 } | |
| 323 } | |
| 324 if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes) | |
| 325 return pic>1 ? AVPROBE_SCORE_MAX/2+1 : AVPROBE_SCORE_MAX/4; // +1 for .m
pg | |
| 326 return 0; | |
| 327 } | |
| 328 #endif | |
| 329 | |
| 330 #if CONFIG_CAVSVIDEO_DEMUXER | |
| 331 #define CAVS_SEQ_START_CODE 0x000001b0 | |
| 332 #define CAVS_PIC_I_START_CODE 0x000001b3 | |
| 333 #define CAVS_UNDEF_START_CODE 0x000001b4 | |
| 334 #define CAVS_PIC_PB_START_CODE 0x000001b6 | |
| 335 #define CAVS_VIDEO_EDIT_CODE 0x000001b7 | |
| 336 #define CAVS_PROFILE_JIZHUN 0x20 | |
| 337 | |
| 338 static int cavsvideo_probe(AVProbeData *p) | |
| 339 { | |
| 340 uint32_t code= -1; | |
| 341 int pic=0, seq=0, slice_pos = 0; | |
| 342 int i; | |
| 343 | |
| 344 for(i=0; i<p->buf_size; i++){ | |
| 345 code = (code<<8) + p->buf[i]; | |
| 346 if ((code & 0xffffff00) == 0x100) { | |
| 347 if(code < CAVS_SEQ_START_CODE) { | |
| 348 /* slices have to be consecutive */ | |
| 349 if(code < slice_pos) | |
| 350 return 0; | |
| 351 slice_pos = code; | |
| 352 } else { | |
| 353 slice_pos = 0; | |
| 354 } | |
| 355 if (code == CAVS_SEQ_START_CODE) { | |
| 356 seq++; | |
| 357 /* check for the only currently supported profile */ | |
| 358 if(p->buf[i+1] != CAVS_PROFILE_JIZHUN) | |
| 359 return 0; | |
| 360 } else if ((code == CAVS_PIC_I_START_CODE) || | |
| 361 (code == CAVS_PIC_PB_START_CODE)) { | |
| 362 pic++; | |
| 363 } else if ((code == CAVS_UNDEF_START_CODE) || | |
| 364 (code > CAVS_VIDEO_EDIT_CODE)) { | |
| 365 return 0; | |
| 366 } | |
| 367 } | |
| 368 } | |
| 369 if(seq && seq*9<=pic*10) | |
| 370 return AVPROBE_SCORE_MAX/2; | |
| 371 return 0; | |
| 372 } | |
| 373 #endif | |
| 374 | |
| 375 #if CONFIG_M4V_DEMUXER | |
| 376 #define VISUAL_OBJECT_START_CODE 0x000001b5 | |
| 377 #define VOP_START_CODE 0x000001b6 | |
| 378 | |
| 379 static int mpeg4video_probe(AVProbeData *probe_packet) | |
| 380 { | |
| 381 uint32_t temp_buffer= -1; | |
| 382 int VO=0, VOL=0, VOP = 0, VISO = 0, res=0; | |
| 383 int i; | |
| 384 | |
| 385 for(i=0; i<probe_packet->buf_size; i++){ | |
| 386 temp_buffer = (temp_buffer<<8) + probe_packet->buf[i]; | |
| 387 if ((temp_buffer & 0xffffff00) != 0x100) | |
| 388 continue; | |
| 389 | |
| 390 if (temp_buffer == VOP_START_CODE) VOP++; | |
| 391 else if (temp_buffer == VISUAL_OBJECT_START_CODE) VISO++; | |
| 392 else if (temp_buffer < 0x120) VO++; | |
| 393 else if (temp_buffer < 0x130) VOL++; | |
| 394 else if ( !(0x1AF < temp_buffer && temp_buffer < 0x1B7) | |
| 395 && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++; | |
| 396 } | |
| 397 | |
| 398 if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0) | |
| 399 return AVPROBE_SCORE_MAX/2; | |
| 400 return 0; | |
| 401 } | |
| 402 #endif | |
| 403 | |
| 404 #if CONFIG_H264_DEMUXER | |
| 405 static int h264_probe(AVProbeData *p) | |
| 406 { | |
| 407 uint32_t code= -1; | |
| 408 int sps=0, pps=0, idr=0, res=0, sli=0; | |
| 409 int i; | |
| 410 | |
| 411 for(i=0; i<p->buf_size; i++){ | |
| 412 code = (code<<8) + p->buf[i]; | |
| 413 if ((code & 0xffffff00) == 0x100) { | |
| 414 int ref_idc= (code>>5)&3; | |
| 415 int type = code & 0x1F; | |
| 416 static const int8_t ref_zero[32]={ | |
| 417 2, 0, 0, 0, 0,-1, 1,-1, | |
| 418 -1, 1, 1, 1, 1,-1, 2, 2, | |
| 419 2, 2, 2, 0, 2, 2, 2, 2, | |
| 420 2, 2, 2, 2, 2, 2, 2, 2 | |
| 421 }; | |
| 422 | |
| 423 if(code & 0x80) //forbidden bit | |
| 424 return 0; | |
| 425 | |
| 426 if(ref_zero[type] == 1 && ref_idc) | |
| 427 return 0; | |
| 428 if(ref_zero[type] ==-1 && !ref_idc) | |
| 429 return 0; | |
| 430 if(ref_zero[type] == 2) | |
| 431 res++; | |
| 432 | |
| 433 switch(type){ | |
| 434 case 1: sli++; break; | |
| 435 case 5: idr++; break; | |
| 436 case 7: | |
| 437 if(p->buf[i+2]&0x0F) | |
| 438 return 0; | |
| 439 sps++; | |
| 440 break; | |
| 441 case 8: pps++; break; | |
| 442 } | |
| 443 } | |
| 444 } | |
| 445 if(sps && pps && (idr||sli>3) && res<(sps+pps+idr)) | |
| 446 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg | |
| 447 return 0; | |
| 448 } | |
| 449 #endif | |
| 450 | |
| 451 #if CONFIG_H263_DEMUXER | |
| 452 static int h263_probe(AVProbeData *p) | |
| 453 { | |
| 454 uint64_t code= -1; | |
| 455 int i; | |
| 456 int valid_psc=0; | |
| 457 int invalid_psc=0; | |
| 458 int res_change=0; | |
| 459 int src_fmt, last_src_fmt=-1; | |
| 460 int last_gn=0; | |
| 461 | |
| 462 for(i=0; i<p->buf_size; i++){ | |
| 463 code = (code<<8) + p->buf[i]; | |
| 464 if ((code & 0xfffffc0000) == 0x800000) { | |
| 465 src_fmt= (code>>2)&3; | |
| 466 if( src_fmt != last_src_fmt | |
| 467 && last_src_fmt>0 && last_src_fmt<6 | |
| 468 && src_fmt<6) | |
| 469 res_change++; | |
| 470 | |
| 471 if((code&0x300)==0x200 && src_fmt){ | |
| 472 valid_psc++; | |
| 473 last_gn=0; | |
| 474 }else | |
| 475 invalid_psc++; | |
| 476 last_src_fmt= src_fmt; | |
| 477 } else if((code & 0xffff800000) == 0x800000) { | |
| 478 int gn= (code>>(23-5)) & 0x1F; | |
| 479 if(gn<last_gn){ | |
| 480 invalid_psc++; | |
| 481 }else | |
| 482 last_gn= gn; | |
| 483 } | |
| 484 } | |
| 485 //av_log(NULL, AV_LOG_ERROR, "h263_probe: psc:%d invalid:%d res_change:%d\n", va
lid_psc, invalid_psc, res_change); | |
| 486 //h263_probe: psc:3 invalid:0 res_change:0 (1588/recent_ffmpeg_parses_mpg_incorr
ectly.mpg) | |
| 487 if(valid_psc > 2*invalid_psc + 2*res_change + 3){ | |
| 488 return 50; | |
| 489 }else if(valid_psc > 2*invalid_psc) | |
| 490 return 25; | |
| 491 return 0; | |
| 492 } | |
| 493 #endif | |
| 494 | |
| 495 #if CONFIG_H261_DEMUXER | |
| 496 static int h261_probe(AVProbeData *p) | |
| 497 { | |
| 498 uint32_t code= -1; | |
| 499 int i; | |
| 500 int valid_psc=0; | |
| 501 int invalid_psc=0; | |
| 502 int next_gn=0; | |
| 503 int src_fmt=0; | |
| 504 GetBitContext gb; | |
| 505 | |
| 506 init_get_bits(&gb, p->buf, p->buf_size*8); | |
| 507 | |
| 508 for(i=0; i<p->buf_size*8; i++){ | |
| 509 if ((code & 0x01ff0000) || !(code & 0xff00)) { | |
| 510 code = (code<<8) + get_bits(&gb, 8); | |
| 511 i += 7; | |
| 512 } else | |
| 513 code = (code<<1) + get_bits1(&gb); | |
| 514 if ((code & 0xffff0000) == 0x10000) { | |
| 515 int gn= (code>>12)&0xf; | |
| 516 if(!gn) | |
| 517 src_fmt= code&8; | |
| 518 if(gn != next_gn) invalid_psc++; | |
| 519 else valid_psc++; | |
| 520 | |
| 521 if(src_fmt){ // CIF | |
| 522 next_gn= (gn+1 )%13; | |
| 523 }else{ //QCIF | |
| 524 next_gn= (gn+1+!!gn)% 7; | |
| 525 } | |
| 526 } | |
| 527 } | |
| 528 if(valid_psc > 2*invalid_psc + 6){ | |
| 529 return 50; | |
| 530 }else if(valid_psc > 2*invalid_psc + 2) | |
| 531 return 25; | |
| 532 return 0; | |
| 533 } | |
| 534 #endif | |
| 535 | |
| 536 #if CONFIG_DTS_DEMUXER | |
| 537 #define DCA_MARKER_14B_BE 0x1FFFE800 | |
| 538 #define DCA_MARKER_14B_LE 0xFF1F00E8 | |
| 539 #define DCA_MARKER_RAW_BE 0x7FFE8001 | |
| 540 #define DCA_MARKER_RAW_LE 0xFE7F0180 | |
| 541 static int dts_probe(AVProbeData *p) | |
| 542 { | |
| 543 const uint8_t *buf, *bufp; | |
| 544 uint32_t state = -1; | |
| 545 int markers[3] = {0}; | |
| 546 int sum, max; | |
| 547 | |
| 548 buf = p->buf; | |
| 549 | |
| 550 for(; buf < (p->buf+p->buf_size)-2; buf+=2) { | |
| 551 bufp = buf; | |
| 552 state = (state << 16) | bytestream_get_be16(&bufp); | |
| 553 | |
| 554 /* regular bitstream */ | |
| 555 if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE) | |
| 556 markers[0]++; | |
| 557 | |
| 558 /* 14 bits big-endian bitstream */ | |
| 559 if (state == DCA_MARKER_14B_BE) | |
| 560 if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0) | |
| 561 markers[1]++; | |
| 562 | |
| 563 /* 14 bits little-endian bitstream */ | |
| 564 if (state == DCA_MARKER_14B_LE) | |
| 565 if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007) | |
| 566 markers[2]++; | |
| 567 } | |
| 568 sum = markers[0] + markers[1] + markers[2]; | |
| 569 max = markers[1] > markers[0]; | |
| 570 max = markers[2] > markers[max] ? 2 : max; | |
| 571 if (markers[max] > 3 && p->buf_size / markers[max] < 32*1024 && | |
| 572 markers[max] * 4 > sum * 3) | |
| 573 return AVPROBE_SCORE_MAX/2+1; | |
| 574 | |
| 575 return 0; | |
| 576 } | |
| 577 #endif | |
| 578 | |
| 579 #if CONFIG_DIRAC_DEMUXER | |
| 580 static int dirac_probe(AVProbeData *p) | |
| 581 { | |
| 582 if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D')) | |
| 583 return AVPROBE_SCORE_MAX; | |
| 584 else | |
| 585 return 0; | |
| 586 } | |
| 587 #endif | |
| 588 | |
| 589 #if CONFIG_DNXHD_DEMUXER | |
| 590 static int dnxhd_probe(AVProbeData *p) | |
| 591 { | |
| 592 static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01}; | |
| 593 int w, h, compression_id; | |
| 594 if (p->buf_size < 0x2c) | |
| 595 return 0; | |
| 596 if (memcmp(p->buf, header, 5)) | |
| 597 return 0; | |
| 598 h = AV_RB16(p->buf + 0x18); | |
| 599 w = AV_RB16(p->buf + 0x1a); | |
| 600 if (!w || !h) | |
| 601 return 0; | |
| 602 compression_id = AV_RB32(p->buf + 0x28); | |
| 603 if (compression_id < 1237 || compression_id > 1253) | |
| 604 return 0; | |
| 605 return AVPROBE_SCORE_MAX; | |
| 606 } | |
| 607 #endif | |
| 608 | |
| 609 #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER | |
| 610 static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) | |
| 611 { | |
| 612 int max_frames, first_frames = 0, frames; | |
| 613 uint8_t *buf, *buf2, *end; | |
| 614 AC3HeaderInfo hdr; | |
| 615 GetBitContext gbc; | |
| 616 enum CodecID codec_id = CODEC_ID_AC3; | |
| 617 | |
| 618 max_frames = 0; | |
| 619 buf = p->buf; | |
| 620 end = buf + p->buf_size; | |
| 621 | |
| 622 for(; buf < end; buf++) { | |
| 623 buf2 = buf; | |
| 624 | |
| 625 for(frames = 0; buf2 < end; frames++) { | |
| 626 init_get_bits(&gbc, buf2, 54); | |
| 627 if(ff_ac3_parse_header(&gbc, &hdr) < 0) | |
| 628 break; | |
| 629 if(buf2 + hdr.frame_size > end || | |
| 630 av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_s
ize - 2)) | |
| 631 break; | |
| 632 if (hdr.bitstream_id > 10) | |
| 633 codec_id = CODEC_ID_EAC3; | |
| 634 buf2 += hdr.frame_size; | |
| 635 } | |
| 636 max_frames = FFMAX(max_frames, frames); | |
| 637 if(buf == p->buf) | |
| 638 first_frames = frames; | |
| 639 } | |
| 640 if(codec_id != expected_codec_id) return 0; | |
| 641 // keep this in sync with mp3 probe, both need to avoid | |
| 642 // issues with MPEG-files! | |
| 643 if (first_frames>=4) return AVPROBE_SCORE_MAX/2+1; | |
| 644 else if(max_frames>500)return AVPROBE_SCORE_MAX/2; | |
| 645 else if(max_frames>=4) return AVPROBE_SCORE_MAX/4; | |
| 646 else if(max_frames>=1) return 1; | |
| 647 else return 0; | |
| 648 } | |
| 649 #endif | |
| 650 | |
| 651 #if CONFIG_AC3_DEMUXER | |
| 652 static int ac3_probe(AVProbeData *p) | |
| 653 { | |
| 654 return ac3_eac3_probe(p, CODEC_ID_AC3); | |
| 655 } | |
| 656 #endif | |
| 657 | |
| 658 #if CONFIG_EAC3_DEMUXER | |
| 659 static int eac3_probe(AVProbeData *p) | |
| 660 { | |
| 661 return ac3_eac3_probe(p, CODEC_ID_EAC3); | |
| 662 } | |
| 663 #endif | |
| 664 | |
| 665 #if CONFIG_AAC_DEMUXER | |
| 666 static int adts_aac_probe(AVProbeData *p) | |
| 667 { | |
| 668 int max_frames = 0, first_frames = 0; | |
| 669 int fsize, frames; | |
| 670 uint8_t *buf0 = p->buf; | |
| 671 uint8_t *buf2; | |
| 672 uint8_t *buf; | |
| 673 uint8_t *end = buf0 + p->buf_size - 7; | |
| 674 | |
| 675 if (ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC)) { | |
| 676 buf0 += ff_id3v2_tag_len(buf0); | |
| 677 } | |
| 678 buf = buf0; | |
| 679 | |
| 680 for(; buf < end; buf= buf2+1) { | |
| 681 buf2 = buf; | |
| 682 | |
| 683 for(frames = 0; buf2 < end; frames++) { | |
| 684 uint32_t header = AV_RB16(buf2); | |
| 685 if((header&0xFFF6) != 0xFFF0) | |
| 686 break; | |
| 687 fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF; | |
| 688 if(fsize < 7) | |
| 689 break; | |
| 690 buf2 += fsize; | |
| 691 } | |
| 692 max_frames = FFMAX(max_frames, frames); | |
| 693 if(buf == buf0) | |
| 694 first_frames= frames; | |
| 695 } | |
| 696 if (first_frames>=3) return AVPROBE_SCORE_MAX/2+1; | |
| 697 else if(max_frames>500)return AVPROBE_SCORE_MAX/2; | |
| 698 else if(max_frames>=3) return AVPROBE_SCORE_MAX/4; | |
| 699 else if(max_frames>=1) return 1; | |
| 700 else return 0; | |
| 701 } | |
| 702 | |
| 703 static int adts_aac_read_header(AVFormatContext *s, | |
| 704 AVFormatParameters *ap) | |
| 705 { | |
| 706 AVStream *st; | |
| 707 | |
| 708 st = av_new_stream(s, 0); | |
| 709 if (!st) | |
| 710 return AVERROR(ENOMEM); | |
| 711 | |
| 712 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; | |
| 713 st->codec->codec_id = s->iformat->value; | |
| 714 st->need_parsing = AVSTREAM_PARSE_FULL; | |
| 715 | |
| 716 ff_id3v1_read(s); | |
| 717 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC); | |
| 718 | |
| 719 return 0; | |
| 720 } | |
| 721 | |
| 722 #endif | |
| 723 | |
| 724 /* Note: Do not forget to add new entries to the Makefile as well. */ | |
| 725 | |
| 726 #if CONFIG_AAC_DEMUXER | |
| 727 AVInputFormat aac_demuxer = { | |
| 728 "aac", | |
| 729 NULL_IF_CONFIG_SMALL("raw ADTS AAC"), | |
| 730 0, | |
| 731 adts_aac_probe, | |
| 732 adts_aac_read_header, | |
| 733 ff_raw_read_partial_packet, | |
| 734 .flags= AVFMT_GENERIC_INDEX, | |
| 735 .extensions = "aac", | |
| 736 .value = CODEC_ID_AAC, | |
| 737 }; | |
| 738 #endif | |
| 739 | |
| 740 #if CONFIG_AC3_DEMUXER | |
| 741 AVInputFormat ac3_demuxer = { | |
| 742 "ac3", | |
| 743 NULL_IF_CONFIG_SMALL("raw AC-3"), | |
| 744 0, | |
| 745 ac3_probe, | |
| 746 audio_read_header, | |
| 747 ff_raw_read_partial_packet, | |
| 748 .flags= AVFMT_GENERIC_INDEX, | |
| 749 .extensions = "ac3", | |
| 750 .value = CODEC_ID_AC3, | |
| 751 }; | |
| 752 #endif | |
| 753 | |
| 754 #if CONFIG_AC3_MUXER | |
| 755 AVOutputFormat ac3_muxer = { | |
| 756 "ac3", | |
| 757 NULL_IF_CONFIG_SMALL("raw AC-3"), | |
| 758 "audio/x-ac3", | |
| 759 "ac3", | |
| 760 0, | |
| 761 CODEC_ID_AC3, | |
| 762 CODEC_ID_NONE, | |
| 763 NULL, | |
| 764 raw_write_packet, | |
| 765 .flags= AVFMT_NOTIMESTAMPS, | |
| 766 }; | |
| 767 #endif | |
| 768 | |
| 769 #if CONFIG_DIRAC_DEMUXER | |
| 770 AVInputFormat dirac_demuxer = { | |
| 771 "dirac", | |
| 772 NULL_IF_CONFIG_SMALL("raw Dirac"), | |
| 773 0, | |
| 774 dirac_probe, | |
| 775 video_read_header, | |
| 776 ff_raw_read_partial_packet, | |
| 777 .flags= AVFMT_GENERIC_INDEX, | |
| 778 .value = CODEC_ID_DIRAC, | |
| 779 }; | |
| 780 #endif | |
| 781 | |
| 782 #if CONFIG_DIRAC_MUXER | |
| 783 AVOutputFormat dirac_muxer = { | |
| 784 "dirac", | |
| 785 NULL_IF_CONFIG_SMALL("raw Dirac"), | |
| 786 NULL, | |
| 787 "drc", | |
| 788 0, | |
| 789 CODEC_ID_NONE, | |
| 790 CODEC_ID_DIRAC, | |
| 791 NULL, | |
| 792 raw_write_packet, | |
| 793 .flags= AVFMT_NOTIMESTAMPS, | |
| 794 }; | |
| 795 #endif | |
| 796 | |
| 797 #if CONFIG_DNXHD_DEMUXER | |
| 798 AVInputFormat dnxhd_demuxer = { | |
| 799 "dnxhd", | |
| 800 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), | |
| 801 0, | |
| 802 dnxhd_probe, | |
| 803 video_read_header, | |
| 804 ff_raw_read_partial_packet, | |
| 805 .flags= AVFMT_GENERIC_INDEX, | |
| 806 .value = CODEC_ID_DNXHD, | |
| 807 }; | |
| 808 #endif | |
| 809 | |
| 810 #if CONFIG_DNXHD_MUXER | |
| 811 AVOutputFormat dnxhd_muxer = { | |
| 812 "dnxhd", | |
| 813 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), | |
| 814 NULL, | |
| 815 "dnxhd", | |
| 816 0, | |
| 817 CODEC_ID_NONE, | |
| 818 CODEC_ID_DNXHD, | |
| 819 NULL, | |
| 820 raw_write_packet, | |
| 821 .flags= AVFMT_NOTIMESTAMPS, | |
| 822 }; | |
| 823 #endif | |
| 824 | |
| 825 #if CONFIG_DTS_DEMUXER | |
| 826 AVInputFormat dts_demuxer = { | |
| 827 "dts", | |
| 828 NULL_IF_CONFIG_SMALL("raw DTS"), | |
| 829 0, | |
| 830 dts_probe, | |
| 831 audio_read_header, | |
| 832 ff_raw_read_partial_packet, | |
| 833 .flags= AVFMT_GENERIC_INDEX, | |
| 834 .extensions = "dts", | |
| 835 .value = CODEC_ID_DTS, | |
| 836 }; | |
| 837 #endif | |
| 838 | |
| 839 #if CONFIG_DTS_MUXER | |
| 840 AVOutputFormat dts_muxer = { | |
| 841 "dts", | |
| 842 NULL_IF_CONFIG_SMALL("raw DTS"), | |
| 843 "audio/x-dca", | |
| 844 "dts", | |
| 845 0, | |
| 846 CODEC_ID_DTS, | |
| 847 CODEC_ID_NONE, | |
| 848 NULL, | |
| 849 raw_write_packet, | |
| 850 .flags= AVFMT_NOTIMESTAMPS, | |
| 851 }; | |
| 852 #endif | |
| 853 | |
| 854 #if CONFIG_EAC3_DEMUXER | |
| 855 AVInputFormat eac3_demuxer = { | |
| 856 "eac3", | |
| 857 NULL_IF_CONFIG_SMALL("raw E-AC-3"), | |
| 858 0, | |
| 859 eac3_probe, | |
| 860 audio_read_header, | |
| 861 ff_raw_read_partial_packet, | |
| 862 .flags= AVFMT_GENERIC_INDEX, | |
| 863 .extensions = "eac3", | |
| 864 .value = CODEC_ID_EAC3, | |
| 865 }; | |
| 866 #endif | |
| 867 | |
| 868 #if CONFIG_EAC3_MUXER | |
| 869 AVOutputFormat eac3_muxer = { | |
| 870 "eac3", | |
| 871 NULL_IF_CONFIG_SMALL("raw E-AC-3"), | |
| 872 "audio/x-eac3", | |
| 873 "eac3", | |
| 874 0, | |
| 875 CODEC_ID_EAC3, | |
| 876 CODEC_ID_NONE, | |
| 877 NULL, | |
| 878 raw_write_packet, | |
| 879 .flags= AVFMT_NOTIMESTAMPS, | |
| 880 }; | |
| 881 #endif | |
| 882 | |
| 883 #if CONFIG_GSM_DEMUXER | |
| 884 AVInputFormat gsm_demuxer = { | |
| 885 "gsm", | |
| 886 NULL_IF_CONFIG_SMALL("raw GSM"), | |
| 887 0, | |
| 888 NULL, | |
| 889 audio_read_header, | |
| 890 ff_raw_read_partial_packet, | |
| 891 .flags= AVFMT_GENERIC_INDEX, | |
| 892 .extensions = "gsm", | |
| 893 .value = CODEC_ID_GSM, | |
| 894 }; | |
| 895 #endif | |
| 896 | |
| 897 #if CONFIG_H261_DEMUXER | |
| 898 AVInputFormat h261_demuxer = { | |
| 899 "h261", | |
| 900 NULL_IF_CONFIG_SMALL("raw H.261"), | |
| 901 0, | |
| 902 h261_probe, | |
| 903 video_read_header, | |
| 904 ff_raw_read_partial_packet, | |
| 905 .flags= AVFMT_GENERIC_INDEX, | |
| 906 .extensions = "h261", | |
| 907 .value = CODEC_ID_H261, | |
| 908 }; | |
| 909 #endif | |
| 910 | |
| 911 #if CONFIG_H261_MUXER | |
| 912 AVOutputFormat h261_muxer = { | |
| 913 "h261", | |
| 914 NULL_IF_CONFIG_SMALL("raw H.261"), | |
| 915 "video/x-h261", | |
| 916 "h261", | |
| 917 0, | |
| 918 CODEC_ID_NONE, | |
| 919 CODEC_ID_H261, | |
| 920 NULL, | |
| 921 raw_write_packet, | |
| 922 .flags= AVFMT_NOTIMESTAMPS, | |
| 923 }; | |
| 924 #endif | |
| 925 | |
| 926 #if CONFIG_H263_DEMUXER | |
| 927 AVInputFormat h263_demuxer = { | |
| 928 "h263", | |
| 929 NULL_IF_CONFIG_SMALL("raw H.263"), | |
| 930 0, | |
| 931 h263_probe, | |
| 932 video_read_header, | |
| 933 ff_raw_read_partial_packet, | |
| 934 .flags= AVFMT_GENERIC_INDEX, | |
| 935 // .extensions = "h263", //FIXME remove after writing mpeg4_probe | |
| 936 .value = CODEC_ID_H263, | |
| 937 }; | |
| 938 #endif | |
| 939 | |
| 940 #if CONFIG_H263_MUXER | |
| 941 AVOutputFormat h263_muxer = { | |
| 942 "h263", | |
| 943 NULL_IF_CONFIG_SMALL("raw H.263"), | |
| 944 "video/x-h263", | |
| 945 "h263", | |
| 946 0, | |
| 947 CODEC_ID_NONE, | |
| 948 CODEC_ID_H263, | |
| 949 NULL, | |
| 950 raw_write_packet, | |
| 951 .flags= AVFMT_NOTIMESTAMPS, | |
| 952 }; | |
| 953 #endif | |
| 954 | |
| 955 #if CONFIG_H264_DEMUXER | |
| 956 AVInputFormat h264_demuxer = { | |
| 957 "h264", | |
| 958 NULL_IF_CONFIG_SMALL("raw H.264 video format"), | |
| 959 0, | |
| 960 h264_probe, | |
| 961 video_read_header, | |
| 962 ff_raw_read_partial_packet, | |
| 963 .flags= AVFMT_GENERIC_INDEX, | |
| 964 .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe | |
| 965 .value = CODEC_ID_H264, | |
| 966 }; | |
| 967 #endif | |
| 968 | |
| 969 #if CONFIG_H264_MUXER | |
| 970 AVOutputFormat h264_muxer = { | |
| 971 "h264", | |
| 972 NULL_IF_CONFIG_SMALL("raw H.264 video format"), | |
| 973 NULL, | |
| 974 "h264", | |
| 975 0, | |
| 976 CODEC_ID_NONE, | |
| 977 CODEC_ID_H264, | |
| 978 NULL, | |
| 979 raw_write_packet, | |
| 980 .flags= AVFMT_NOTIMESTAMPS, | |
| 981 }; | |
| 982 #endif | |
| 983 | |
| 984 #if CONFIG_CAVSVIDEO_MUXER | |
| 985 AVOutputFormat cavsvideo_muxer = { | |
| 986 "cavsvideo", | |
| 987 NULL_IF_CONFIG_SMALL("raw Chinese AVS video"), | |
| 988 NULL, | |
| 989 "cavs", | |
| 990 0, | |
| 991 CODEC_ID_NONE, | |
| 992 CODEC_ID_CAVS, | |
| 993 NULL, | |
| 994 raw_write_packet, | |
| 995 .flags= AVFMT_NOTIMESTAMPS, | |
| 996 }; | |
| 997 #endif | |
| 998 | |
| 999 #if CONFIG_INGENIENT_DEMUXER | |
| 1000 AVInputFormat ingenient_demuxer = { | |
| 1001 "ingenient", | |
| 1002 NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"), | |
| 1003 0, | |
| 1004 NULL, | |
| 1005 video_read_header, | |
| 1006 ingenient_read_packet, | |
| 1007 .flags= AVFMT_GENERIC_INDEX, | |
| 1008 .extensions = "cgi", // FIXME | |
| 1009 .value = CODEC_ID_MJPEG, | |
| 1010 }; | |
| 1011 #endif | |
| 1012 | |
| 1013 #if CONFIG_M4V_DEMUXER | |
| 1014 AVInputFormat m4v_demuxer = { | |
| 1015 "m4v", | |
| 1016 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), | |
| 1017 0, | |
| 1018 mpeg4video_probe, /** probing for MPEG-4 data */ | |
| 1019 video_read_header, | |
| 1020 ff_raw_read_partial_packet, | |
| 1021 .flags= AVFMT_GENERIC_INDEX, | |
| 1022 .extensions = "m4v", | |
| 1023 .value = CODEC_ID_MPEG4, | |
| 1024 }; | |
| 1025 #endif | |
| 1026 | |
| 1027 #if CONFIG_M4V_MUXER | |
| 1028 AVOutputFormat m4v_muxer = { | |
| 1029 "m4v", | |
| 1030 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), | |
| 1031 NULL, | |
| 1032 "m4v", | |
| 1033 0, | |
| 1034 CODEC_ID_NONE, | |
| 1035 CODEC_ID_MPEG4, | |
| 1036 NULL, | |
| 1037 raw_write_packet, | |
| 1038 .flags= AVFMT_NOTIMESTAMPS, | |
| 1039 }; | |
| 1040 #endif | |
| 1041 | |
| 1042 #if CONFIG_MJPEG_DEMUXER | |
| 1043 AVInputFormat mjpeg_demuxer = { | |
| 1044 "mjpeg", | |
| 1045 NULL_IF_CONFIG_SMALL("raw MJPEG video"), | |
| 1046 0, | |
| 1047 NULL, | |
| 1048 video_read_header, | |
| 1049 ff_raw_read_partial_packet, | |
| 1050 .flags= AVFMT_GENERIC_INDEX, | |
| 1051 .extensions = "mjpg,mjpeg", | |
| 1052 .value = CODEC_ID_MJPEG, | |
| 1053 }; | |
| 1054 #endif | |
| 1055 | |
| 1056 #if CONFIG_MJPEG_MUXER | |
| 1057 AVOutputFormat mjpeg_muxer = { | |
| 1058 "mjpeg", | |
| 1059 NULL_IF_CONFIG_SMALL("raw MJPEG video"), | |
| 1060 "video/x-mjpeg", | |
| 1061 "mjpg,mjpeg", | |
| 1062 0, | |
| 1063 CODEC_ID_NONE, | |
| 1064 CODEC_ID_MJPEG, | |
| 1065 NULL, | |
| 1066 raw_write_packet, | |
| 1067 .flags= AVFMT_NOTIMESTAMPS, | |
| 1068 }; | |
| 1069 #endif | |
| 1070 | |
| 1071 #if CONFIG_MLP_DEMUXER | |
| 1072 AVInputFormat mlp_demuxer = { | |
| 1073 "mlp", | |
| 1074 NULL_IF_CONFIG_SMALL("raw MLP"), | |
| 1075 0, | |
| 1076 NULL, | |
| 1077 audio_read_header, | |
| 1078 ff_raw_read_partial_packet, | |
| 1079 .flags= AVFMT_GENERIC_INDEX, | |
| 1080 .extensions = "mlp", | |
| 1081 .value = CODEC_ID_MLP, | |
| 1082 }; | |
| 1083 #endif | |
| 1084 | |
| 1085 #if CONFIG_MLP_MUXER | |
| 1086 AVOutputFormat mlp_muxer = { | |
| 1087 "mlp", | |
| 1088 NULL_IF_CONFIG_SMALL("raw MLP"), | |
| 1089 NULL, | |
| 1090 "mlp", | |
| 1091 0, | |
| 1092 CODEC_ID_MLP, | |
| 1093 CODEC_ID_NONE, | |
| 1094 NULL, | |
| 1095 raw_write_packet, | |
| 1096 .flags= AVFMT_NOTIMESTAMPS, | |
| 1097 }; | |
| 1098 #endif | |
| 1099 | |
| 1100 #if CONFIG_SRT_MUXER | |
| 1101 AVOutputFormat srt_muxer = { | |
| 1102 .name = "srt", | |
| 1103 .long_name = NULL_IF_CONFIG_SMALL("SubRip subtitle format"), | |
| 1104 .mime_type = "application/x-subrip", | |
| 1105 .extensions = "srt", | |
| 1106 .write_packet = raw_write_packet, | |
| 1107 .flags = AVFMT_NOTIMESTAMPS, | |
| 1108 .subtitle_codec = CODEC_ID_SRT, | |
| 1109 }; | |
| 1110 #endif | |
| 1111 | |
| 1112 #if CONFIG_TRUEHD_DEMUXER | |
| 1113 AVInputFormat truehd_demuxer = { | |
| 1114 "truehd", | |
| 1115 NULL_IF_CONFIG_SMALL("raw TrueHD"), | |
| 1116 0, | |
| 1117 NULL, | |
| 1118 audio_read_header, | |
| 1119 ff_raw_read_partial_packet, | |
| 1120 .flags= AVFMT_GENERIC_INDEX, | |
| 1121 .extensions = "thd", | |
| 1122 .value = CODEC_ID_TRUEHD, | |
| 1123 }; | |
| 1124 #endif | |
| 1125 | |
| 1126 #if CONFIG_TRUEHD_MUXER | |
| 1127 AVOutputFormat truehd_muxer = { | |
| 1128 "truehd", | |
| 1129 NULL_IF_CONFIG_SMALL("raw TrueHD"), | |
| 1130 NULL, | |
| 1131 "thd", | |
| 1132 0, | |
| 1133 CODEC_ID_TRUEHD, | |
| 1134 CODEC_ID_NONE, | |
| 1135 NULL, | |
| 1136 raw_write_packet, | |
| 1137 .flags= AVFMT_NOTIMESTAMPS, | |
| 1138 }; | |
| 1139 #endif | |
| 1140 | |
| 1141 #if CONFIG_MPEG1VIDEO_MUXER | |
| 1142 AVOutputFormat mpeg1video_muxer = { | |
| 1143 "mpeg1video", | |
| 1144 NULL_IF_CONFIG_SMALL("raw MPEG-1 video"), | |
| 1145 "video/x-mpeg", | |
| 1146 "mpg,mpeg,m1v", | |
| 1147 0, | |
| 1148 CODEC_ID_NONE, | |
| 1149 CODEC_ID_MPEG1VIDEO, | |
| 1150 NULL, | |
| 1151 raw_write_packet, | |
| 1152 .flags= AVFMT_NOTIMESTAMPS, | |
| 1153 }; | |
| 1154 #endif | |
| 1155 | |
| 1156 #if CONFIG_MPEG2VIDEO_MUXER | |
| 1157 AVOutputFormat mpeg2video_muxer = { | |
| 1158 "mpeg2video", | |
| 1159 NULL_IF_CONFIG_SMALL("raw MPEG-2 video"), | |
| 1160 NULL, | |
| 1161 "m2v", | |
| 1162 0, | |
| 1163 CODEC_ID_NONE, | |
| 1164 CODEC_ID_MPEG2VIDEO, | |
| 1165 NULL, | |
| 1166 raw_write_packet, | |
| 1167 .flags= AVFMT_NOTIMESTAMPS, | |
| 1168 }; | |
| 1169 #endif | |
| 1170 | |
| 1171 #if CONFIG_MPEGVIDEO_DEMUXER | |
| 1172 AVInputFormat mpegvideo_demuxer = { | |
| 1173 "mpegvideo", | |
| 1174 NULL_IF_CONFIG_SMALL("raw MPEG video"), | |
| 1175 0, | |
| 1176 mpegvideo_probe, | |
| 1177 video_read_header, | |
| 1178 ff_raw_read_partial_packet, | |
| 1179 .flags= AVFMT_GENERIC_INDEX, | |
| 1180 .value = CODEC_ID_MPEG1VIDEO, | |
| 1181 }; | |
| 1182 #endif | |
| 1183 | |
| 1184 #if CONFIG_CAVSVIDEO_DEMUXER | |
| 1185 AVInputFormat cavsvideo_demuxer = { | |
| 1186 "cavsvideo", | |
| 1187 NULL_IF_CONFIG_SMALL("raw Chinese AVS video"), | |
| 1188 0, | |
| 1189 cavsvideo_probe, | |
| 1190 video_read_header, | |
| 1191 ff_raw_read_partial_packet, | |
| 1192 .flags= AVFMT_GENERIC_INDEX, | |
| 1193 .value = CODEC_ID_CAVS, | |
| 1194 }; | |
| 1195 #endif | |
| 1196 | |
| 1197 #if CONFIG_NULL_MUXER | |
| 1198 AVOutputFormat null_muxer = { | |
| 1199 "null", | |
| 1200 NULL_IF_CONFIG_SMALL("raw null video format"), | |
| 1201 NULL, | |
| 1202 NULL, | |
| 1203 0, | |
| 1204 #if HAVE_BIGENDIAN | |
| 1205 CODEC_ID_PCM_S16BE, | |
| 1206 #else | |
| 1207 CODEC_ID_PCM_S16LE, | |
| 1208 #endif | |
| 1209 CODEC_ID_RAWVIDEO, | |
| 1210 NULL, | |
| 1211 null_write_packet, | |
| 1212 .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS, | |
| 1213 }; | |
| 1214 #endif | |
| 1215 | |
| 1216 #if CONFIG_RAWVIDEO_DEMUXER | |
| 1217 AVInputFormat rawvideo_demuxer = { | |
| 1218 "rawvideo", | |
| 1219 NULL_IF_CONFIG_SMALL("raw video format"), | |
| 1220 0, | |
| 1221 NULL, | |
| 1222 raw_read_header, | |
| 1223 rawvideo_read_packet, | |
| 1224 .flags= AVFMT_GENERIC_INDEX, | |
| 1225 .extensions = "yuv,cif,qcif,rgb", | |
| 1226 .value = CODEC_ID_RAWVIDEO, | |
| 1227 }; | |
| 1228 #endif | |
| 1229 | |
| 1230 #if CONFIG_RAWVIDEO_MUXER | |
| 1231 AVOutputFormat rawvideo_muxer = { | |
| 1232 "rawvideo", | |
| 1233 NULL_IF_CONFIG_SMALL("raw video format"), | |
| 1234 NULL, | |
| 1235 "yuv,rgb", | |
| 1236 0, | |
| 1237 CODEC_ID_NONE, | |
| 1238 CODEC_ID_RAWVIDEO, | |
| 1239 NULL, | |
| 1240 raw_write_packet, | |
| 1241 .flags= AVFMT_NOTIMESTAMPS, | |
| 1242 }; | |
| 1243 #endif | |
| 1244 | |
| 1245 #if CONFIG_ROQ_MUXER | |
| 1246 AVOutputFormat roq_muxer = | |
| 1247 { | |
| 1248 "RoQ", | |
| 1249 NULL_IF_CONFIG_SMALL("raw id RoQ format"), | |
| 1250 NULL, | |
| 1251 "roq", | |
| 1252 0, | |
| 1253 CODEC_ID_ROQ_DPCM, | |
| 1254 CODEC_ID_ROQ, | |
| 1255 roq_write_header, | |
| 1256 raw_write_packet, | |
| 1257 }; | |
| 1258 #endif | |
| 1259 | |
| 1260 #if CONFIG_SHORTEN_DEMUXER | |
| 1261 AVInputFormat shorten_demuxer = { | |
| 1262 "shn", | |
| 1263 NULL_IF_CONFIG_SMALL("raw Shorten"), | |
| 1264 0, | |
| 1265 NULL, | |
| 1266 audio_read_header, | |
| 1267 ff_raw_read_partial_packet, | |
| 1268 .flags= AVFMT_GENERIC_INDEX, | |
| 1269 .extensions = "shn", | |
| 1270 .value = CODEC_ID_SHORTEN, | |
| 1271 }; | |
| 1272 #endif | |
| 1273 | |
| 1274 #if CONFIG_VC1_DEMUXER | |
| 1275 AVInputFormat vc1_demuxer = { | |
| 1276 "vc1", | |
| 1277 NULL_IF_CONFIG_SMALL("raw VC-1"), | |
| 1278 0, | |
| 1279 NULL /* vc1_probe */, | |
| 1280 video_read_header, | |
| 1281 ff_raw_read_partial_packet, | |
| 1282 .extensions = "vc1", | |
| 1283 .value = CODEC_ID_VC1, | |
| 1284 }; | |
| 1285 #endif | |
| 1286 | |
| 1287 /* PCM formats */ | |
| 1288 | |
| 1289 #define PCMINPUTDEF(name, long_name, ext, codec) \ | |
| 1290 AVInputFormat pcm_ ## name ## _demuxer = {\ | |
| 1291 #name,\ | |
| 1292 NULL_IF_CONFIG_SMALL(long_name),\ | |
| 1293 0,\ | |
| 1294 NULL,\ | |
| 1295 raw_read_header,\ | |
| 1296 raw_read_packet,\ | |
| 1297 NULL,\ | |
| 1298 pcm_read_seek,\ | |
| 1299 .flags= AVFMT_GENERIC_INDEX,\ | |
| 1300 .extensions = ext,\ | |
| 1301 .value = codec,\ | |
| 1302 }; | |
| 1303 | |
| 1304 #define PCMOUTPUTDEF(name, long_name, ext, codec) \ | |
| 1305 AVOutputFormat pcm_ ## name ## _muxer = {\ | |
| 1306 #name,\ | |
| 1307 NULL_IF_CONFIG_SMALL(long_name),\ | |
| 1308 NULL,\ | |
| 1309 ext,\ | |
| 1310 0,\ | |
| 1311 codec,\ | |
| 1312 CODEC_ID_NONE,\ | |
| 1313 NULL,\ | |
| 1314 raw_write_packet,\ | |
| 1315 .flags= AVFMT_NOTIMESTAMPS,\ | |
| 1316 }; | |
| 1317 | |
| 1318 | |
| 1319 #if !CONFIG_MUXERS && CONFIG_DEMUXERS | |
| 1320 #define PCMDEF(name, long_name, ext, codec) \ | |
| 1321 PCMINPUTDEF(name, long_name, ext, codec) | |
| 1322 #elif CONFIG_MUXERS && !CONFIG_DEMUXERS | |
| 1323 #define PCMDEF(name, long_name, ext, codec) \ | |
| 1324 PCMOUTPUTDEF(name, long_name, ext, codec) | |
| 1325 #elif CONFIG_MUXERS && CONFIG_DEMUXERS | |
| 1326 #define PCMDEF(name, long_name, ext, codec) \ | |
| 1327 PCMINPUTDEF(name, long_name, ext, codec)\ | |
| 1328 PCMOUTPUTDEF(name, long_name, ext, codec) | |
| 1329 #else | |
| 1330 #define PCMDEF(name, long_name, ext, codec) | |
| 1331 #endif | |
| 1332 | |
| 1333 #if HAVE_BIGENDIAN | |
| 1334 #define BE_DEF(s) s | |
| 1335 #define LE_DEF(s) NULL | |
| 1336 #else | |
| 1337 #define BE_DEF(s) NULL | |
| 1338 #define LE_DEF(s) s | |
| 1339 #endif | |
| 1340 | |
| 1341 PCMDEF(f64be, "PCM 64 bit floating-point big-endian format", | |
| 1342 NULL, CODEC_ID_PCM_F64BE) | |
| 1343 | |
| 1344 PCMDEF(f64le, "PCM 64 bit floating-point little-endian format", | |
| 1345 NULL, CODEC_ID_PCM_F64LE) | |
| 1346 | |
| 1347 PCMDEF(f32be, "PCM 32 bit floating-point big-endian format", | |
| 1348 NULL, CODEC_ID_PCM_F32BE) | |
| 1349 | |
| 1350 PCMDEF(f32le, "PCM 32 bit floating-point little-endian format", | |
| 1351 NULL, CODEC_ID_PCM_F32LE) | |
| 1352 | |
| 1353 PCMDEF(s32be, "PCM signed 32 bit big-endian format", | |
| 1354 NULL, CODEC_ID_PCM_S32BE) | |
| 1355 | |
| 1356 PCMDEF(s32le, "PCM signed 32 bit little-endian format", | |
| 1357 NULL, CODEC_ID_PCM_S32LE) | |
| 1358 | |
| 1359 PCMDEF(s24be, "PCM signed 24 bit big-endian format", | |
| 1360 NULL, CODEC_ID_PCM_S24BE) | |
| 1361 | |
| 1362 PCMDEF(s24le, "PCM signed 24 bit little-endian format", | |
| 1363 NULL, CODEC_ID_PCM_S24LE) | |
| 1364 | |
| 1365 PCMDEF(s16be, "PCM signed 16 bit big-endian format", | |
| 1366 BE_DEF("sw"), CODEC_ID_PCM_S16BE) | |
| 1367 | |
| 1368 PCMDEF(s16le, "PCM signed 16 bit little-endian format", | |
| 1369 LE_DEF("sw"), CODEC_ID_PCM_S16LE) | |
| 1370 | |
| 1371 PCMDEF(s8, "PCM signed 8 bit format", | |
| 1372 "sb", CODEC_ID_PCM_S8) | |
| 1373 | |
| 1374 PCMDEF(u32be, "PCM unsigned 32 bit big-endian format", | |
| 1375 NULL, CODEC_ID_PCM_U32BE) | |
| 1376 | |
| 1377 PCMDEF(u32le, "PCM unsigned 32 bit little-endian format", | |
| 1378 NULL, CODEC_ID_PCM_U32LE) | |
| 1379 | |
| 1380 PCMDEF(u24be, "PCM unsigned 24 bit big-endian format", | |
| 1381 NULL, CODEC_ID_PCM_U24BE) | |
| 1382 | |
| 1383 PCMDEF(u24le, "PCM unsigned 24 bit little-endian format", | |
| 1384 NULL, CODEC_ID_PCM_U24LE) | |
| 1385 | |
| 1386 PCMDEF(u16be, "PCM unsigned 16 bit big-endian format", | |
| 1387 BE_DEF("uw"), CODEC_ID_PCM_U16BE) | |
| 1388 | |
| 1389 PCMDEF(u16le, "PCM unsigned 16 bit little-endian format", | |
| 1390 LE_DEF("uw"), CODEC_ID_PCM_U16LE) | |
| 1391 | |
| 1392 PCMDEF(u8, "PCM unsigned 8 bit format", | |
| 1393 "ub", CODEC_ID_PCM_U8) | |
| 1394 | |
| 1395 PCMDEF(alaw, "PCM A-law format", | |
| 1396 "al", CODEC_ID_PCM_ALAW) | |
| 1397 | |
| 1398 PCMDEF(mulaw, "PCM mu-law format", | |
| 1399 "ul", CODEC_ID_PCM_MULAW) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3384002:
ffmpeg source update for sep 09 (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/ffmpeg/