Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.  */
  41.  
  42. #include "libavutil/channel_layout.h"
  43. #include "avformat.h"
  44. #include "internal.h"
  45. #include "libavutil/intreadwrite.h"
  46. #include "libavutil/des.h"
  47. #include "oma.h"
  48. #include "pcm.h"
  49. #include "id3v2.h"
  50.  
  51.  
  52. static const uint64_t leaf_table[] = {
  53.     0xd79e8283acea4620, 0x7a9762f445afd0d8,
  54.     0x354d60a60b8c79f1, 0x584e1cde00b07aee,
  55.     0x1573cd93da7df623, 0x47f98d79620dd535
  56. };
  57.  
  58. typedef struct OMAContext {
  59.     uint64_t content_start;
  60.     int encrypted;
  61.     uint16_t k_size;
  62.     uint16_t e_size;
  63.     uint16_t i_size;
  64.     uint16_t s_size;
  65.     uint32_t rid;
  66.     uint8_t r_val[24];
  67.     uint8_t n_val[24];
  68.     uint8_t m_val[8];
  69.     uint8_t s_val[8];
  70.     uint8_t sm_val[8];
  71.     uint8_t e_val[8];
  72.     uint8_t iv[8];
  73.     struct AVDES av_des;
  74. } OMAContext;
  75.  
  76. static void hex_log(AVFormatContext *s, int level,
  77.                     const char *name, const uint8_t *value, int len)
  78. {
  79.     char buf[33];
  80.     len = FFMIN(len, 16);
  81.     if (av_log_get_level() < level)
  82.         return;
  83.     ff_data_to_hex(buf, value, len, 1);
  84.     buf[len << 1] = '\0';
  85.     av_log(s, level, "%s: %s\n", name, buf);
  86. }
  87.  
  88. static int kset(AVFormatContext *s, const uint8_t *r_val, const uint8_t *n_val,
  89.                 int len)
  90. {
  91.     OMAContext *oc = s->priv_data;
  92.  
  93.     if (!r_val && !n_val)
  94.         return -1;
  95.  
  96.     len = FFMIN(len, 16);
  97.  
  98.     /* use first 64 bits in the third round again */
  99.     if (r_val) {
  100.         if (r_val != oc->r_val) {
  101.             memset(oc->r_val, 0, 24);
  102.             memcpy(oc->r_val, r_val, len);
  103.         }
  104.         memcpy(&oc->r_val[16], r_val, 8);
  105.     }
  106.     if (n_val) {
  107.         if (n_val != oc->n_val) {
  108.             memset(oc->n_val, 0, 24);
  109.             memcpy(oc->n_val, n_val, len);
  110.         }
  111.         memcpy(&oc->n_val[16], n_val, 8);
  112.     }
  113.  
  114.     return 0;
  115. }
  116.  
  117. #define OMA_RPROBE_M_VAL 48 + 1
  118.  
  119. static int rprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size,
  120.                   const uint8_t *r_val)
  121. {
  122.     OMAContext *oc = s->priv_data;
  123.     unsigned int pos;
  124.     struct AVDES av_des;
  125.  
  126.     if (!enc_header || !r_val ||
  127.         size < OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size ||
  128.         size < OMA_RPROBE_M_VAL)
  129.         return -1;
  130.  
  131.     /* m_val */
  132.     av_des_init(&av_des, r_val, 192, 1);
  133.     av_des_crypt(&av_des, oc->m_val, &enc_header[48], 1, NULL, 1);
  134.  
  135.     /* s_val */
  136.     av_des_init(&av_des, oc->m_val, 64, 0);
  137.     av_des_crypt(&av_des, oc->s_val, NULL, 1, NULL, 0);
  138.  
  139.     /* sm_val */
  140.     pos = OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size;
  141.     av_des_init(&av_des, oc->s_val, 64, 0);
  142.     av_des_mac(&av_des, oc->sm_val, &enc_header[pos], (oc->i_size >> 3));
  143.  
  144.     pos += oc->i_size;
  145.  
  146.     return memcmp(&enc_header[pos], oc->sm_val, 8) ? -1 : 0;
  147. }
  148.  
  149. static int nprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size,
  150.                   const uint8_t *n_val)
  151. {
  152.     OMAContext *oc = s->priv_data;
  153.     uint64_t pos;
  154.     uint32_t taglen, datalen;
  155.     struct AVDES av_des;
  156.  
  157.     if (!enc_header || !n_val ||
  158.         size < OMA_ENC_HEADER_SIZE + oc->k_size + 4)
  159.         return -1;
  160.  
  161.     pos = OMA_ENC_HEADER_SIZE + oc->k_size;
  162.     if (!memcmp(&enc_header[pos], "EKB ", 4))
  163.         pos += 32;
  164.  
  165.     if (size < pos + 44)
  166.         return -1;
  167.  
  168.     if (AV_RB32(&enc_header[pos]) != oc->rid)
  169.         av_log(s, AV_LOG_DEBUG, "Mismatching RID\n");
  170.  
  171.     taglen  = AV_RB32(&enc_header[pos + 32]);
  172.     datalen = AV_RB32(&enc_header[pos + 36]) >> 4;
  173.  
  174.     pos += 44L + taglen;
  175.  
  176.     if (pos + (((uint64_t)datalen) << 4) > size)
  177.         return -1;
  178.  
  179.     av_des_init(&av_des, n_val, 192, 1);
  180.     while (datalen-- > 0) {
  181.         av_des_crypt(&av_des, oc->r_val, &enc_header[pos], 2, NULL, 1);
  182.         kset(s, oc->r_val, NULL, 16);
  183.         if (!rprobe(s, enc_header, size, oc->r_val))
  184.             return 0;
  185.         pos += 16;
  186.     }
  187.  
  188.     return -1;
  189. }
  190.  
  191. static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header)
  192. {
  193.     OMAContext *oc = s->priv_data;
  194.     ID3v2ExtraMetaGEOB *geob = NULL;
  195.     uint8_t *gdata;
  196.  
  197.     oc->encrypted = 1;
  198.     av_log(s, AV_LOG_INFO, "File is encrypted\n");
  199.  
  200.     /* find GEOB metadata */
  201.     while (em) {
  202.         if (!strcmp(em->tag, "GEOB") &&
  203.             (geob = em->data) &&
  204.             (!strcmp(geob->description, "OMG_LSI") ||
  205.              !strcmp(geob->description, "OMG_BKLSI"))) {
  206.             break;
  207.         }
  208.         em = em->next;
  209.     }
  210.     if (!em) {
  211.         av_log(s, AV_LOG_ERROR, "No encryption header found\n");
  212.         return AVERROR_INVALIDDATA;
  213.     }
  214.  
  215.     if (geob->datasize < 64) {
  216.         av_log(s, AV_LOG_ERROR,
  217.                "Invalid GEOB data size: %u\n", geob->datasize);
  218.         return AVERROR_INVALIDDATA;
  219.     }
  220.  
  221.     gdata = geob->data;
  222.  
  223.     if (AV_RB16(gdata) != 1)
  224.         av_log(s, AV_LOG_WARNING, "Unknown version in encryption header\n");
  225.  
  226.     oc->k_size = AV_RB16(&gdata[2]);
  227.     oc->e_size = AV_RB16(&gdata[4]);
  228.     oc->i_size = AV_RB16(&gdata[6]);
  229.     oc->s_size = AV_RB16(&gdata[8]);
  230.  
  231.     if (memcmp(&gdata[OMA_ENC_HEADER_SIZE], "KEYRING     ", 12)) {
  232.         av_log(s, AV_LOG_ERROR, "Invalid encryption header\n");
  233.         return AVERROR_INVALIDDATA;
  234.     }
  235.     if (   OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size + 8 > geob->datasize
  236.         || OMA_ENC_HEADER_SIZE + 48 > geob->datasize
  237.     ) {
  238.         av_log(s, AV_LOG_ERROR, "Too little GEOB data\n");
  239.         return AVERROR_INVALIDDATA;
  240.     }
  241.     oc->rid = AV_RB32(&gdata[OMA_ENC_HEADER_SIZE + 28]);
  242.     av_log(s, AV_LOG_DEBUG, "RID: %.8x\n", oc->rid);
  243.  
  244.     memcpy(oc->iv, &header[0x58], 8);
  245.     hex_log(s, AV_LOG_DEBUG, "IV", oc->iv, 8);
  246.  
  247.     hex_log(s, AV_LOG_DEBUG, "CBC-MAC",
  248.             &gdata[OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size],
  249.             8);
  250.  
  251.     if (s->keylen > 0) {
  252.         kset(s, s->key, s->key, s->keylen);
  253.     }
  254.     if (!memcmp(oc->r_val, (const uint8_t[8]){0}, 8) ||
  255.         rprobe(s, gdata, geob->datasize, oc->r_val) < 0 &&
  256.         nprobe(s, gdata, geob->datasize, oc->n_val) < 0) {
  257.         int i;
  258.         for (i = 0; i < FF_ARRAY_ELEMS(leaf_table); i += 2) {
  259.             uint8_t buf[16];
  260.             AV_WL64(buf,     leaf_table[i]);
  261.             AV_WL64(&buf[8], leaf_table[i + 1]);
  262.             kset(s, buf, buf, 16);
  263.             if (!rprobe(s, gdata, geob->datasize, oc->r_val) ||
  264.                 !nprobe(s, gdata, geob->datasize, oc->n_val))
  265.                 break;
  266.         }
  267.         if (i >= FF_ARRAY_ELEMS(leaf_table)) {
  268.             av_log(s, AV_LOG_ERROR, "Invalid key\n");
  269.             return AVERROR_INVALIDDATA;
  270.         }
  271.     }
  272.  
  273.     /* e_val */
  274.     av_des_init(&oc->av_des, oc->m_val, 64, 0);
  275.     av_des_crypt(&oc->av_des, oc->e_val,
  276.                  &gdata[OMA_ENC_HEADER_SIZE + 40], 1, NULL, 0);
  277.     hex_log(s, AV_LOG_DEBUG, "EK", oc->e_val, 8);
  278.  
  279.     /* init e_val */
  280.     av_des_init(&oc->av_des, oc->e_val, 64, 1);
  281.  
  282.     return 0;
  283. }
  284.  
  285. static int oma_read_header(AVFormatContext *s)
  286. {
  287.     int     ret, framesize, jsflag, samplerate;
  288.     uint32_t codec_params, channel_id;
  289.     int16_t eid;
  290.     uint8_t buf[EA3_HEADER_SIZE];
  291.     uint8_t *edata;
  292.     AVStream *st;
  293.     ID3v2ExtraMeta *extra_meta = NULL;
  294.     OMAContext *oc = s->priv_data;
  295.  
  296.     ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta);
  297.     ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
  298.     if (ret < EA3_HEADER_SIZE)
  299.         return -1;
  300.  
  301.     if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}), 3) ||
  302.         buf[4] != 0 || buf[5] != EA3_HEADER_SIZE) {
  303.         av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n");
  304.         return AVERROR_INVALIDDATA;
  305.     }
  306.  
  307.     oc->content_start = avio_tell(s->pb);
  308.  
  309.     /* encrypted file */
  310.     eid = AV_RB16(&buf[6]);
  311.     if (eid != -1 && eid != -128 && decrypt_init(s, extra_meta, buf) < 0) {
  312.         ff_id3v2_free_extra_meta(&extra_meta);
  313.         return -1;
  314.     }
  315.  
  316.     ff_id3v2_free_extra_meta(&extra_meta);
  317.  
  318.     codec_params = AV_RB24(&buf[33]);
  319.  
  320.     st = avformat_new_stream(s, NULL);
  321.     if (!st)
  322.         return AVERROR(ENOMEM);
  323.  
  324.     st->start_time = 0;
  325.     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  326.     st->codec->codec_tag  = buf[32];
  327.     st->codec->codec_id   = ff_codec_get_id(ff_oma_codec_tags,
  328.                                             st->codec->codec_tag);
  329.  
  330.     switch (buf[32]) {
  331.     case OMA_CODECID_ATRAC3:
  332.         samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100;
  333.         if (!samplerate) {
  334.             av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
  335.             return AVERROR_INVALIDDATA;
  336.         }
  337.         if (samplerate != 44100)
  338.             avpriv_request_sample(s, "Sample rate %d", samplerate);
  339.  
  340.         framesize = (codec_params & 0x3FF) * 8;
  341.  
  342.         /* get stereo coding mode, 1 for joint-stereo */
  343.         jsflag = (codec_params >> 17) & 1;
  344.  
  345.         st->codec->channels    = 2;
  346.         st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
  347.         st->codec->sample_rate = samplerate;
  348.         st->codec->bit_rate    = st->codec->sample_rate * framesize * 8 / 1024;
  349.  
  350.         /* fake the ATRAC3 extradata
  351.          * (wav format, makes stream copy to wav work) */
  352.         if (ff_alloc_extradata(st->codec, 14))
  353.             return AVERROR(ENOMEM);
  354.  
  355.         edata = st->codec->extradata;
  356.         AV_WL16(&edata[0],  1);             // always 1
  357.         AV_WL32(&edata[2],  samplerate);    // samples rate
  358.         AV_WL16(&edata[6],  jsflag);        // coding mode
  359.         AV_WL16(&edata[8],  jsflag);        // coding mode
  360.         AV_WL16(&edata[10], 1);             // always 1
  361.         // AV_WL16(&edata[12], 0);          // always 0
  362.  
  363.         avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
  364.         break;
  365.     case OMA_CODECID_ATRAC3P:
  366.         channel_id = (codec_params >> 10) & 7;
  367.         if (!channel_id) {
  368.             av_log(s, AV_LOG_ERROR,
  369.                    "Invalid ATRAC-X channel id: %d\n", channel_id);
  370.             return AVERROR_INVALIDDATA;
  371.         }
  372.         st->codec->channel_layout = ff_oma_chid_to_native_layout[channel_id - 1];
  373.         st->codec->channels       = ff_oma_chid_to_num_channels[channel_id - 1];
  374.         framesize = ((codec_params & 0x3FF) * 8) + 8;
  375.         samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100;
  376.         if (!samplerate) {
  377.             av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n");
  378.             return AVERROR_INVALIDDATA;
  379.         }
  380.         st->codec->sample_rate = samplerate;
  381.         st->codec->bit_rate    = samplerate * framesize * 8 / 2048;
  382.         avpriv_set_pts_info(st, 64, 1, samplerate);
  383.         av_log(s, AV_LOG_ERROR, "Unsupported codec ATRAC3+!\n");
  384.         break;
  385.     case OMA_CODECID_MP3:
  386.         st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
  387.         framesize = 1024;
  388.         break;
  389.     case OMA_CODECID_LPCM:
  390.         /* PCM 44.1 kHz 16 bit stereo big-endian */
  391.         st->codec->channels = 2;
  392.         st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
  393.         st->codec->sample_rate = 44100;
  394.         framesize = 1024;
  395.         /* bit rate = sample rate x PCM block align (= 4) x 8 */
  396.         st->codec->bit_rate = st->codec->sample_rate * 32;
  397.         st->codec->bits_per_coded_sample =
  398.             av_get_bits_per_sample(st->codec->codec_id);
  399.         avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
  400.         break;
  401.     default:
  402.         av_log(s, AV_LOG_ERROR, "Unsupported codec %d!\n", buf[32]);
  403.         return AVERROR(ENOSYS);
  404.     }
  405.  
  406.     st->codec->block_align = framesize;
  407.  
  408.     return 0;
  409. }
  410.  
  411.  
  412. static int oma_read_packet(AVFormatContext *s, AVPacket *pkt)
  413. {
  414.     OMAContext *oc = s->priv_data;
  415.     int packet_size = s->streams[0]->codec->block_align;
  416.     int ret = av_get_packet(s->pb, pkt, packet_size);
  417.  
  418.     if (ret < packet_size)
  419.         pkt->flags |= AV_PKT_FLAG_CORRUPT;
  420.  
  421.     if (ret < 0)
  422.         return ret;
  423.     if (!ret)
  424.         return AVERROR_EOF;
  425.  
  426.     pkt->stream_index = 0;
  427.  
  428.     if (oc->encrypted) {
  429.         /* previous unencrypted block saved in IV for
  430.          * the next packet (CBC mode) */
  431.         if (ret == packet_size)
  432.             av_des_crypt(&oc->av_des, pkt->data, pkt->data,
  433.                          (packet_size >> 3), oc->iv, 1);
  434.         else
  435.             memset(oc->iv, 0, 8);
  436.     }
  437.  
  438.     return ret;
  439. }
  440.  
  441. static int oma_read_probe(AVProbeData *p)
  442. {
  443.     const uint8_t *buf;
  444.     unsigned tag_len = 0;
  445.  
  446.     buf = p->buf;
  447.  
  448.     if (p->buf_size < ID3v2_HEADER_SIZE ||
  449.         !ff_id3v2_match(buf, ID3v2_EA3_MAGIC) ||
  450.         buf[3] != 3 || // version must be 3
  451.         buf[4]) // flags byte zero
  452.         return 0;
  453.  
  454.     tag_len = ff_id3v2_tag_len(buf);
  455.  
  456.     /* This check cannot overflow as tag_len has at most 28 bits */
  457.     if (p->buf_size < tag_len + 5)
  458.         /* EA3 header comes late, might be outside of the probe buffer */
  459.         return AVPROBE_SCORE_EXTENSION;
  460.  
  461.     buf += tag_len;
  462.  
  463.     if (!memcmp(buf, "EA3", 3) && !buf[4] && buf[5] == EA3_HEADER_SIZE)
  464.         return AVPROBE_SCORE_MAX;
  465.     else
  466.         return 0;
  467. }
  468.  
  469. static int oma_read_seek(struct AVFormatContext *s,
  470.                          int stream_index, int64_t timestamp, int flags)
  471. {
  472.     OMAContext *oc = s->priv_data;
  473.     int err = ff_pcm_read_seek(s, stream_index, timestamp, flags);
  474.  
  475.     if (!oc->encrypted)
  476.         return err;
  477.  
  478.     /* readjust IV for CBC */
  479.     if (err || avio_tell(s->pb) < oc->content_start)
  480.         goto wipe;
  481.     if ((err = avio_seek(s->pb, -8, SEEK_CUR)) < 0)
  482.         goto wipe;
  483.     if ((err = avio_read(s->pb, oc->iv, 8)) < 8) {
  484.         if (err >= 0)
  485.             err = AVERROR_EOF;
  486.         goto wipe;
  487.     }
  488.  
  489.     return 0;
  490. wipe:
  491.     memset(oc->iv, 0, 8);
  492.     return err;
  493. }
  494.  
  495. AVInputFormat ff_oma_demuxer = {
  496.     .name           = "oma",
  497.     .long_name      = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
  498.     .priv_data_size = sizeof(OMAContext),
  499.     .read_probe     = oma_read_probe,
  500.     .read_header    = oma_read_header,
  501.     .read_packet    = oma_read_packet,
  502.     .read_seek      = oma_read_seek,
  503.     .flags          = AVFMT_GENERIC_INDEX,
  504.     .extensions     = "oma,omg,aa3",
  505.     .codec_tag      = (const AVCodecTag* const []){ff_oma_codec_tags, 0},
  506. };
  507.