apps/codecs.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Björn Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "config.h"
  22
  23 #include <stdbool.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <timefuncs.h>
  28 #include <ctype.h>
  29 #include <stdarg.h>
  30 #include "string-extra.h"
  31 #include "load_code.h"
  32 #include "debug.h"
  33 #include "button.h"
  34 #include "dir.h"
  35 #include "file.h"
  36 #include "kernel.h"
  37 #include "screens.h"
  38 #include "misc.h"
  39 #include "codecs.h"
  40 #include "lang.h"
  41 #include "keyboard.h"
  42 #include "buffering.h"
  43 #include "mp3_playback.h"
  44 #include "backlight.h"
  45 #include "storage.h"
  46 #include "talk.h"
  47 #include "mp3data.h"
  48 #include "powermgmt.h"
  49 #include "system.h"
  50 #include "sound.h"
  51 #include "splash.h"
  52 #include "general.h"
  53
  54 #define LOGF_ENABLE
  55 #include "logf.h"
  56
  57 #if (CONFIG_PLATFORM & (PLATFORM_SDL|PLATFORM_MAEMO|PLATFORM_PANDORA))
  58 #define PREFIX(_x_) sim_ ## _x_
  59 #else
  60 #define PREFIX(_x_) _x_
  61 #endif
  62
  63 #if (CONFIG_PLATFORM & PLATFORM_HOSTED)
  64 /* For PLATFORM_HOSTED this buffer must be define here. */
  65 static unsigned char codecbuf[CODEC_SIZE];
  66 #else
  67 /* For PLATFORM_NATIVE this buffer is defined in *.lds files. */
  68 extern unsigned char codecbuf[];
  69 #endif
  70
  71 static size_t codec_size;
  72
  73 extern void* plugin_get_audio_buffer(size_t *buffer_size);
  74
  75 #if (CONFIG_PLATFORM & PLATFORM_NATIVE) && defined(HAVE_RECORDING)
  76 #undef open
  77 static int open(const char* pathname, int flags, ...)
  78 {
  79     return file_open(pathname, flags);
  80 }
  81 #endif
  82 struct codec_api ci = {
  83
  84     0,    /* filesize */
  85     0,    /* curpos */
  86     NULL, /* id3 */
  87     ERR_HANDLE_NOT_FOUND, /* audio_hid */
  88     NULL, /* struct dsp_config *dsp */
  89     NULL, /* codec_get_buffer */
  90     NULL, /* pcmbuf_insert */
  91     NULL, /* set_elapsed */
  92     NULL, /* read_filebuf */
  93     NULL, /* request_buffer */
  94     NULL, /* advance_buffer */
  95     NULL, /* seek_buffer */
  96     NULL, /* seek_complete */
  97     NULL, /* set_offset */
  98     NULL, /* configure */
  99     NULL, /* get_command */
 100
 101     /* kernel/ system */
 102 #if defined(CPU_ARM) && CONFIG_PLATFORM & PLATFORM_NATIVE
 103     __div0,
 104 #endif
 105     sleep,
 106     yield,
 107
 108 #if NUM_CORES > 1
 109     create_thread,
 110     thread_thaw,
 111     thread_wait,
 112     semaphore_init,
 113     semaphore_wait,
 114     semaphore_release,
 115 #endif
 116
 117     cpucache_flush,
 118     cpucache_invalidate,
 119
 120     /* strings and memory */
 121     strcpy,
 122     strlen,
 123     strcmp,
 124     strcat,
 125     memset,
 126     memcpy,
 127     memmove,
 128     memcmp,
 129     memchr,
 130     strcasestr,
 131 #if defined(DEBUG) || defined(SIMULATOR)
 132     debugf,
 133 #endif
 134 #ifdef ROCKBOX_HAS_LOGF
 135     logf,
 136 #endif
 137
 138     (qsort_func)qsort,
 139     &global_settings,
 140
 141 #ifdef RB_PROFILE
 142     profile_thread,
 143     profstop,
 144     __cyg_profile_func_enter,
 145     __cyg_profile_func_exit,
 146 #endif
 147
 148 #ifdef HAVE_RECORDING
 149     enc_get_inputs,
 150     enc_set_parameters,
 151     enc_get_chunk,
 152     enc_finish_chunk,
 153     enc_get_pcm_data,
 154     enc_unget_pcm_data,
 155
 156     /* file */
 157     (open_func)PREFIX(open),
 158     PREFIX(close),
 159     (read_func)PREFIX(read),
 160     PREFIX(lseek),
 161     (write_func)PREFIX(write),
 162     round_value_to_list32,
 163
 164 #endif /* HAVE_RECORDING */
 165
 166     /* new stuff at the end, sort into place next time
 167        the API gets incompatible */
 168 };
 169
 170 void codec_get_full_path(char *path, const char *codec_root_fn)
 171 {
 172     snprintf(path, MAX_PATH-1, "%s/%s." CODEC_EXTENSION,
 173              CODECS_DIR, codec_root_fn);
 174 }
 175
 176 /* Returns pointer to and size of free codec RAM. Aligns to CACHEALIGN_SIZE. */
 177 void *codec_get_buffer_callback(size_t *size)
 178 {
 179     void *buf = &codecbuf[codec_size];
 180     ssize_t s = CODEC_SIZE - codec_size;
 181
 182     if (s <= 0)
 183         return NULL;
 184
 185     *size = s;
 186     ALIGN_BUFFER(buf, *size, CACHEALIGN_SIZE);
 187
 188     return buf;
 189 }
 190
 191 /** codec loading and call interface **/
 192 static void *curr_handle = NULL;
 193 static struct codec_header *c_hdr = NULL;
 194
 195 static int codec_load_ram(struct codec_api *api)
 196 {
 197     struct lc_header *hdr;
 198
 199     c_hdr = lc_get_header(curr_handle);
 200     hdr   = c_hdr ? &c_hdr->lc_hdr : NULL;
 201
 202     if (hdr == NULL
 203         || (hdr->magic != CODEC_MAGIC
 204 #ifdef HAVE_RECORDING
 205              && hdr->magic != CODEC_ENC_MAGIC
 206 #endif
 207             )
 208         || hdr->target_id != TARGET_ID
 209 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 210         || hdr->load_addr != codecbuf
 211         || hdr->end_addr > codecbuf + CODEC_SIZE
 212 #endif
 213         )
 214     {
 215         logf("codec header error");
 216         lc_close(curr_handle);
 217         curr_handle = NULL;
 218         return CODEC_ERROR;
 219     }
 220
 221     if (hdr->api_version > CODEC_API_VERSION
 222         || hdr->api_version < CODEC_MIN_API_VERSION) {
 223         logf("codec api version error");
 224         lc_close(curr_handle);
 225         curr_handle = NULL;
 226         return CODEC_ERROR;
 227     }
 228
 229 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 230     codec_size = hdr->end_addr - codecbuf;
 231 #else
 232     codec_size = 0;
 233 #endif
 234
 235     *(c_hdr->api) = api;
 236
 237     logf("Codec: calling entrypoint");
 238     return c_hdr->entry_point(CODEC_LOAD);
 239 }
 240
 241 int codec_load_buf(int hid, struct codec_api *api)
 242 {
 243     int rc = bufread(hid, CODEC_SIZE, codecbuf);
 244
 245     if (rc < 0) {
 246         logf("Codec: cannot read buf handle");
 247         return CODEC_ERROR;
 248     }
 249
 250     curr_handle = lc_open_from_mem(codecbuf, rc);
 251
 252     if (curr_handle == NULL) {
 253         logf("Codec: load error");
 254         return CODEC_ERROR;
 255     }
 256
 257     return codec_load_ram(api);
 258 }
 259
 260 int codec_load_file(const char *plugin, struct codec_api *api)
 261 {
 262     char path[MAX_PATH];
 263
 264     codec_get_full_path(path, plugin);
 265
 266     curr_handle = lc_open(path, codecbuf, CODEC_SIZE);
 267
 268     if (curr_handle == NULL) {
 269         logf("Codec: cannot read file");
 270         return CODEC_ERROR;
 271     }
 272
 273     return codec_load_ram(api);
 274 }
 275
 276 int codec_run_proc(void)
 277 {
 278     if (curr_handle == NULL) {
 279         logf("Codec: no codec to run");
 280         return CODEC_ERROR;
 281     }
 282
 283     logf("Codec: entering run state");
 284     return c_hdr->run_proc();
 285 }
 286
 287 int codec_close(void)
 288 {
 289     int status = CODEC_OK;
 290
 291     if (curr_handle != NULL) {
 292         logf("Codec: cleaning up");
 293         status = c_hdr->entry_point(CODEC_UNLOAD);
 294         lc_close(curr_handle);
 295         curr_handle = NULL;
 296     }
 297
 298     return status;
 299 }