v811_spc009/vendor/huanglong/sample/audio/karaoke/karaoke.c

/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2020-2021. All rights reserved.
 * Description: karaoke sample
 * Author: audio
 * Create: 2020-04-03
 */

#include <stdio.h>
#include <stdlib.h>
#include "securec.h"

#include "adp_common_ext.h"
#include "uapi_sound.h"
#include "karaoke.h"

static td_s32 mixengine_snd_init(td_void)
{
    td_s32 ret;
    uapi_snd_attr attr;

    ret = uapi_snd_init();
    if (ret != TD_SUCCESS) {
        printf("call uapi_SND_Init failed.\n");
        return ret;
    }

    ret = uapi_snd_get_default_open_attr(UAPI_SND_0, &attr);
    if (ret != TD_SUCCESS) {
        printf("call uapi_snd_get_default_open_attr failed.\n");
        return ret;
    }

    ret = uapi_snd_open(UAPI_SND_0, &attr);
    if (ret != TD_SUCCESS) {
        printf("call uapi_snd_open failed. ret(%d)\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_void mixengine_snd_deinit(td_void)
{
    td_s32 ret;

    ret = uapi_snd_close(UAPI_SND_0);
    if (ret != TD_SUCCESS) {
        printf("call uapi_snd_close failed.\n");
        return;
    }

    ret = uapi_snd_deinit();
    if (ret != TD_SUCCESS) {
        printf("call uapi_snd_deinit failed.\n");
        return;
    }
}

static td_s32 sample_capture_init(td_char **argv, td_handle *track_id)
{
    td_s32 ret;
    uapi_audio_track_attr track_attr;
    td_u32 card;
    td_bool sync = TD_TRUE;

    card = (td_u32)strtol(argv[1], NULL, 10);             /* 10 is Dec */
    ret = usb_mic_dev_init(card);
    if (ret != TD_SUCCESS) {
        printf("%s[%d]: call usb_mic_dev_init failed\n", __FUNCTION__, __LINE__);
        return ret;
    }

    ret = mixengine_snd_init();
    if (ret != TD_SUCCESS) {
        printf("mixengine_snd_init fail!\n");
        usb_mic_dev_deinit();
        return ret;
    }

    ret = uapi_snd_get_default_track_attr(UAPI_SND_TRACK_TYPE_LOWLATENCY, &track_attr);
    if (ret != TD_SUCCESS) {
        printf("uapi_snd_get_default_track_attr fail!\n");
        mixengine_snd_deinit();
        usb_mic_dev_deinit();
        return ret;
    }

    sync = !!((td_u32)strtol(argv[2], NULL, 10) == 0);    /* 2 is num, 10 is Dec */
    if (sync == TD_FALSE) {
        track_attr.sync_port_mute = TD_FALSE;
        track_attr.sync_port_vol = TD_FALSE;
    }

    ret = uapi_snd_create_track(UAPI_SND_0, &track_attr, track_id);
    if (ret != TD_SUCCESS) {
        printf("uapi_snd_create_track fail!\n");
        mixengine_snd_deinit();
        usb_mic_dev_deinit();
        return ret;
    }

    return TD_SUCCESS;
}
static td_void sample_capture_deinit(td_handle track_id)
{
    td_s32 ret;

    ret = uapi_snd_destroy_track(track_id);
    if (ret != TD_SUCCESS) {
        printf("call uapi_snd_destroy_track failed\n");
        return;
    }

    mixengine_snd_deinit();
}

static td_void capture_ctx_init(sample_capture_ctx *ctx)
{
    ctx->ao_frame.bit_depth = UAPI_AUDIO_BIT_DEPTH_16;
    ctx->ao_frame.channels = CHANNELS_2;
    ctx->ao_frame.interleaved = TD_TRUE;
    ctx->ao_frame.sample_rate = UAPI_AUDIO_SAMPLE_RATE_48K;
    ctx->ao_frame.pts = 0xffffffffffffffff;
    ctx->ao_frame.bits_buffer = TD_NULL;
    ctx->ao_frame.frame_index = 0;
    ctx->ao_frame.pcm_samples = DEFAULT_PCM_SAMPLES;
    ctx->ao_frame.iec_data_type = 0;
}

td_s32 main(td_s32 argc, td_char **argv)
{
    td_s32 ret;
    td_char input_cmd[INPUT_CMD_LENGTH];
    sample_capture_ctx ctx;

    if (argc < 3) { /* 3 is max input num */
        printf("======please input card num and sync attr======\n");
        return -1;
    }

    ret = memset_s(&ctx, sizeof(ctx), 0, sizeof(sample_capture_ctx));
    if (ret != EOK) {
        printf("call memset_s failed(0x%x)\n", ret);
        return ret;
    }

    sample_capture_init(argv, &ctx.track_id);

    capture_ctx_init(&ctx);

    capture_sample_start(&ctx);

    while (1) {
        printf("please input the q to quit!\n");
        (td_void)fgets((char *)(input_cmd), (sizeof(input_cmd) - 1), stdin);

        if (input_cmd[0] == 'q') {
            printf("prepare to quit!\n");
            break;
        }
    }

    capture_sample_stop(&ctx);
    sample_capture_deinit(ctx.track_id);
    return TD_SUCCESS;
}