You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

711 lines
22KB

  1. /*
  2. * "Real" compatible mux and demux.
  3. * Copyright (c) 2000, 2001 Gerard Lantau.
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include <stdio.h>
  22. #include <errno.h>
  23. #include "avformat.h"
  24. /* in ms */
  25. #define BUFFER_DURATION 0
  26. typedef struct {
  27. int nb_packets;
  28. int packet_total_size;
  29. int packet_max_size;
  30. /* codec related output */
  31. int bit_rate;
  32. float frame_rate;
  33. int nb_frames; /* current frame number */
  34. int total_frames; /* total number of frames */
  35. int num;
  36. AVCodecContext *enc;
  37. } StreamInfo;
  38. typedef struct {
  39. StreamInfo streams[2];
  40. StreamInfo *audio_stream, *video_stream;
  41. int data_pos; /* position of the data after the header */
  42. int nb_packets;
  43. } RMContext;
  44. static void put_str(ByteIOContext *s, const char *tag)
  45. {
  46. put_be16(s,strlen(tag));
  47. while (*tag) {
  48. put_byte(s, *tag++);
  49. }
  50. }
  51. static void put_str8(ByteIOContext *s, const char *tag)
  52. {
  53. put_byte(s, strlen(tag));
  54. while (*tag) {
  55. put_byte(s, *tag++);
  56. }
  57. }
  58. static void rv10_write_header(AVFormatContext *ctx,
  59. int data_size, int index_pos)
  60. {
  61. RMContext *rm = ctx->priv_data;
  62. ByteIOContext *s = &ctx->pb;
  63. StreamInfo *stream;
  64. unsigned char *data_offset_ptr, *start_ptr;
  65. const char *desc, *mimetype;
  66. int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
  67. int bit_rate, v, duration, flags, data_pos;
  68. start_ptr = s->buf_ptr;
  69. put_tag(s, ".RMF");
  70. put_be32(s,18); /* header size */
  71. put_be16(s,0);
  72. put_be32(s,0);
  73. put_be32(s,4 + ctx->nb_streams); /* num headers */
  74. put_tag(s,"PROP");
  75. put_be32(s, 50);
  76. put_be16(s, 0);
  77. packet_max_size = 0;
  78. packet_total_size = 0;
  79. nb_packets = 0;
  80. bit_rate = 0;
  81. duration = 0;
  82. for(i=0;i<ctx->nb_streams;i++) {
  83. StreamInfo *stream = &rm->streams[i];
  84. bit_rate += stream->bit_rate;
  85. if (stream->packet_max_size > packet_max_size)
  86. packet_max_size = stream->packet_max_size;
  87. nb_packets += stream->nb_packets;
  88. packet_total_size += stream->packet_total_size;
  89. /* select maximum duration */
  90. v = (int) (1000.0 * (float)stream->total_frames / stream->frame_rate);
  91. if (v > duration)
  92. duration = v;
  93. }
  94. put_be32(s, bit_rate); /* max bit rate */
  95. put_be32(s, bit_rate); /* avg bit rate */
  96. put_be32(s, packet_max_size); /* max packet size */
  97. if (nb_packets > 0)
  98. packet_avg_size = packet_total_size / nb_packets;
  99. else
  100. packet_avg_size = 0;
  101. put_be32(s, packet_avg_size); /* avg packet size */
  102. put_be32(s, nb_packets); /* num packets */
  103. put_be32(s, duration); /* duration */
  104. put_be32(s, BUFFER_DURATION); /* preroll */
  105. put_be32(s, index_pos); /* index offset */
  106. /* computation of data the data offset */
  107. data_offset_ptr = s->buf_ptr;
  108. put_be32(s, 0); /* data offset : will be patched after */
  109. put_be16(s, ctx->nb_streams); /* num streams */
  110. flags = 1 | 2; /* save allowed & perfect play */
  111. if (url_is_streamed(s))
  112. flags |= 4; /* live broadcast */
  113. put_be16(s, flags);
  114. /* comments */
  115. put_tag(s,"CONT");
  116. size = strlen(ctx->title) + strlen(ctx->author) + strlen(ctx->copyright) +
  117. strlen(ctx->comment) + 4 * 2 + 10;
  118. put_be32(s,size);
  119. put_be16(s,0);
  120. put_str(s, ctx->title);
  121. put_str(s, ctx->author);
  122. put_str(s, ctx->copyright);
  123. put_str(s, ctx->comment);
  124. for(i=0;i<ctx->nb_streams;i++) {
  125. int codec_data_size;
  126. stream = &rm->streams[i];
  127. if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
  128. desc = "The Audio Stream";
  129. mimetype = "audio/x-pn-realaudio";
  130. codec_data_size = 73;
  131. } else {
  132. desc = "The Video Stream";
  133. mimetype = "video/x-pn-realvideo";
  134. codec_data_size = 34;
  135. }
  136. put_tag(s,"MDPR");
  137. size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
  138. put_be32(s, size);
  139. put_be16(s, 0);
  140. put_be16(s, i); /* stream number */
  141. put_be32(s, stream->bit_rate); /* max bit rate */
  142. put_be32(s, stream->bit_rate); /* avg bit rate */
  143. put_be32(s, stream->packet_max_size); /* max packet size */
  144. if (stream->nb_packets > 0)
  145. packet_avg_size = stream->packet_total_size /
  146. stream->nb_packets;
  147. else
  148. packet_avg_size = 0;
  149. put_be32(s, packet_avg_size); /* avg packet size */
  150. put_be32(s, 0); /* start time */
  151. put_be32(s, BUFFER_DURATION); /* preroll */
  152. /* duration */
  153. put_be32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
  154. put_str8(s, desc);
  155. put_str8(s, mimetype);
  156. put_be32(s, codec_data_size);
  157. if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
  158. int coded_frame_size, fscode, sample_rate;
  159. sample_rate = stream->enc->sample_rate;
  160. coded_frame_size = (stream->enc->bit_rate *
  161. stream->enc->frame_size) / (8 * sample_rate);
  162. /* audio codec info */
  163. put_tag(s, ".ra");
  164. put_byte(s, 0xfd);
  165. put_be32(s, 0x00040000); /* version */
  166. put_tag(s, ".ra4");
  167. put_be32(s, 0x01b53530); /* stream length */
  168. put_be16(s, 4); /* unknown */
  169. put_be32(s, 0x39); /* header size */
  170. switch(sample_rate) {
  171. case 48000:
  172. case 24000:
  173. case 12000:
  174. fscode = 1;
  175. break;
  176. default:
  177. case 44100:
  178. case 22050:
  179. case 11025:
  180. fscode = 2;
  181. break;
  182. case 32000:
  183. case 16000:
  184. case 8000:
  185. fscode = 3;
  186. }
  187. put_be16(s, fscode); /* codec additional info, for AC3, seems
  188. to be a frequency code */
  189. /* special hack to compensate rounding errors... */
  190. if (coded_frame_size == 557)
  191. coded_frame_size--;
  192. put_be32(s, coded_frame_size); /* frame length */
  193. put_be32(s, 0x51540); /* unknown */
  194. put_be32(s, 0x249f0); /* unknown */
  195. put_be32(s, 0x249f0); /* unknown */
  196. put_be16(s, 0x01);
  197. /* frame length : seems to be very important */
  198. put_be16(s, coded_frame_size);
  199. put_be32(s, 0); /* unknown */
  200. put_be16(s, stream->enc->sample_rate); /* sample rate */
  201. put_be32(s, 0x10); /* unknown */
  202. put_be16(s, stream->enc->channels);
  203. put_str8(s, "Int0"); /* codec name */
  204. put_str8(s, "dnet"); /* codec name */
  205. put_be16(s, 0); /* title length */
  206. put_be16(s, 0); /* author length */
  207. put_be16(s, 0); /* copyright length */
  208. put_byte(s, 0); /* end of header */
  209. } else {
  210. /* video codec info */
  211. put_be32(s,34); /* size */
  212. put_tag(s,"VIDORV10");
  213. put_be16(s, stream->enc->width);
  214. put_be16(s, stream->enc->height);
  215. put_be16(s, 24); /* frames per seconds ? */
  216. put_be32(s,0); /* unknown meaning */
  217. put_be16(s, 12); /* unknown meaning */
  218. put_be32(s,0); /* unknown meaning */
  219. put_be16(s, 8); /* unknown meaning */
  220. /* Seems to be the codec version: only use basic H263. The next
  221. versions seems to add a diffential DC coding as in
  222. MPEG... nothing new under the sun */
  223. put_be32(s,0x10000000);
  224. //put_be32(s,0x10003000);
  225. }
  226. }
  227. /* patch data offset field */
  228. data_pos = s->buf_ptr - start_ptr;
  229. rm->data_pos = data_pos;
  230. data_offset_ptr[0] = data_pos >> 24;
  231. data_offset_ptr[1] = data_pos >> 16;
  232. data_offset_ptr[2] = data_pos >> 8;
  233. data_offset_ptr[3] = data_pos;
  234. /* data stream */
  235. put_tag(s,"DATA");
  236. put_be32(s,data_size + 10 + 8);
  237. put_be16(s,0);
  238. put_be32(s, nb_packets); /* number of packets */
  239. put_be32(s,0); /* next data header */
  240. }
  241. static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
  242. int length, int key_frame)
  243. {
  244. int timestamp;
  245. ByteIOContext *s = &ctx->pb;
  246. stream->nb_packets++;
  247. stream->packet_total_size += length;
  248. if (length > stream->packet_max_size)
  249. stream->packet_max_size = length;
  250. put_be16(s,0); /* version */
  251. put_be16(s,length + 12);
  252. put_be16(s, stream->num); /* stream number */
  253. timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate;
  254. put_be32(s, timestamp); /* timestamp */
  255. put_byte(s, 0); /* reserved */
  256. put_byte(s, key_frame ? 2 : 0); /* flags */
  257. }
  258. static int rm_write_header(AVFormatContext *s)
  259. {
  260. StreamInfo *stream;
  261. RMContext *rm;
  262. int n;
  263. AVCodecContext *codec;
  264. rm = malloc(sizeof(RMContext));
  265. if (!rm)
  266. return -1;
  267. memset(rm, 0, sizeof(RMContext));
  268. s->priv_data = rm;
  269. for(n=0;n<s->nb_streams;n++) {
  270. s->streams[n]->id = n;
  271. codec = &s->streams[n]->codec;
  272. stream = &rm->streams[n];
  273. memset(stream, 0, sizeof(StreamInfo));
  274. stream->num = n;
  275. stream->bit_rate = codec->bit_rate;
  276. stream->enc = codec;
  277. switch(codec->codec_type) {
  278. case CODEC_TYPE_AUDIO:
  279. rm->audio_stream = stream;
  280. stream->frame_rate = (float)codec->sample_rate / (float)codec->frame_size;
  281. /* XXX: dummy values */
  282. stream->packet_max_size = 1024;
  283. stream->nb_packets = 0;
  284. stream->total_frames = stream->nb_packets;
  285. break;
  286. case CODEC_TYPE_VIDEO:
  287. rm->video_stream = stream;
  288. stream->frame_rate = (float)codec->frame_rate / (float)FRAME_RATE_BASE;
  289. /* XXX: dummy values */
  290. stream->packet_max_size = 4096;
  291. stream->nb_packets = 0;
  292. stream->total_frames = stream->nb_packets;
  293. break;
  294. }
  295. }
  296. rv10_write_header(s, 0, 0);
  297. put_flush_packet(&s->pb);
  298. return 0;
  299. }
  300. static int rm_write_audio(AVFormatContext *s, UINT8 *buf, int size)
  301. {
  302. UINT8 buf1[size];
  303. RMContext *rm = s->priv_data;
  304. ByteIOContext *pb = &s->pb;
  305. StreamInfo *stream = rm->audio_stream;
  306. int i;
  307. write_packet_header(s, stream, size, stream->enc->key_frame);
  308. /* for AC3, the words seems to be reversed */
  309. for(i=0;i<size;i+=2) {
  310. buf1[i] = buf[i+1];
  311. buf1[i+1] = buf[i];
  312. }
  313. put_buffer(pb, buf1, size);
  314. put_flush_packet(pb);
  315. stream->nb_frames++;
  316. return 0;
  317. }
  318. static int rm_write_video(AVFormatContext *s, UINT8 *buf, int size)
  319. {
  320. RMContext *rm = s->priv_data;
  321. ByteIOContext *pb = &s->pb;
  322. StreamInfo *stream = rm->video_stream;
  323. int key_frame = stream->enc->key_frame;
  324. /* XXX: this is incorrect: should be a parameter */
  325. /* Well, I spent some time finding the meaning of these bits. I am
  326. not sure I understood everything, but it works !! */
  327. #if 1
  328. write_packet_header(s, stream, size + 7, key_frame);
  329. /* bit 7: '1' if final packet of a frame converted in several packets */
  330. put_byte(pb, 0x81);
  331. /* bit 7: '1' if I frame. bits 6..0 : sequence number in current
  332. frame starting from 1 */
  333. if (key_frame) {
  334. put_byte(pb, 0x81);
  335. } else {
  336. put_byte(pb, 0x01);
  337. }
  338. put_be16(pb, 0x4000 | (size)); /* total frame size */
  339. put_be16(pb, 0x4000 | (size)); /* offset from the start or the end */
  340. #else
  341. /* full frame */
  342. write_packet_header(s, size + 6);
  343. put_byte(pb, 0xc0);
  344. put_be16(pb, 0x4000 | size); /* total frame size */
  345. put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */
  346. #endif
  347. put_byte(pb, stream->nb_frames & 0xff);
  348. put_buffer(pb, buf, size);
  349. put_flush_packet(pb);
  350. stream->nb_frames++;
  351. return 0;
  352. }
  353. static int rm_write_packet(AVFormatContext *s, int stream_index,
  354. UINT8 *buf, int size)
  355. {
  356. if (s->streams[stream_index]->codec.codec_type ==
  357. CODEC_TYPE_AUDIO)
  358. return rm_write_audio(s, buf, size);
  359. else
  360. return rm_write_video(s, buf, size);
  361. }
  362. static int rm_write_trailer(AVFormatContext *s)
  363. {
  364. RMContext *rm = s->priv_data;
  365. int data_size, index_pos, i;
  366. ByteIOContext *pb = &s->pb;
  367. if (!url_is_streamed(&s->pb)) {
  368. /* end of file: finish to write header */
  369. index_pos = url_fseek(pb, 0, SEEK_CUR);
  370. data_size = index_pos - rm->data_pos;
  371. /* index */
  372. put_tag(pb, "INDX");
  373. put_be32(pb, 10 + 10 * s->nb_streams);
  374. put_be16(pb, 0);
  375. for(i=0;i<s->nb_streams;i++) {
  376. put_be32(pb, 0); /* zero indices */
  377. put_be16(pb, i); /* stream number */
  378. put_be32(pb, 0); /* next index */
  379. }
  380. /* undocumented end header */
  381. put_be32(pb, 0);
  382. put_be32(pb, 0);
  383. url_fseek(pb, 0, SEEK_SET);
  384. for(i=0;i<s->nb_streams;i++)
  385. rm->streams[i].total_frames = rm->streams[i].nb_frames;
  386. rv10_write_header(s, data_size, index_pos);
  387. } else {
  388. /* undocumented end header */
  389. put_be32(pb, 0);
  390. put_be32(pb, 0);
  391. }
  392. put_flush_packet(pb);
  393. free(rm);
  394. return 0;
  395. }
  396. /***************************************************/
  397. static void get_str(ByteIOContext *pb, char *buf, int buf_size)
  398. {
  399. int len, i;
  400. char *q;
  401. len = get_be16(pb);
  402. q = buf;
  403. for(i=0;i<len;i++) {
  404. if (i < buf_size - 1)
  405. *q++ = get_byte(pb);
  406. }
  407. *q = '\0';
  408. }
  409. static void get_str8(ByteIOContext *pb, char *buf, int buf_size)
  410. {
  411. int len, i;
  412. char *q;
  413. len = get_byte(pb);
  414. q = buf;
  415. for(i=0;i<len;i++) {
  416. if (i < buf_size - 1)
  417. *q++ = get_byte(pb);
  418. }
  419. *q = '\0';
  420. }
  421. static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
  422. {
  423. RMContext *rm;
  424. AVStream *st;
  425. ByteIOContext *pb = &s->pb;
  426. unsigned int tag, v;
  427. int tag_size, size, codec_data_size, i;
  428. INT64 codec_pos;
  429. unsigned int h263_hack_version;
  430. char buf[128];
  431. if (get_le32(pb) != MKTAG('.', 'R', 'M', 'F'))
  432. return -EIO;
  433. rm = av_mallocz(sizeof(RMContext));
  434. if (!rm)
  435. return -ENOMEM;
  436. s->priv_data = rm;
  437. get_be32(pb); /* header size */
  438. get_be16(pb);
  439. get_be32(pb);
  440. get_be32(pb); /* number of headers */
  441. for(;;) {
  442. if (url_feof(pb))
  443. goto fail;
  444. tag = get_le32(pb);
  445. tag_size = get_be32(pb);
  446. get_be16(pb);
  447. #if 0
  448. printf("tag=%c%c%c%c (%08x) size=%d\n",
  449. (tag) & 0xff,
  450. (tag >> 8) & 0xff,
  451. (tag >> 16) & 0xff,
  452. (tag >> 24) & 0xff,
  453. tag,
  454. tag_size);
  455. #endif
  456. if (tag_size < 10)
  457. goto fail;
  458. switch(tag) {
  459. case MKTAG('P', 'R', 'O', 'P'):
  460. /* file header */
  461. get_be32(pb); /* max bit rate */
  462. get_be32(pb); /* avg bit rate */
  463. get_be32(pb); /* max packet size */
  464. get_be32(pb); /* avg packet size */
  465. get_be32(pb); /* nb packets */
  466. get_be32(pb); /* duration */
  467. get_be32(pb); /* preroll */
  468. get_be32(pb); /* index offset */
  469. get_be32(pb); /* data offset */
  470. get_be16(pb); /* nb streams */
  471. get_be16(pb); /* flags */
  472. break;
  473. case MKTAG('C', 'O', 'N', 'T'):
  474. get_str(pb, s->title, sizeof(s->title));
  475. get_str(pb, s->author, sizeof(s->author));
  476. get_str(pb, s->copyright, sizeof(s->copyright));
  477. get_str(pb, s->comment, sizeof(s->comment));
  478. break;
  479. case MKTAG('M', 'D', 'P', 'R'):
  480. st = av_mallocz(sizeof(AVStream));
  481. if (!st)
  482. goto fail;
  483. s->streams[s->nb_streams++] = st;
  484. st->id = get_be16(pb);
  485. get_be32(pb); /* max bit rate */
  486. st->codec.bit_rate = get_be32(pb); /* bit rate */
  487. get_be32(pb); /* max packet size */
  488. get_be32(pb); /* avg packet size */
  489. get_be32(pb); /* start time */
  490. get_be32(pb); /* preroll */
  491. get_be32(pb); /* duration */
  492. get_str8(pb, buf, sizeof(buf)); /* desc */
  493. get_str8(pb, buf, sizeof(buf)); /* mimetype */
  494. codec_data_size = get_be32(pb);
  495. codec_pos = url_ftell(pb);
  496. v = get_be32(pb);
  497. if (v == MKTAG(0xfd, 'a', 'r', '.')) {
  498. /* ra type header */
  499. get_be32(pb); /* version */
  500. get_be32(pb); /* .ra4 */
  501. get_be32(pb);
  502. get_be16(pb);
  503. get_be32(pb); /* header size */
  504. get_be16(pb); /* add codec info */
  505. get_be32(pb); /* coded frame size */
  506. get_be32(pb); /* ??? */
  507. get_be32(pb); /* ??? */
  508. get_be32(pb); /* ??? */
  509. get_be16(pb); /* 1 */
  510. get_be16(pb); /* coded frame size */
  511. get_be32(pb);
  512. st->codec.sample_rate = get_be16(pb);
  513. get_be32(pb);
  514. st->codec.channels = get_be16(pb);
  515. get_str8(pb, buf, sizeof(buf)); /* desc */
  516. get_str8(pb, buf, sizeof(buf)); /* desc */
  517. st->codec.codec_type = CODEC_TYPE_AUDIO;
  518. if (!strcmp(buf, "dnet")) {
  519. st->codec.codec_id = CODEC_ID_AC3;
  520. } else {
  521. st->codec.codec_id = CODEC_ID_NONE;
  522. nstrcpy(st->codec.codec_name, sizeof(st->codec.codec_name),
  523. buf);
  524. }
  525. } else {
  526. if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) {
  527. fail1:
  528. fprintf(stderr, "Unsupported video codec\n");
  529. goto fail;
  530. }
  531. st->codec.codec_tag = get_le32(pb);
  532. if (st->codec.codec_tag != MKTAG('R', 'V', '1', '0'))
  533. goto fail1;
  534. st->codec.width = get_be16(pb);
  535. st->codec.height = get_be16(pb);
  536. st->codec.frame_rate = get_be16(pb) * FRAME_RATE_BASE;
  537. st->codec.codec_type = CODEC_TYPE_VIDEO;
  538. get_be32(pb);
  539. get_be16(pb);
  540. get_be32(pb);
  541. get_be16(pb);
  542. /* modification of h263 codec version (!) */
  543. h263_hack_version = get_be32(pb);
  544. switch(h263_hack_version) {
  545. case 0x10000000:
  546. st->codec.sub_id = 0;
  547. st->codec.codec_id = CODEC_ID_RV10;
  548. break;
  549. case 0x10003000:
  550. case 0x10003001:
  551. st->codec.sub_id = 3;
  552. st->codec.codec_id = CODEC_ID_RV10;
  553. break;
  554. default:
  555. /* not handled */
  556. st->codec.codec_id = CODEC_ID_NONE;
  557. break;
  558. }
  559. }
  560. /* skip codec info */
  561. size = url_ftell(pb) - codec_pos;
  562. url_fskip(pb, codec_data_size - size);
  563. break;
  564. case MKTAG('D', 'A', 'T', 'A'):
  565. goto header_end;
  566. default:
  567. /* unknown tag: skip it */
  568. url_fskip(pb, tag_size - 10);
  569. break;
  570. }
  571. }
  572. header_end:
  573. rm->nb_packets = get_be32(pb); /* number of packets */
  574. get_be32(pb); /* next data header */
  575. return 0;
  576. fail:
  577. for(i=0;i<s->nb_streams;i++) {
  578. free(s->streams[i]);
  579. }
  580. return -EIO;
  581. }
  582. static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
  583. {
  584. RMContext *rm = s->priv_data;
  585. ByteIOContext *pb = &s->pb;
  586. AVStream *st;
  587. int len, num, timestamp, i, tmp, j;
  588. UINT8 *ptr;
  589. redo:
  590. if (rm->nb_packets == 0)
  591. return -EIO;
  592. get_be16(pb);
  593. len = get_be16(pb);
  594. if (len < 12)
  595. return -EIO;
  596. num = get_be16(pb);
  597. timestamp = get_be32(pb);
  598. get_byte(pb); /* reserved */
  599. get_byte(pb); /* flags */
  600. rm->nb_packets--;
  601. len -= 12;
  602. st = NULL;
  603. for(i=0;i<s->nb_streams;i++) {
  604. st = s->streams[i];
  605. if (num == st->id)
  606. break;
  607. }
  608. if (i == s->nb_streams) {
  609. /* skip packet if unknown number */
  610. url_fskip(pb, len);
  611. goto redo;
  612. }
  613. av_new_packet(pkt, len);
  614. pkt->stream_index = i;
  615. get_buffer(pb, pkt->data, len);
  616. /* for AC3, needs to swap bytes */
  617. if (st->codec.codec_id == CODEC_ID_AC3) {
  618. ptr = pkt->data;
  619. for(j=0;j<len;j+=2) {
  620. tmp = ptr[0];
  621. ptr[0] = ptr[1];
  622. ptr[1] = tmp;
  623. ptr += 2;
  624. }
  625. }
  626. return 0;
  627. }
  628. static int rm_read_close(AVFormatContext *s)
  629. {
  630. RMContext *rm = s->priv_data;
  631. free(rm);
  632. return 0;
  633. }
  634. AVFormat rm_format = {
  635. "rm",
  636. "rm format",
  637. "audio/x-pn-realaudio",
  638. "rm,ra",
  639. CODEC_ID_AC3,
  640. CODEC_ID_RV10,
  641. rm_write_header,
  642. rm_write_packet,
  643. rm_write_trailer,
  644. rm_read_header,
  645. rm_read_packet,
  646. rm_read_close,
  647. };