1/* 2 * "Real" compatible demuxer. 3 * Copyright (c) 2000, 2001 Fabrice Bellard 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include "libavutil/avstring.h" 23#include "libavutil/intreadwrite.h" 24#include "avformat.h" 25#include "rm.h" 26 27struct RMStream { 28 AVPacket pkt; ///< place to store merged video frame / reordered audio data 29 int videobufsize; ///< current assembled frame size 30 int videobufpos; ///< position for the next slice in the video buffer 31 int curpic_num; ///< picture number of current frame 32 int cur_slice, slices; 33 int64_t pktpos; ///< first slice position in file 34 /// Audio descrambling matrix parameters 35 int64_t audiotimestamp; ///< Audio packet timestamp 36 int sub_packet_cnt; // Subpacket counter, used while reading 37 int sub_packet_size, sub_packet_h, coded_framesize; ///< Descrambling parameters from container 38 int audio_framesize; /// Audio frame size from container 39 int sub_packet_lengths[16]; /// Length of each subpacket 40}; 41 42typedef struct { 43 int nb_packets; 44 int old_format; 45 int current_stream; 46 int remaining_len; 47 int audio_stream_num; ///< Stream number for audio packets 48 int audio_pkt_cnt; ///< Output packet counter 49} RMDemuxContext; 50 51static inline void get_strl(ByteIOContext *pb, char *buf, int buf_size, int len) 52{ 53 int i; 54 char *q, r; 55 56 q = buf; 57 for(i=0;i<len;i++) { 58 r = get_byte(pb); 59 if (i < buf_size - 1) 60 *q++ = r; 61 } 62 if (buf_size > 0) *q = '\0'; 63} 64 65static void get_str8(ByteIOContext *pb, char *buf, int buf_size) 66{ 67 get_strl(pb, buf, buf_size, get_byte(pb)); 68} 69 70static void rm_read_metadata(AVFormatContext *s, int wide) 71{ 72 char buf[1024]; 73 int i; 74 for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) { 75 int len = wide ? get_be16(s->pb) : get_byte(s->pb); 76 get_strl(s->pb, buf, sizeof(buf), len); 77 av_metadata_set(&s->metadata, ff_rm_metadata[i], buf); 78 } 79} 80 81RMStream *ff_rm_alloc_rmstream (void) 82{ 83 RMStream *rms = av_mallocz(sizeof(RMStream)); 84 rms->curpic_num = -1; 85 return rms; 86} 87 88void ff_rm_free_rmstream (RMStream *rms) 89{ 90 av_free_packet(&rms->pkt); 91} 92 93static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb, 94 AVStream *st, RMStream *ast, int read_all) 95{ 96 char buf[256]; 97 uint32_t version; 98 99 /* ra type header */ 100 version = get_be32(pb); /* version */ 101 if (((version >> 16) & 0xff) == 3) { 102 int64_t startpos = url_ftell(pb); 103 url_fskip(pb, 14); 104 rm_read_metadata(s, 0); 105 if ((startpos + (version & 0xffff)) >= url_ftell(pb) + 2) { 106 // fourcc (should always be "lpcJ") 107 get_byte(pb); 108 get_str8(pb, buf, sizeof(buf)); 109 } 110 // Skip extra header crap (this should never happen) 111 if ((startpos + (version & 0xffff)) > url_ftell(pb)) 112 url_fskip(pb, (version & 0xffff) + startpos - url_ftell(pb)); 113 st->codec->sample_rate = 8000; 114 st->codec->channels = 1; 115 st->codec->codec_type = CODEC_TYPE_AUDIO; 116 st->codec->codec_id = CODEC_ID_RA_144; 117 } else { 118 int flavor, sub_packet_h, coded_framesize, sub_packet_size; 119 /* old version (4) */ 120 get_be32(pb); /* .ra4 */ 121 get_be32(pb); /* data size */ 122 get_be16(pb); /* version2 */ 123 get_be32(pb); /* header size */ 124 flavor= get_be16(pb); /* add codec info / flavor */ 125 ast->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */ 126 get_be32(pb); /* ??? */ 127 get_be32(pb); /* ??? */ 128 get_be32(pb); /* ??? */ 129 ast->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */ 130 st->codec->block_align= get_be16(pb); /* frame size */ 131 ast->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */ 132 get_be16(pb); /* ??? */ 133 if (((version >> 16) & 0xff) == 5) { 134 get_be16(pb); get_be16(pb); get_be16(pb); 135 } 136 st->codec->sample_rate = get_be16(pb); 137 get_be32(pb); 138 st->codec->channels = get_be16(pb); 139 if (((version >> 16) & 0xff) == 5) { 140 get_be32(pb); 141 get_buffer(pb, buf, 4); 142 buf[4] = 0; 143 } else { 144 get_str8(pb, buf, sizeof(buf)); /* desc */ 145 get_str8(pb, buf, sizeof(buf)); /* desc */ 146 } 147 st->codec->codec_type = CODEC_TYPE_AUDIO; 148 if (!strcmp(buf, "dnet")) { 149 st->codec->codec_id = CODEC_ID_AC3; 150 st->need_parsing = AVSTREAM_PARSE_FULL; 151 } else if (!strcmp(buf, "28_8")) { 152 st->codec->codec_id = CODEC_ID_RA_288; 153 st->codec->extradata_size= 0; 154 ast->audio_framesize = st->codec->block_align; 155 st->codec->block_align = coded_framesize; 156 157 if(ast->audio_framesize >= UINT_MAX / sub_packet_h){ 158 av_log(s, AV_LOG_ERROR, "ast->audio_framesize * sub_packet_h too large\n"); 159 return -1; 160 } 161 162 av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h); 163 } else if ((!strcmp(buf, "cook")) || (!strcmp(buf, "atrc")) || (!strcmp(buf, "sipr"))) { 164 int codecdata_length; 165 get_be16(pb); get_byte(pb); 166 if (((version >> 16) & 0xff) == 5) 167 get_byte(pb); 168 codecdata_length = get_be32(pb); 169 if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ 170 av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); 171 return -1; 172 } 173 174 if(sub_packet_size <= 0){ 175 av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n"); 176 return -1; 177 } 178 179 if (!strcmp(buf, "cook")) st->codec->codec_id = CODEC_ID_COOK; 180 else if (!strcmp(buf, "sipr")) st->codec->codec_id = CODEC_ID_SIPR; 181 else st->codec->codec_id = CODEC_ID_ATRAC3; 182 st->codec->extradata_size= codecdata_length; 183 st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); 184 get_buffer(pb, st->codec->extradata, st->codec->extradata_size); 185 ast->audio_framesize = st->codec->block_align; 186 st->codec->block_align = ast->sub_packet_size; 187 188 if(ast->audio_framesize >= UINT_MAX / sub_packet_h){ 189 av_log(s, AV_LOG_ERROR, "rm->audio_framesize * sub_packet_h too large\n"); 190 return -1; 191 } 192 193 av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h); 194 } else if (!strcmp(buf, "raac") || !strcmp(buf, "racp")) { 195 int codecdata_length; 196 get_be16(pb); get_byte(pb); 197 if (((version >> 16) & 0xff) == 5) 198 get_byte(pb); 199 st->codec->codec_id = CODEC_ID_AAC; 200 codecdata_length = get_be32(pb); 201 if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ 202 av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); 203 return -1; 204 } 205 if (codecdata_length >= 1) { 206 st->codec->extradata_size = codecdata_length - 1; 207 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); 208 get_byte(pb); 209 get_buffer(pb, st->codec->extradata, st->codec->extradata_size); 210 } 211 } else { 212 st->codec->codec_id = CODEC_ID_NONE; 213 av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name)); 214 } 215 if (read_all) { 216 get_byte(pb); 217 get_byte(pb); 218 get_byte(pb); 219 rm_read_metadata(s, 0); 220 } 221 } 222 return 0; 223} 224 225int 226ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb, 227 AVStream *st, RMStream *rst, int codec_data_size) 228{ 229 unsigned int v; 230 int size; 231 int64_t codec_pos; 232 233 av_set_pts_info(st, 64, 1, 1000); 234 codec_pos = url_ftell(pb); 235 v = get_be32(pb); 236 if (v == MKTAG(0xfd, 'a', 'r', '.')) { 237 /* ra type header */ 238 if (rm_read_audio_stream_info(s, pb, st, rst, 0)) 239 return -1; 240 } else { 241 int fps, fps2; 242 if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) { 243 fail1: 244 av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n"); 245 goto skip; 246 } 247 st->codec->codec_tag = get_le32(pb); 248// av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0')); 249 if ( st->codec->codec_tag != MKTAG('R', 'V', '1', '0') 250 && st->codec->codec_tag != MKTAG('R', 'V', '2', '0') 251 && st->codec->codec_tag != MKTAG('R', 'V', '3', '0') 252 && st->codec->codec_tag != MKTAG('R', 'V', '4', '0') 253 && st->codec->codec_tag != MKTAG('R', 'V', 'T', 'R')) 254 goto fail1; 255 st->codec->width = get_be16(pb); 256 st->codec->height = get_be16(pb); 257 st->codec->time_base.num= 1; 258 fps= get_be16(pb); 259 st->codec->codec_type = CODEC_TYPE_VIDEO; 260 get_be32(pb); 261 fps2= get_be16(pb); 262 get_be16(pb); 263 264 st->codec->extradata_size= codec_data_size - (url_ftell(pb) - codec_pos); 265 266 if(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){ 267 //check is redundant as get_buffer() will catch this 268 av_log(s, AV_LOG_ERROR, "st->codec->extradata_size too large\n"); 269 return -1; 270 } 271 st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); 272 if (!st->codec->extradata) 273 return AVERROR(ENOMEM); 274 get_buffer(pb, st->codec->extradata, st->codec->extradata_size); 275 276// av_log(s, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2); 277 st->codec->time_base.den = fps * st->codec->time_base.num; 278 switch(((uint8_t*)st->codec->extradata)[4]>>4){ 279 case 1: st->codec->codec_id = CODEC_ID_RV10; break; 280 case 2: st->codec->codec_id = CODEC_ID_RV20; break; 281 case 3: st->codec->codec_id = CODEC_ID_RV30; break; 282 case 4: st->codec->codec_id = CODEC_ID_RV40; break; 283 default: goto fail1; 284 } 285 } 286 287skip: 288 /* skip codec info */ 289 size = url_ftell(pb) - codec_pos; 290 url_fskip(pb, codec_data_size - size); 291 292 return 0; 293} 294 295 296static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap) 297{ 298 RMDemuxContext *rm = s->priv_data; 299 AVStream *st; 300 301 rm->old_format = 1; 302 st = av_new_stream(s, 0); 303 if (!st) 304 return -1; 305 st->priv_data = ff_rm_alloc_rmstream(); 306 return rm_read_audio_stream_info(s, s->pb, st, st->priv_data, 1); 307} 308 309static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) 310{ 311 RMDemuxContext *rm = s->priv_data; 312 AVStream *st; 313 ByteIOContext *pb = s->pb; 314 unsigned int tag; 315 int tag_size; 316 unsigned int start_time, duration; 317 char buf[128]; 318 int flags = 0; 319 320 tag = get_le32(pb); 321 if (tag == MKTAG('.', 'r', 'a', 0xfd)) { 322 /* very old .ra format */ 323 return rm_read_header_old(s, ap); 324 } else if (tag != MKTAG('.', 'R', 'M', 'F')) { 325 return AVERROR(EIO); 326 } 327 328 get_be32(pb); /* header size */ 329 get_be16(pb); 330 get_be32(pb); 331 get_be32(pb); /* number of headers */ 332 333 for(;;) { 334 if (url_feof(pb)) 335 return -1; 336 tag = get_le32(pb); 337 tag_size = get_be32(pb); 338 get_be16(pb); 339#if 0 340 printf("tag=%c%c%c%c (%08x) size=%d\n", 341 (tag) & 0xff, 342 (tag >> 8) & 0xff, 343 (tag >> 16) & 0xff, 344 (tag >> 24) & 0xff, 345 tag, 346 tag_size); 347#endif 348 if (tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A')) 349 return -1; 350 switch(tag) { 351 case MKTAG('P', 'R', 'O', 'P'): 352 /* file header */ 353 get_be32(pb); /* max bit rate */ 354 get_be32(pb); /* avg bit rate */ 355 get_be32(pb); /* max packet size */ 356 get_be32(pb); /* avg packet size */ 357 get_be32(pb); /* nb packets */ 358 get_be32(pb); /* duration */ 359 get_be32(pb); /* preroll */ 360 get_be32(pb); /* index offset */ 361 get_be32(pb); /* data offset */ 362 get_be16(pb); /* nb streams */ 363 flags = get_be16(pb); /* flags */ 364 break; 365 case MKTAG('C', 'O', 'N', 'T'): 366 rm_read_metadata(s, 1); 367 break; 368 case MKTAG('M', 'D', 'P', 'R'): 369 st = av_new_stream(s, 0); 370 if (!st) 371 return AVERROR(ENOMEM); 372 st->id = get_be16(pb); 373 get_be32(pb); /* max bit rate */ 374 st->codec->bit_rate = get_be32(pb); /* bit rate */ 375 get_be32(pb); /* max packet size */ 376 get_be32(pb); /* avg packet size */ 377 start_time = get_be32(pb); /* start time */ 378 get_be32(pb); /* preroll */ 379 duration = get_be32(pb); /* duration */ 380 st->start_time = start_time; 381 st->duration = duration; 382 get_str8(pb, buf, sizeof(buf)); /* desc */ 383 get_str8(pb, buf, sizeof(buf)); /* mimetype */ 384 st->codec->codec_type = CODEC_TYPE_DATA; 385 st->priv_data = ff_rm_alloc_rmstream(); 386 if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data, 387 get_be32(pb)) < 0) 388 return -1; 389 break; 390 case MKTAG('D', 'A', 'T', 'A'): 391 goto header_end; 392 default: 393 /* unknown tag: skip it */ 394 url_fskip(pb, tag_size - 10); 395 break; 396 } 397 } 398 header_end: 399 rm->nb_packets = get_be32(pb); /* number of packets */ 400 if (!rm->nb_packets && (flags & 4)) 401 rm->nb_packets = 3600 * 25; 402 get_be32(pb); /* next data header */ 403 return 0; 404} 405 406static int get_num(ByteIOContext *pb, int *len) 407{ 408 int n, n1; 409 410 n = get_be16(pb); 411 (*len)-=2; 412 n &= 0x7FFF; 413 if (n >= 0x4000) { 414 return n - 0x4000; 415 } else { 416 n1 = get_be16(pb); 417 (*len)-=2; 418 return (n << 16) | n1; 419 } 420} 421 422/* multiple of 20 bytes for ra144 (ugly) */ 423#define RAW_PACKET_SIZE 1000 424 425static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){ 426 RMDemuxContext *rm = s->priv_data; 427 ByteIOContext *pb = s->pb; 428 int len, num, res, i; 429 AVStream *st; 430 uint32_t state=0xFFFFFFFF; 431 432 while(!url_feof(pb)){ 433 *pos= url_ftell(pb) - 3; 434 if(rm->remaining_len > 0){ 435 num= rm->current_stream; 436 len= rm->remaining_len; 437 *timestamp = AV_NOPTS_VALUE; 438 *flags= 0; 439 }else{ 440 state= (state<<8) + get_byte(pb); 441 442 if(state == MKBETAG('I', 'N', 'D', 'X')){ 443 len = get_be16(pb) - 6; 444 if(len<0) 445 continue; 446 goto skip; 447 } 448 449 if(state > (unsigned)0xFFFF || state < 12) 450 continue; 451 len=state; 452 state= 0xFFFFFFFF; 453 454 num = get_be16(pb); 455 *timestamp = get_be32(pb); 456 res= get_byte(pb); /* reserved */ 457 *flags = get_byte(pb); /* flags */ 458 459 460 len -= 12; 461 } 462 for(i=0;i<s->nb_streams;i++) { 463 st = s->streams[i]; 464 if (num == st->id) 465 break; 466 } 467 if (i == s->nb_streams) { 468skip: 469 /* skip packet if unknown number */ 470 url_fskip(pb, len); 471 rm->remaining_len -= len; 472 continue; 473 } 474 *stream_index= i; 475 476 return len; 477 } 478 return -1; 479} 480 481static int rm_assemble_video_frame(AVFormatContext *s, ByteIOContext *pb, 482 RMDemuxContext *rm, RMStream *vst, 483 AVPacket *pkt, int len) 484{ 485 int hdr, seq, pic_num, len2, pos; 486 int type; 487 488 hdr = get_byte(pb); len--; 489 type = hdr >> 6; 490 491 if(type != 3){ // not frame as a part of packet 492 seq = get_byte(pb); len--; 493 } 494 if(type != 1){ // not whole frame 495 len2 = get_num(pb, &len); 496 pos = get_num(pb, &len); 497 pic_num = get_byte(pb); len--; 498 } 499 if(len<0) 500 return -1; 501 rm->remaining_len = len; 502 if(type&1){ // frame, not slice 503 if(type == 3) // frame as a part of packet 504 len= len2; 505 if(rm->remaining_len < len) 506 return -1; 507 rm->remaining_len -= len; 508 if(av_new_packet(pkt, len + 9) < 0) 509 return AVERROR(EIO); 510 pkt->data[0] = 0; 511 AV_WL32(pkt->data + 1, 1); 512 AV_WL32(pkt->data + 5, 0); 513 get_buffer(pb, pkt->data + 9, len); 514 return 0; 515 } 516 //now we have to deal with single slice 517 518 if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){ 519 vst->slices = ((hdr & 0x3F) << 1) + 1; 520 vst->videobufsize = len2 + 8*vst->slices + 1; 521 av_free_packet(&vst->pkt); //FIXME this should be output. 522 if(av_new_packet(&vst->pkt, vst->videobufsize) < 0) 523 return AVERROR(ENOMEM); 524 vst->videobufpos = 8*vst->slices + 1; 525 vst->cur_slice = 0; 526 vst->curpic_num = pic_num; 527 vst->pktpos = url_ftell(pb); 528 } 529 if(type == 2) 530 len = FFMIN(len, pos); 531 532 if(++vst->cur_slice > vst->slices) 533 return 1; 534 AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1); 535 AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1); 536 if(vst->videobufpos + len > vst->videobufsize) 537 return 1; 538 if (get_buffer(pb, vst->pkt.data + vst->videobufpos, len) != len) 539 return AVERROR(EIO); 540 vst->videobufpos += len; 541 rm->remaining_len-= len; 542 543 if(type == 2 || (vst->videobufpos) == vst->videobufsize){ 544 vst->pkt.data[0] = vst->cur_slice-1; 545 *pkt= vst->pkt; 546 vst->pkt.data= NULL; 547 vst->pkt.size= 0; 548 if(vst->slices != vst->cur_slice) //FIXME find out how to set slices correct from the begin 549 memmove(pkt->data + 1 + 8*vst->cur_slice, pkt->data + 1 + 8*vst->slices, 550 vst->videobufpos - 1 - 8*vst->slices); 551 pkt->size = vst->videobufpos + 8*(vst->cur_slice - vst->slices); 552 pkt->pts = AV_NOPTS_VALUE; 553 pkt->pos = vst->pktpos; 554 return 0; 555 } 556 557 return 1; 558} 559 560static inline void 561rm_ac3_swap_bytes (AVStream *st, AVPacket *pkt) 562{ 563 uint8_t *ptr; 564 int j; 565 566 if (st->codec->codec_id == CODEC_ID_AC3) { 567 ptr = pkt->data; 568 for (j=0;j<pkt->size;j+=2) { 569 FFSWAP(int, ptr[0], ptr[1]); 570 ptr += 2; 571 } 572 } 573} 574 575int 576ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb, 577 AVStream *st, RMStream *ast, int len, AVPacket *pkt, 578 int *seq, int *flags, int64_t *timestamp) 579{ 580 RMDemuxContext *rm = s->priv_data; 581 582 if (st->codec->codec_type == CODEC_TYPE_VIDEO) { 583 rm->current_stream= st->id; 584 if(rm_assemble_video_frame(s, pb, rm, ast, pkt, len)) 585 return -1; //got partial frame 586 } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) { 587 if ((st->codec->codec_id == CODEC_ID_RA_288) || 588 (st->codec->codec_id == CODEC_ID_COOK) || 589 (st->codec->codec_id == CODEC_ID_ATRAC3) || 590 (st->codec->codec_id == CODEC_ID_SIPR)) { 591 int x; 592 int sps = ast->sub_packet_size; 593 int cfs = ast->coded_framesize; 594 int h = ast->sub_packet_h; 595 int y = ast->sub_packet_cnt; 596 int w = ast->audio_framesize; 597 598 if (*flags & 2) 599 y = ast->sub_packet_cnt = 0; 600 if (!y) 601 ast->audiotimestamp = *timestamp; 602 603 switch(st->codec->codec_id) { 604 case CODEC_ID_RA_288: 605 for (x = 0; x < h/2; x++) 606 get_buffer(pb, ast->pkt.data+x*2*w+y*cfs, cfs); 607 break; 608 case CODEC_ID_ATRAC3: 609 case CODEC_ID_COOK: 610 for (x = 0; x < w/sps; x++) 611 get_buffer(pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps); 612 break; 613 } 614 615 if (++(ast->sub_packet_cnt) < h) 616 return -1; 617 else { 618 ast->sub_packet_cnt = 0; 619 rm->audio_stream_num = st->index; 620 rm->audio_pkt_cnt = h * w / st->codec->block_align - 1; 621 // Release first audio packet 622 av_new_packet(pkt, st->codec->block_align); 623 memcpy(pkt->data, ast->pkt.data, st->codec->block_align); //FIXME avoid this 624 *timestamp = ast->audiotimestamp; 625 *flags = 2; // Mark first packet as keyframe 626 } 627 } else if (st->codec->codec_id == CODEC_ID_AAC) { 628 int x; 629 rm->audio_stream_num = st->index; 630 ast->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4; 631 if (ast->sub_packet_cnt) { 632 for (x = 0; x < ast->sub_packet_cnt; x++) 633 ast->sub_packet_lengths[x] = get_be16(pb); 634 // Release first audio packet 635 rm->audio_pkt_cnt = ast->sub_packet_cnt - 1; 636 av_get_packet(pb, pkt, ast->sub_packet_lengths[0]); 637 *flags = 2; // Mark first packet as keyframe 638 } 639 } else { 640 av_get_packet(pb, pkt, len); 641 rm_ac3_swap_bytes(st, pkt); 642 } 643 } else 644 av_get_packet(pb, pkt, len); 645 646 if( (st->discard >= AVDISCARD_NONKEY && !(*flags&2)) 647 || st->discard >= AVDISCARD_ALL){ 648 av_free_packet(pkt); 649 return -1; 650 } 651 652 pkt->stream_index = st->index; 653 654#if 0 655 if (st->codec->codec_type == CODEC_TYPE_VIDEO) { 656 if(st->codec->codec_id == CODEC_ID_RV20){ 657 int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1); 658 av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq); 659 660 seq |= (*timestamp&~0x3FFF); 661 if(seq - *timestamp > 0x2000) seq -= 0x4000; 662 if(seq - *timestamp < -0x2000) seq += 0x4000; 663 } 664 } 665#endif 666 667 pkt->pts= *timestamp; 668 if (*flags & 2) 669 pkt->flags |= PKT_FLAG_KEY; 670 671 return st->codec->codec_type == CODEC_TYPE_AUDIO ? rm->audio_pkt_cnt : 0; 672} 673 674int 675ff_rm_retrieve_cache (AVFormatContext *s, ByteIOContext *pb, 676 AVStream *st, RMStream *ast, AVPacket *pkt) 677{ 678 RMDemuxContext *rm = s->priv_data; 679 680 assert (rm->audio_pkt_cnt > 0); 681 682 if (st->codec->codec_id == CODEC_ID_AAC) 683 av_get_packet(pb, pkt, ast->sub_packet_lengths[ast->sub_packet_cnt - rm->audio_pkt_cnt]); 684 else { 685 av_new_packet(pkt, st->codec->block_align); 686 memcpy(pkt->data, ast->pkt.data + st->codec->block_align * //FIXME avoid this 687 (ast->sub_packet_h * ast->audio_framesize / st->codec->block_align - rm->audio_pkt_cnt), 688 st->codec->block_align); 689 } 690 rm->audio_pkt_cnt--; 691 pkt->flags = 0; 692 pkt->stream_index = st->index; 693 694 return rm->audio_pkt_cnt; 695} 696 697static int rm_read_packet(AVFormatContext *s, AVPacket *pkt) 698{ 699 RMDemuxContext *rm = s->priv_data; 700 ByteIOContext *pb = s->pb; 701 AVStream *st; 702 int i, len; 703 int64_t timestamp, pos; 704 int flags; 705 706 if (rm->audio_pkt_cnt) { 707 // If there are queued audio packet return them first 708 st = s->streams[rm->audio_stream_num]; 709 ff_rm_retrieve_cache(s, s->pb, st, st->priv_data, pkt); 710 } else if (rm->old_format) { 711 RMStream *ast; 712 713 st = s->streams[0]; 714 ast = st->priv_data; 715 if (st->codec->codec_id == CODEC_ID_RA_288) { 716 int x, y; 717 718 for (y = 0; y < ast->sub_packet_h; y++) 719 for (x = 0; x < ast->sub_packet_h/2; x++) 720 if (get_buffer(pb, ast->pkt.data+x*2*ast->audio_framesize+y*ast->coded_framesize, ast->coded_framesize) <= 0) 721 return AVERROR(EIO); 722 rm->audio_stream_num = 0; 723 rm->audio_pkt_cnt = ast->sub_packet_h * ast->audio_framesize / st->codec->block_align - 1; 724 // Release first audio packet 725 av_new_packet(pkt, st->codec->block_align); 726 memcpy(pkt->data, ast->pkt.data, st->codec->block_align); //FIXME avoid this 727 pkt->flags |= PKT_FLAG_KEY; // Mark first packet as keyframe 728 pkt->stream_index = 0; 729 } else { 730 /* just read raw bytes */ 731 len = RAW_PACKET_SIZE; 732 len= av_get_packet(pb, pkt, len); 733 pkt->stream_index = 0; 734 if (len <= 0) { 735 return AVERROR(EIO); 736 } 737 pkt->size = len; 738 } 739 rm_ac3_swap_bytes(st, pkt); 740 } else { 741 int seq=1; 742resync: 743 len=sync(s, ×tamp, &flags, &i, &pos); 744 if(len<0) 745 return AVERROR(EIO); 746 st = s->streams[i]; 747 748 if (ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt, 749 &seq, &flags, ×tamp) < 0) 750 goto resync; 751 752 if((flags&2) && (seq&0x7F) == 1) 753 av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME); 754 } 755 756 return 0; 757} 758 759static int rm_read_close(AVFormatContext *s) 760{ 761 int i; 762 763 for (i=0;i<s->nb_streams;i++) 764 ff_rm_free_rmstream(s->streams[i]->priv_data); 765 766 return 0; 767} 768 769static int rm_probe(AVProbeData *p) 770{ 771 /* check file header */ 772 if ((p->buf[0] == '.' && p->buf[1] == 'R' && 773 p->buf[2] == 'M' && p->buf[3] == 'F' && 774 p->buf[4] == 0 && p->buf[5] == 0) || 775 (p->buf[0] == '.' && p->buf[1] == 'r' && 776 p->buf[2] == 'a' && p->buf[3] == 0xfd)) 777 return AVPROBE_SCORE_MAX; 778 else 779 return 0; 780} 781 782static int64_t rm_read_dts(AVFormatContext *s, int stream_index, 783 int64_t *ppos, int64_t pos_limit) 784{ 785 RMDemuxContext *rm = s->priv_data; 786 int64_t pos, dts; 787 int stream_index2, flags, len, h; 788 789 pos = *ppos; 790 791 if(rm->old_format) 792 return AV_NOPTS_VALUE; 793 794 url_fseek(s->pb, pos, SEEK_SET); 795 rm->remaining_len=0; 796 for(;;){ 797 int seq=1; 798 AVStream *st; 799 800 len=sync(s, &dts, &flags, &stream_index2, &pos); 801 if(len<0) 802 return AV_NOPTS_VALUE; 803 804 st = s->streams[stream_index2]; 805 if (st->codec->codec_type == CODEC_TYPE_VIDEO) { 806 h= get_byte(s->pb); len--; 807 if(!(h & 0x40)){ 808 seq = get_byte(s->pb); len--; 809 } 810 } 811 812 if((flags&2) && (seq&0x7F) == 1){ 813// av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq); 814 av_add_index_entry(st, pos, dts, 0, 0, AVINDEX_KEYFRAME); 815 if(stream_index2 == stream_index) 816 break; 817 } 818 819 url_fskip(s->pb, len); 820 } 821 *ppos = pos; 822 return dts; 823} 824 825AVInputFormat rm_demuxer = { 826 "rm", 827 NULL_IF_CONFIG_SMALL("RealMedia format"), 828 sizeof(RMDemuxContext), 829 rm_probe, 830 rm_read_header, 831 rm_read_packet, 832 rm_read_close, 833 NULL, 834 rm_read_dts, 835}; 836 837AVInputFormat rdt_demuxer = { 838 "rdt", 839 NULL_IF_CONFIG_SMALL("RDT demuxer"), 840 sizeof(RMDemuxContext), 841 NULL, 842 NULL, 843 NULL, 844 rm_read_close, 845}; 846