Subversion Repositories Kolibri OS

Rev

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