git.sesse.net Git - ffmpeg/blob - libavformat/omadec.c

   1 /*
   2  * Sony OpenMG (OMA) demuxer
   3  *
   4  * Copyright (c) 2008, 2013 Maxim Poliakovski
   5  *               2008 Benjamin Larsson
   6  *               2011 David Goldwich
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * This is a demuxer for Sony OpenMG Music files
  28  *
  29  * Known file extensions: ".oma", "aa3"
  30  * The format of such files consists of three parts:
  31  * - "ea3" header carrying overall info and metadata. Except for starting with
  32  *   "ea" instead of "ID", it's an ID3v2 header.
  33  * - "EA3" header is a Sony-specific header containing information about
  34  *   the OpenMG file: codec type (usually ATRAC, can also be MP3 or WMA),
  35  *   codec specific info (packet size, sample rate, channels and so on)
  36  *   and DRM related info (file encryption, content id).
  37  * - Sound data organized in packets follow the EA3 header
  38  *   (can be encrypted using the Sony DRM!).
  39  *
  40  * Supported decoders: ATRAC3, ATRAC3+, MP3, LPCM
  41  */
  42
  43 #include <inttypes.h>
  44
  45 #include "libavutil/channel_layout.h"
  46 #include "avformat.h"
  47 #include "internal.h"
  48 #include "libavutil/intreadwrite.h"
  49 #include "libavutil/des.h"
  50 #include "libavutil/mathematics.h"
  51 #include "oma.h"
  52 #include "pcm.h"
  53 #include "id3v2.h"
  54
  55
  56 static const uint64_t leaf_table[] = {
  57     0xd79e8283acea4620, 0x7a9762f445afd0d8,
  58     0x354d60a60b8c79f1, 0x584e1cde00b07aee,
  59     0x1573cd93da7df623, 0x47f98d79620dd535
  60 };
  61
  62 typedef struct OMAContext {
  63     uint64_t content_start;
  64     int encrypted;
  65     uint16_t k_size;
  66     uint16_t e_size;
  67     uint16_t i_size;
  68     uint16_t s_size;
  69     uint32_t rid;
  70     uint8_t r_val[24];
  71     uint8_t n_val[24];
  72     uint8_t m_val[8];
  73     uint8_t s_val[8];
  74     uint8_t sm_val[8];
  75     uint8_t e_val[8];
  76     uint8_t iv[8];
  77     struct AVDES *av_des;
  78
  79     int (*read_packet)(AVFormatContext *s, AVPacket *pkt);
  80 } OMAContext;
  81
  82 static int oma_read_close(AVFormatContext *s)
  83 {
  84     OMAContext *oc = s->priv_data;
  85     av_freep(&oc->av_des);
  86     return 0;
  87 }
  88
  89 static void hex_log(AVFormatContext *s, int level,
  90                     const char *name, const uint8_t *value, int len)
  91 {
  92     char buf[33];
  93     len = FFMIN(len, 16);
  94     if (av_log_get_level() < level)
  95         return;
  96     ff_data_to_hex(buf, value, len, 1);
  97     buf[len << 1] = '\0';
  98     av_log(s, level, "%s: %s\n", name, buf);
  99 }
 100
 101 static int kset(AVFormatContext *s, const uint8_t *r_val, const uint8_t *n_val,
 102                 int len)
 103 {
 104     OMAContext *oc = s->priv_data;
 105
 106     if (!r_val && !n_val)
 107         return -1;
 108
 109     len = FFMIN(len, 16);
 110
 111     /* use first 64 bits in the third round again */
 112     if (r_val) {
 113         if (r_val != oc->r_val) {
 114             memset(oc->r_val, 0, 24);
 115             memcpy(oc->r_val, r_val, len);
 116         }
 117         memcpy(&oc->r_val[16], r_val, 8);
 118     }
 119     if (n_val) {
 120         if (n_val != oc->n_val) {
 121             memset(oc->n_val, 0, 24);
 122             memcpy(oc->n_val, n_val, len);
 123         }
 124         memcpy(&oc->n_val[16], n_val, 8);
 125     }
 126
 127     return 0;
 128 }
 129
 130 #define OMA_RPROBE_M_VAL 48 + 1
 131
 132 static int rprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size,
 133                   const uint8_t *r_val)
 134 {
 135     OMAContext *oc = s->priv_data;
 136     unsigned int pos;
 137     struct AVDES *av_des;
 138
 139     if (!enc_header || !r_val ||
 140         size < OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size ||
 141         size < OMA_RPROBE_M_VAL)
 142         return -1;
 143
 144     av_des = av_des_alloc();
 145     if (!av_des)
 146         return AVERROR(ENOMEM);
 147
 148     /* m_val */
 149     av_des_init(av_des, r_val, 192, 1);
 150     av_des_crypt(av_des, oc->m_val, &enc_header[48], 1, NULL, 1);
 151
 152     /* s_val */
 153     av_des_init(av_des, oc->m_val, 64, 0);
 154     av_des_crypt(av_des, oc->s_val, NULL, 1, NULL, 0);
 155
 156     /* sm_val */
 157     pos = OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size;
 158     av_des_init(av_des, oc->s_val, 64, 0);
 159     av_des_mac(av_des, oc->sm_val, &enc_header[pos], (oc->i_size >> 3));
 160
 161     pos += oc->i_size;
 162
 163     av_free(av_des);
 164
 165     return memcmp(&enc_header[pos], oc->sm_val, 8) ? -1 : 0;
 166 }
 167
 168 static int nprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size,
 169                   const uint8_t *n_val)
 170 {
 171     OMAContext *oc = s->priv_data;
 172     uint64_t pos;
 173     uint32_t taglen, datalen;
 174     struct AVDES *av_des;
 175
 176     if (!enc_header || !n_val ||
 177         size < OMA_ENC_HEADER_SIZE + oc->k_size + 4)
 178         return -1;
 179
 180     pos = OMA_ENC_HEADER_SIZE + oc->k_size;
 181     if (!memcmp(&enc_header[pos], "EKB ", 4))
 182         pos += 32;
 183
 184     if (size < pos + 44)
 185         return -1;
 186
 187     if (AV_RB32(&enc_header[pos]) != oc->rid)
 188         av_log(s, AV_LOG_DEBUG, "Mismatching RID\n");
 189
 190     taglen  = AV_RB32(&enc_header[pos + 32]);
 191     datalen = AV_RB32(&enc_header[pos + 36]) >> 4;
 192
 193     pos += 44LL + taglen;
 194
 195     if (pos + (((uint64_t)datalen) << 4) > size)
 196         return -1;
 197
 198     av_des = av_des_alloc();
 199     if (!av_des)
 200         return AVERROR(ENOMEM);
 201
 202     av_des_init(av_des, n_val, 192, 1);
 203     while (datalen-- > 0) {
 204         av_des_crypt(av_des, oc->r_val, &enc_header[pos], 2, NULL, 1);
 205         kset(s, oc->r_val, NULL, 16);
 206         if (!rprobe(s, enc_header, size, oc->r_val)) {
 207             av_free(av_des);
 208             return 0;
 209         }
 210         pos += 16;
 211     }
 212
 213     av_free(av_des);
 214     return -1;
 215 }
 216
 217 static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header)
 218 {
 219     OMAContext *oc = s->priv_data;
 220     ID3v2ExtraMetaGEOB *geob = NULL;
 221     uint8_t *gdata;
 222
 223     oc->encrypted = 1;
 224     av_log(s, AV_LOG_INFO, "File is encrypted\n");
 225
 226     /* find GEOB metadata */
 227     for (; em; em = em->next) {
 228         if (strcmp(em->tag, "GEOB"))
 229             continue;
 230         geob = &em->data.geob;
 231         if (!strcmp(geob->description, "OMG_LSI") ||
 232             !strcmp(geob->description, "OMG_BKLSI"))
 233             break;
 234     }
 235     if (!em) {
 236         av_log(s, AV_LOG_ERROR, "No encryption header found\n");
 237         return AVERROR_INVALIDDATA;
 238     }
 239
 240     if (geob->datasize < 64) {
 241         av_log(s, AV_LOG_ERROR,
 242                "Invalid GEOB data size: %"PRIu32"\n", geob->datasize);
 243         return AVERROR_INVALIDDATA;
 244     }
 245
 246     gdata = geob->data;
 247
 248     if (AV_RB16(gdata) != 1)
 249         av_log(s, AV_LOG_WARNING, "Unknown version in encryption header\n");
 250
 251     oc->k_size = AV_RB16(&gdata[2]);
 252     oc->e_size = AV_RB16(&gdata[4]);
 253     oc->i_size = AV_RB16(&gdata[6]);
 254     oc->s_size = AV_RB16(&gdata[8]);
 255
 256     if (memcmp(&gdata[OMA_ENC_HEADER_SIZE], "KEYRING     ", 12)) {
 257         av_log(s, AV_LOG_ERROR, "Invalid encryption header\n");
 258         return AVERROR_INVALIDDATA;
 259     }
 260     if (OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size + 8 > geob->datasize ||
 261         OMA_ENC_HEADER_SIZE + 48 > geob->datasize) {
 262         av_log(s, AV_LOG_ERROR, "Too little GEOB data\n");
 263         return AVERROR_INVALIDDATA;
 264     }
 265     oc->rid = AV_RB32(&gdata[OMA_ENC_HEADER_SIZE + 28]);
 266     av_log(s, AV_LOG_DEBUG, "RID: %.8"PRIx32"\n", oc->rid);
 267
 268     memcpy(oc->iv, &header[0x58], 8);
 269     hex_log(s, AV_LOG_DEBUG, "IV", oc->iv, 8);
 270
 271     hex_log(s, AV_LOG_DEBUG, "CBC-MAC",
 272             &gdata[OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size],
 273             8);
 274
 275     if (s->keylen > 0) {
 276         kset(s, s->key, s->key, s->keylen);
 277     }
 278     if (!memcmp(oc->r_val, (const uint8_t[8]){0}, 8) ||
 279         rprobe(s, gdata, geob->datasize, oc->r_val) < 0 &&
 280         nprobe(s, gdata, geob->datasize, oc->n_val) < 0) {
 281         int i;
 282         for (i = 0; i < FF_ARRAY_ELEMS(leaf_table); i += 2) {
 283             uint8_t buf[16];
 284             AV_WL64(buf,     leaf_table[i]);
 285             AV_WL64(&buf[8], leaf_table[i + 1]);
 286             kset(s, buf, buf, 16);
 287             if (!rprobe(s, gdata, geob->datasize, oc->r_val) ||
 288                 !nprobe(s, gdata, geob->datasize, oc->n_val))
 289                 break;
 290         }
 291         if (i >= FF_ARRAY_ELEMS(leaf_table)) {
 292             av_log(s, AV_LOG_ERROR, "Invalid key\n");
 293             return AVERROR_INVALIDDATA;
 294         }
 295     }
 296
 297     oc->av_des = av_des_alloc();
 298     if (!oc->av_des)
 299         return AVERROR(ENOMEM);
 300
 301     /* e_val */
 302     av_des_init(oc->av_des, oc->m_val, 64, 0);
 303     av_des_crypt(oc->av_des, oc->e_val,
 304                  &gdata[OMA_ENC_HEADER_SIZE + 40], 1, NULL, 0);
 305     hex_log(s, AV_LOG_DEBUG, "EK", oc->e_val, 8);
 306
 307     /* init e_val */
 308     av_des_init(oc->av_des, oc->e_val, 64, 1);
 309
 310     return 0;
 311 }
 312
 313 static int read_packet(AVFormatContext *s, AVPacket *pkt)
 314 {
 315     OMAContext *oc  = s->priv_data;
 316     AVStream *st    = s->streams[0];
 317     int packet_size = st->codecpar->block_align;
 318     int byte_rate   = st->codecpar->bit_rate >> 3;
 319     int64_t pos     = avio_tell(s->pb);
 320     int ret         = av_get_packet(s->pb, pkt, packet_size);
 321
 322     if (ret < packet_size)
 323         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 324
 325     if (ret < 0)
 326         return ret;
 327     if (!ret)
 328         return AVERROR_EOF;
 329
 330     pkt->stream_index = 0;
 331
 332     if (pos >= oc->content_start && byte_rate > 0) {
 333         pkt->pts =
 334         pkt->dts = av_rescale(pos - oc->content_start, st->time_base.den,
 335                               byte_rate * (int64_t)st->time_base.num);
 336     }
 337
 338     if (oc->encrypted) {
 339         /* previous unencrypted block saved in IV for
 340          * the next packet (CBC mode) */
 341         if (ret == packet_size)
 342             av_des_crypt(oc->av_des, pkt->data, pkt->data,
 343                          (packet_size >> 3), oc->iv, 1);
 344         else
 345             memset(oc->iv, 0, 8);
 346     }
 347
 348     return ret;
 349 }
 350
 351 static int aal_read_packet(AVFormatContext *s, AVPacket *pkt)
 352 {
 353     int64_t pos = avio_tell(s->pb);
 354     int ret, pts;
 355     int packet_size;
 356     unsigned tag;
 357
 358     if (avio_feof(s->pb))
 359         return AVERROR_EOF;
 360
 361     tag = avio_rb24(s->pb);
 362     if (tag == 0)
 363         return AVERROR_EOF;
 364     else if (tag != MKBETAG(0,'B','L','K'))
 365         return AVERROR_INVALIDDATA;
 366
 367     avio_skip(s->pb, 1);
 368     packet_size = avio_rb16(s->pb);
 369     avio_skip(s->pb, 2);
 370     pts = avio_rb32(s->pb);
 371     avio_skip(s->pb, 12);
 372     ret = av_get_packet(s->pb, pkt, packet_size);
 373     if (ret < packet_size)
 374         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 375
 376     if (ret < 0)
 377         return ret;
 378     if (!ret)
 379         return AVERROR_EOF;
 380
 381     pkt->stream_index = 0;
 382     pkt->pos = pos;
 383     if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL) {
 384         pkt->duration = 1024;
 385         pkt->pts = pts * 1024LL;
 386     } else {
 387         pkt->duration = 2048;
 388         pkt->pts = pts * 2048LL;
 389     }
 390
 391     return ret;
 392 }
 393
 394 static int oma_read_header(AVFormatContext *s)
 395 {
 396     int     ret, framesize, jsflag, samplerate;
 397     uint32_t codec_params, channel_id;
 398     int16_t eid;
 399     uint8_t buf[EA3_HEADER_SIZE];
 400     uint8_t *edata;
 401     AVStream *st;
 402     ID3v2ExtraMeta *extra_meta = NULL;
 403     OMAContext *oc = s->priv_data;
 404
 405     ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta, 0);
 406     if ((ret = ff_id3v2_parse_chapters(s, extra_meta)) < 0) {
 407         ff_id3v2_free_extra_meta(&extra_meta);
 408         return ret;
 409     }
 410
 411     ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
 412     if (ret < EA3_HEADER_SIZE) {
 413         ff_id3v2_free_extra_meta(&extra_meta);
 414         return -1;
 415     }
 416
 417     if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}), 3) ||
 418         buf[4] != 0 || buf[5] != EA3_HEADER_SIZE) {
 419         ff_id3v2_free_extra_meta(&extra_meta);
 420         av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n");
 421         return AVERROR_INVALIDDATA;
 422     }
 423
 424     oc->content_start = avio_tell(s->pb);
 425
 426     /* encrypted file */
 427     eid = AV_RB16(&buf[6]);
 428     if (eid != -1 && eid != -128 && decrypt_init(s, extra_meta, buf) < 0) {
 429         ff_id3v2_free_extra_meta(&extra_meta);
 430         return -1;
 431     }
 432
 433     ff_id3v2_free_extra_meta(&extra_meta);
 434
 435     codec_params = AV_RB24(&buf[33]);
 436
 437     st = avformat_new_stream(s, NULL);
 438     if (!st) {
 439         ret = AVERROR(ENOMEM);
 440         goto fail;
 441     }
 442
 443     st->start_time = 0;
 444     st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
 445     st->codecpar->codec_tag  = buf[32];
 446     st->codecpar->codec_id   = ff_codec_get_id(ff_oma_codec_tags,
 447                                                st->codecpar->codec_tag);
 448
 449     oc->read_packet = read_packet;
 450
 451     switch (buf[32]) {
 452     case OMA_CODECID_ATRAC3:
 453         samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100;
 454         if (!samplerate) {
 455             av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
 456             ret = AVERROR_INVALIDDATA;
 457             goto fail;
 458         }
 459         if (samplerate != 44100)
 460             avpriv_request_sample(s, "Sample rate %d", samplerate);
 461
 462         framesize = (codec_params & 0x3FF) * 8;
 463
 464         /* get stereo coding mode, 1 for joint-stereo */
 465         jsflag = (codec_params >> 17) & 1;
 466
 467         st->codecpar->channels    = 2;
 468         st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
 469         st->codecpar->sample_rate = samplerate;
 470         st->codecpar->bit_rate    = st->codecpar->sample_rate * framesize / (1024 / 8);
 471
 472         /* fake the ATRAC3 extradata
 473          * (wav format, makes stream copy to wav work) */
 474         if ((ret = ff_alloc_extradata(st->codecpar, 14)) < 0)
 475             goto fail;
 476
 477         edata = st->codecpar->extradata;
 478         AV_WL16(&edata[0],  1);             // always 1
 479         AV_WL32(&edata[2],  samplerate);    // samples rate
 480         AV_WL16(&edata[6],  jsflag);        // coding mode
 481         AV_WL16(&edata[8],  jsflag);        // coding mode
 482         AV_WL16(&edata[10], 1);             // always 1
 483         // AV_WL16(&edata[12], 0);          // always 0
 484
 485         avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
 486         break;
 487     case OMA_CODECID_ATRAC3P:
 488         channel_id = (codec_params >> 10) & 7;
 489         if (!channel_id) {
 490             av_log(s, AV_LOG_ERROR,
 491                    "Invalid ATRAC-X channel id: %"PRIu32"\n", channel_id);
 492             ret = AVERROR_INVALIDDATA;
 493             goto fail;
 494         }
 495         st->codecpar->channel_layout = ff_oma_chid_to_native_layout[channel_id - 1];
 496         st->codecpar->channels       = ff_oma_chid_to_num_channels[channel_id - 1];
 497         framesize = ((codec_params & 0x3FF) * 8) + 8;
 498         samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100;
 499         if (!samplerate) {
 500             av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
 501             ret = AVERROR_INVALIDDATA;
 502             goto fail;
 503         }
 504         st->codecpar->sample_rate = samplerate;
 505         st->codecpar->bit_rate    = samplerate * framesize / (2048 / 8);
 506         avpriv_set_pts_info(st, 64, 1, samplerate);
 507         break;
 508     case OMA_CODECID_MP3:
 509         st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
 510         framesize = 1024;
 511         break;
 512     case OMA_CODECID_LPCM:
 513         /* PCM 44.1 kHz 16 bit stereo big-endian */
 514         st->codecpar->channels = 2;
 515         st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
 516         st->codecpar->sample_rate = 44100;
 517         framesize = 1024;
 518         /* bit rate = sample rate x PCM block align (= 4) x 8 */
 519         st->codecpar->bit_rate = st->codecpar->sample_rate * 32;
 520         st->codecpar->bits_per_coded_sample =
 521             av_get_bits_per_sample(st->codecpar->codec_id);
 522         avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
 523         break;
 524     case OMA_CODECID_ATRAC3AL:
 525         st->codecpar->channels    = 2;
 526         st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
 527         st->codecpar->sample_rate = 44100;
 528         avpriv_set_pts_info(st, 64, 1, 44100);
 529         oc->read_packet = aal_read_packet;
 530         framesize = 4096;
 531         break;
 532     case OMA_CODECID_ATRAC3PAL:
 533         st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
 534         st->codecpar->channels       = 2;
 535         st->codecpar->sample_rate = 44100;
 536         avpriv_set_pts_info(st, 64, 1, 44100);
 537         oc->read_packet = aal_read_packet;
 538         framesize = 4096;
 539         break;
 540     default:
 541         av_log(s, AV_LOG_ERROR, "Unsupported codec %d!\n", buf[32]);
 542         ret = AVERROR(ENOSYS);
 543         goto fail;
 544     }
 545
 546     st->codecpar->block_align = framesize;
 547
 548     return 0;
 549 fail:
 550     oma_read_close(s);
 551     return ret;
 552 }
 553
 554 static int oma_read_packet(AVFormatContext *s, AVPacket *pkt)
 555 {
 556     OMAContext *oc  = s->priv_data;
 557     return oc->read_packet(s, pkt);
 558 }
 559
 560 static int oma_read_probe(const AVProbeData *p)
 561 {
 562     const uint8_t *buf = p->buf;
 563     unsigned tag_len = 0;
 564
 565     if (p->buf_size >= ID3v2_HEADER_SIZE && ff_id3v2_match(buf, ID3v2_EA3_MAGIC))
 566         tag_len = ff_id3v2_tag_len(buf);
 567
 568     /* This check cannot overflow as tag_len has at most 28 bits */
 569     if (p->buf_size < tag_len + 5)
 570         /* EA3 header comes late, might be outside of the probe buffer */
 571         return tag_len ? AVPROBE_SCORE_EXTENSION/2 : 0;
 572
 573     buf += tag_len;
 574
 575     if (!memcmp(buf, "EA3", 3) && !buf[4] && buf[5] == EA3_HEADER_SIZE)
 576         return AVPROBE_SCORE_MAX;
 577     else
 578         return 0;
 579 }
 580
 581 static int oma_read_seek(struct AVFormatContext *s,
 582                          int stream_index, int64_t timestamp, int flags)
 583 {
 584     OMAContext *oc = s->priv_data;
 585     AVStream *st = s->streams[0];
 586     int64_t err;
 587
 588     if (st->codecpar->codec_id == AV_CODEC_ID_ATRAC3PAL ||
 589         st->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL)
 590         return -1;
 591
 592     err = ff_pcm_read_seek(s, stream_index, timestamp, flags);
 593     if (!oc->encrypted)
 594         return err;
 595
 596     /* readjust IV for CBC */
 597     if (err || avio_tell(s->pb) < oc->content_start)
 598         goto wipe;
 599     if ((err = avio_seek(s->pb, -8, SEEK_CUR)) < 0)
 600         goto wipe;
 601     if ((err = avio_read(s->pb, oc->iv, 8)) < 8) {
 602         if (err >= 0)
 603             err = AVERROR_EOF;
 604         goto wipe;
 605     }
 606
 607     return 0;
 608 wipe:
 609     memset(oc->iv, 0, 8);
 610     return err;
 611 }
 612
 613 AVInputFormat ff_oma_demuxer = {
 614     .name           = "oma",
 615     .long_name      = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
 616     .priv_data_size = sizeof(OMAContext),
 617     .read_probe     = oma_read_probe,
 618     .read_header    = oma_read_header,
 619     .read_packet    = oma_read_packet,
 620     .read_seek      = oma_read_seek,
 621     .read_close     = oma_read_close,
 622     .flags          = AVFMT_GENERIC_INDEX,
 623     .extensions     = "oma,omg,aa3",
 624     .codec_tag      = (const AVCodecTag* const []){ff_oma_codec_tags, 0},
 625 };